1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
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_runner_util.h"
6
7 #include <utility>
8
9 #include "base/bind.h"
10 #include "base/location.h"
11 #include "base/run_loop.h"
12 #include "testing/gtest/include/gtest/gtest.h"
13
14 namespace base {
15
16 namespace {
17
ReturnFourtyTwo()18 int ReturnFourtyTwo() {
19 return 42;
20 }
21
StoreValue(int * destination,int value)22 void StoreValue(int* destination, int value) {
23 *destination = value;
24 }
25
StoreDoubleValue(double * destination,double value)26 void StoreDoubleValue(double* destination, double value) {
27 *destination = value;
28 }
29
30 int g_foo_destruct_count = 0;
31 int g_foo_free_count = 0;
32
33 struct Foo {
~Foobase::__anon7354e4fa0111::Foo34 ~Foo() {
35 ++g_foo_destruct_count;
36 }
37 };
38
CreateFoo()39 std::unique_ptr<Foo> CreateFoo() {
40 return std::unique_ptr<Foo>(new Foo);
41 }
42
ExpectFoo(std::unique_ptr<Foo> foo)43 void ExpectFoo(std::unique_ptr<Foo> foo) {
44 EXPECT_TRUE(foo.get());
45 std::unique_ptr<Foo> local_foo(std::move(foo));
46 EXPECT_TRUE(local_foo.get());
47 EXPECT_FALSE(foo.get());
48 }
49
50 struct FooDeleter {
operator ()base::__anon7354e4fa0111::FooDeleter51 void operator()(Foo* foo) const {
52 ++g_foo_free_count;
53 delete foo;
54 };
55 };
56
CreateScopedFoo()57 std::unique_ptr<Foo, FooDeleter> CreateScopedFoo() {
58 return std::unique_ptr<Foo, FooDeleter>(new Foo);
59 }
60
ExpectScopedFoo(std::unique_ptr<Foo,FooDeleter> foo)61 void ExpectScopedFoo(std::unique_ptr<Foo, FooDeleter> foo) {
62 EXPECT_TRUE(foo.get());
63 std::unique_ptr<Foo, FooDeleter> local_foo(std::move(foo));
64 EXPECT_TRUE(local_foo.get());
65 EXPECT_FALSE(foo.get());
66 }
67
68 } // namespace
69
TEST(TaskRunnerHelpersTest,PostTaskAndReplyWithResult)70 TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResult) {
71 int result = 0;
72
73 MessageLoop message_loop;
74 PostTaskAndReplyWithResult(message_loop.task_runner().get(), FROM_HERE,
75 Bind(&ReturnFourtyTwo),
76 Bind(&StoreValue, &result));
77
78 RunLoop().RunUntilIdle();
79
80 EXPECT_EQ(42, result);
81 }
82
TEST(TaskRunnerHelpersTest,PostTaskAndReplyWithResultImplicitConvert)83 TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultImplicitConvert) {
84 double result = 0;
85
86 MessageLoop message_loop;
87 PostTaskAndReplyWithResult(message_loop.task_runner().get(), FROM_HERE,
88 Bind(&ReturnFourtyTwo),
89 Bind(&StoreDoubleValue, &result));
90
91 RunLoop().RunUntilIdle();
92
93 EXPECT_DOUBLE_EQ(42.0, result);
94 }
95
TEST(TaskRunnerHelpersTest,PostTaskAndReplyWithResultPassed)96 TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultPassed) {
97 g_foo_destruct_count = 0;
98 g_foo_free_count = 0;
99
100 MessageLoop message_loop;
101 PostTaskAndReplyWithResult(message_loop.task_runner().get(), FROM_HERE,
102 Bind(&CreateFoo), Bind(&ExpectFoo));
103
104 RunLoop().RunUntilIdle();
105
106 EXPECT_EQ(1, g_foo_destruct_count);
107 EXPECT_EQ(0, g_foo_free_count);
108 }
109
TEST(TaskRunnerHelpersTest,PostTaskAndReplyWithResultPassedFreeProc)110 TEST(TaskRunnerHelpersTest, PostTaskAndReplyWithResultPassedFreeProc) {
111 g_foo_destruct_count = 0;
112 g_foo_free_count = 0;
113
114 MessageLoop message_loop;
115 PostTaskAndReplyWithResult(message_loop.task_runner().get(), FROM_HERE,
116 Bind(&CreateScopedFoo), Bind(&ExpectScopedFoo));
117
118 RunLoop().RunUntilIdle();
119
120 EXPECT_EQ(1, g_foo_destruct_count);
121 EXPECT_EQ(1, g_foo_free_count);
122 }
123
124 } // namespace base
125