1 // Copyright 2012 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/task/task_runner.h"
6
7 #include <memory>
8 #include <utility>
9
10 #include "base/functional/bind.h"
11 #include "base/location.h"
12 #include "base/run_loop.h"
13 #include "base/task/single_thread_task_runner.h"
14 #include "base/test/task_environment.h"
15 #include "testing/gtest/include/gtest/gtest.h"
16
17 namespace base {
18
19 namespace {
20
ReturnFourtyTwo()21 int ReturnFourtyTwo() {
22 return 42;
23 }
24
StoreValue(int * destination,int value)25 void StoreValue(int* destination, int value) {
26 *destination = value;
27 }
28
StoreDoubleValue(double * destination,double value)29 void StoreDoubleValue(double* destination, double value) {
30 *destination = value;
31 }
32
33 int g_foo_destruct_count = 0;
34 int g_foo_free_count = 0;
35
36 struct Foo {
~Foobase::__anon5ab0b62c0111::Foo37 ~Foo() { ++g_foo_destruct_count; }
38 };
39
CreateFoo()40 std::unique_ptr<Foo> CreateFoo() {
41 return std::make_unique<Foo>();
42 }
43
ExpectFoo(std::unique_ptr<Foo> foo)44 void ExpectFoo(std::unique_ptr<Foo> foo) {
45 EXPECT_TRUE(foo.get());
46 std::unique_ptr<Foo> local_foo(std::move(foo));
47 EXPECT_TRUE(local_foo.get());
48 EXPECT_FALSE(foo.get());
49 }
50
51 struct FooDeleter {
operator ()base::__anon5ab0b62c0111::FooDeleter52 void operator()(Foo* foo) const {
53 ++g_foo_free_count;
54 delete foo;
55 }
56 };
57
CreateScopedFoo()58 std::unique_ptr<Foo, FooDeleter> CreateScopedFoo() {
59 return std::unique_ptr<Foo, FooDeleter>(new Foo);
60 }
61
ExpectScopedFoo(std::unique_ptr<Foo,FooDeleter> foo)62 void ExpectScopedFoo(std::unique_ptr<Foo, FooDeleter> foo) {
63 EXPECT_TRUE(foo.get());
64 std::unique_ptr<Foo, FooDeleter> local_foo(std::move(foo));
65 EXPECT_TRUE(local_foo.get());
66 EXPECT_FALSE(foo.get());
67 }
68
69 struct FooWithoutDefaultConstructor {
FooWithoutDefaultConstructorbase::__anon5ab0b62c0111::FooWithoutDefaultConstructor70 explicit FooWithoutDefaultConstructor(int value) : value(value) {}
71 int value;
72 };
73
CreateFooWithoutDefaultConstructor(int value)74 FooWithoutDefaultConstructor CreateFooWithoutDefaultConstructor(int value) {
75 return FooWithoutDefaultConstructor(value);
76 }
77
SaveFooWithoutDefaultConstructor(int * output_value,FooWithoutDefaultConstructor input)78 void SaveFooWithoutDefaultConstructor(int* output_value,
79 FooWithoutDefaultConstructor input) {
80 *output_value = input.value;
81 }
82
83 class TaskRunnerTest : public testing::Test {
84 public:
85 TaskRunnerTest() = default;
86
SetUp()87 void SetUp() override {
88 g_foo_destruct_count = 0;
89 g_foo_free_count = 0;
90 }
91 };
92
93 } // namespace
94
TEST_F(TaskRunnerTest,PostTaskAndReplyWithResult)95 TEST_F(TaskRunnerTest, PostTaskAndReplyWithResult) {
96 int result = 0;
97
98 test::SingleThreadTaskEnvironment task_environment;
99 SingleThreadTaskRunner::GetCurrentDefault()->PostTaskAndReplyWithResult(
100 FROM_HERE, BindOnce(&ReturnFourtyTwo), BindOnce(&StoreValue, &result));
101
102 RunLoop().RunUntilIdle();
103
104 EXPECT_EQ(42, result);
105 }
106
TEST_F(TaskRunnerTest,PostTaskAndReplyWithResultRepeatingCallbacks)107 TEST_F(TaskRunnerTest, PostTaskAndReplyWithResultRepeatingCallbacks) {
108 int result = 0;
109
110 test::SingleThreadTaskEnvironment task_environment;
111 SingleThreadTaskRunner::GetCurrentDefault()->PostTaskAndReplyWithResult(
112 FROM_HERE, BindRepeating(&ReturnFourtyTwo),
113 BindRepeating(&StoreValue, &result));
114
115 RunLoop().RunUntilIdle();
116
117 EXPECT_EQ(42, result);
118 }
119
TEST_F(TaskRunnerTest,PostTaskAndReplyWithResultImplicitConvert)120 TEST_F(TaskRunnerTest, PostTaskAndReplyWithResultImplicitConvert) {
121 double result = 0;
122
123 test::SingleThreadTaskEnvironment task_environment;
124 SingleThreadTaskRunner::GetCurrentDefault()->PostTaskAndReplyWithResult(
125 FROM_HERE, BindOnce(&ReturnFourtyTwo),
126 BindOnce(&StoreDoubleValue, &result));
127
128 RunLoop().RunUntilIdle();
129
130 EXPECT_DOUBLE_EQ(42.0, result);
131 }
132
TEST_F(TaskRunnerTest,PostTaskAndReplyWithResultPassed)133 TEST_F(TaskRunnerTest, PostTaskAndReplyWithResultPassed) {
134 test::SingleThreadTaskEnvironment task_environment;
135 SingleThreadTaskRunner::GetCurrentDefault()->PostTaskAndReplyWithResult(
136 FROM_HERE, BindOnce(&CreateFoo), BindOnce(&ExpectFoo));
137
138 RunLoop().RunUntilIdle();
139
140 EXPECT_EQ(1, g_foo_destruct_count);
141 EXPECT_EQ(0, g_foo_free_count);
142 }
143
TEST_F(TaskRunnerTest,PostTaskAndReplyWithResultPassedFreeProc)144 TEST_F(TaskRunnerTest, PostTaskAndReplyWithResultPassedFreeProc) {
145 test::SingleThreadTaskEnvironment task_environment;
146 SingleThreadTaskRunner::GetCurrentDefault()->PostTaskAndReplyWithResult(
147 FROM_HERE, BindOnce(&CreateScopedFoo), BindOnce(&ExpectScopedFoo));
148
149 RunLoop().RunUntilIdle();
150
151 EXPECT_EQ(1, g_foo_destruct_count);
152 EXPECT_EQ(1, g_foo_free_count);
153 }
154
TEST_F(TaskRunnerTest,PostTaskAndReplyWithResultWithoutDefaultConstructor)155 TEST_F(TaskRunnerTest, PostTaskAndReplyWithResultWithoutDefaultConstructor) {
156 const int kSomeVal = 17;
157
158 test::SingleThreadTaskEnvironment task_environment;
159 int actual = 0;
160
161 SingleThreadTaskRunner::GetCurrentDefault()->PostTaskAndReplyWithResult(
162 FROM_HERE, BindOnce(&CreateFooWithoutDefaultConstructor, kSomeVal),
163 BindOnce(&SaveFooWithoutDefaultConstructor, &actual));
164
165 RunLoop().RunUntilIdle();
166
167 EXPECT_EQ(kSomeVal, actual);
168 }
169
170 } // namespace base
171