1 // Copyright 2017 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 "mojo/public/cpp/bindings/callback_helpers.h"
6
7 #include <memory>
8 #include <string>
9 #include <utility>
10
11 #include "base/bind.h"
12 #include "base/bind_helpers.h"
13 #include "base/callback.h"
14 #include "base/memory/ptr_util.h"
15 #include "testing/gtest/include/gtest/gtest.h"
16
17 namespace mojo {
18
19 namespace {
20
SetBool(bool * var,bool val)21 void SetBool(bool* var, bool val) {
22 *var = val;
23 }
24
SetBoolFromRawPtr(bool * var,bool * val)25 void SetBoolFromRawPtr(bool* var, bool* val) {
26 *var = *val;
27 }
28
SetIntegers(int * a_var,int * b_var,int a_val,int b_val)29 void SetIntegers(int* a_var, int* b_var, int a_val, int b_val) {
30 *a_var = a_val;
31 *b_var = b_val;
32 }
33
SetIntegerFromUniquePtr(int * var,std::unique_ptr<int> val)34 void SetIntegerFromUniquePtr(int* var, std::unique_ptr<int> val) {
35 *var = *val;
36 }
37
SetString(std::string * var,const std::string val)38 void SetString(std::string* var, const std::string val) {
39 *var = val;
40 }
41
CallClosure(base::OnceClosure cl)42 void CallClosure(base::OnceClosure cl) {
43 std::move(cl).Run();
44 }
45
46 } // namespace
47
TEST(CallbackWithDeleteTest,SetIntegers_Run)48 TEST(CallbackWithDeleteTest, SetIntegers_Run) {
49 int a = 0;
50 int b = 0;
51 auto cb =
52 WrapCallbackWithDropHandler(base::BindOnce(&SetIntegers, &a, &b),
53 base::BindOnce(&SetIntegers, &a, &b, 3, 4));
54 std::move(cb).Run(1, 2);
55 EXPECT_EQ(a, 1);
56 EXPECT_EQ(b, 2);
57 }
58
TEST(CallbackWithDeleteTest,SetIntegers_Destruction)59 TEST(CallbackWithDeleteTest, SetIntegers_Destruction) {
60 int a = 0;
61 int b = 0;
62 {
63 auto cb =
64 WrapCallbackWithDropHandler(base::BindOnce(&SetIntegers, &a, &b),
65 base::BindOnce(&SetIntegers, &a, &b, 3, 4));
66 }
67 EXPECT_EQ(a, 3);
68 EXPECT_EQ(b, 4);
69 }
70
TEST(CallbackWithDefaultTest,CallClosure_Run)71 TEST(CallbackWithDefaultTest, CallClosure_Run) {
72 int a = 0;
73 int b = 0;
74 auto cb = WrapCallbackWithDefaultInvokeIfNotRun(
75 base::BindOnce(&CallClosure), base::BindOnce(&SetIntegers, &a, &b, 3, 4));
76 std::move(cb).Run(base::BindOnce(&SetIntegers, &a, &b, 1, 2));
77 EXPECT_EQ(a, 1);
78 EXPECT_EQ(b, 2);
79 }
80
TEST(CallbackWithDefaultTest,CallClosure_Destruction)81 TEST(CallbackWithDefaultTest, CallClosure_Destruction) {
82 int a = 0;
83 int b = 0;
84 {
85 auto cb = WrapCallbackWithDefaultInvokeIfNotRun(
86 base::BindOnce(&CallClosure),
87 base::BindOnce(&SetIntegers, &a, &b, 3, 4));
88 }
89 EXPECT_EQ(a, 3);
90 EXPECT_EQ(b, 4);
91 }
92
TEST(CallbackWithDefaultTest,Closure_Run)93 TEST(CallbackWithDefaultTest, Closure_Run) {
94 bool a = false;
95 auto cb =
96 WrapCallbackWithDefaultInvokeIfNotRun(base::BindOnce(&SetBool, &a, true));
97 std::move(cb).Run();
98 EXPECT_TRUE(a);
99 }
100
TEST(CallbackWithDefaultTest,Closure_Destruction)101 TEST(CallbackWithDefaultTest, Closure_Destruction) {
102 bool a = false;
103 {
104 auto cb = WrapCallbackWithDefaultInvokeIfNotRun(
105 base::BindOnce(&SetBool, &a, true));
106 }
107 EXPECT_TRUE(a);
108 }
109
TEST(CallbackWithDefaultTest,SetBool_Run)110 TEST(CallbackWithDefaultTest, SetBool_Run) {
111 bool a = false;
112 auto cb =
113 WrapCallbackWithDefaultInvokeIfNotRun(base::BindOnce(&SetBool, &a), true);
114 std::move(cb).Run(true);
115 EXPECT_TRUE(a);
116 }
117
TEST(CallbackWithDefaultTest,SetBoolFromRawPtr_Run)118 TEST(CallbackWithDefaultTest, SetBoolFromRawPtr_Run) {
119 bool a = false;
120 bool* b = new bool(false);
121 bool c = true;
122 auto cb = WrapCallbackWithDefaultInvokeIfNotRun(
123 base::BindOnce(&SetBoolFromRawPtr, &a), base::Owned(b));
124 std::move(cb).Run(&c);
125 EXPECT_TRUE(a);
126 }
127
TEST(CallbackWithDefaultTest,SetBoolFromRawPtr_Destruction)128 TEST(CallbackWithDefaultTest, SetBoolFromRawPtr_Destruction) {
129 bool a = false;
130 bool* b = new bool(true);
131 {
132 auto cb = WrapCallbackWithDefaultInvokeIfNotRun(
133 base::BindOnce(&SetBoolFromRawPtr, &a), base::Owned(b));
134 }
135 EXPECT_TRUE(a);
136 }
137
TEST(CallbackWithDefaultTest,SetBool_Destruction)138 TEST(CallbackWithDefaultTest, SetBool_Destruction) {
139 bool a = false;
140 {
141 auto cb = WrapCallbackWithDefaultInvokeIfNotRun(
142 base::BindOnce(&SetBool, &a), true);
143 }
144 EXPECT_TRUE(a);
145 }
146
TEST(CallbackWithDefaultTest,SetIntegers_Run)147 TEST(CallbackWithDefaultTest, SetIntegers_Run) {
148 int a = 0;
149 int b = 0;
150 auto cb = WrapCallbackWithDefaultInvokeIfNotRun(
151 base::BindOnce(&SetIntegers, &a, &b), 3, 4);
152 std::move(cb).Run(1, 2);
153 EXPECT_EQ(a, 1);
154 EXPECT_EQ(b, 2);
155 }
156
TEST(CallbackWithDefaultTest,SetIntegers_Destruction)157 TEST(CallbackWithDefaultTest, SetIntegers_Destruction) {
158 int a = 0;
159 int b = 0;
160 {
161 auto cb = WrapCallbackWithDefaultInvokeIfNotRun(
162 base::BindOnce(&SetIntegers, &a, &b), 3, 4);
163 }
164 EXPECT_EQ(a, 3);
165 EXPECT_EQ(b, 4);
166 }
167
TEST(CallbackWithDefaultTest,SetIntegerFromUniquePtr_Run)168 TEST(CallbackWithDefaultTest, SetIntegerFromUniquePtr_Run) {
169 int a = 0;
170 auto cb = WrapCallbackWithDefaultInvokeIfNotRun(
171 base::BindOnce(&SetIntegerFromUniquePtr, &a), std::make_unique<int>(1));
172 std::move(cb).Run(std::make_unique<int>(2));
173 EXPECT_EQ(a, 2);
174 }
175
TEST(CallbackWithDefaultTest,SetIntegerFromUniquePtr_Destruction)176 TEST(CallbackWithDefaultTest, SetIntegerFromUniquePtr_Destruction) {
177 int a = 0;
178 {
179 auto cb = WrapCallbackWithDefaultInvokeIfNotRun(
180 base::BindOnce(&SetIntegerFromUniquePtr, &a), std::make_unique<int>(1));
181 }
182 EXPECT_EQ(a, 1);
183 }
184
TEST(CallbackWithDefaultTest,SetString_Run)185 TEST(CallbackWithDefaultTest, SetString_Run) {
186 std::string a;
187 auto cb = WrapCallbackWithDefaultInvokeIfNotRun(
188 base::BindOnce(&SetString, &a), "hello");
189 std::move(cb).Run("world");
190 EXPECT_EQ(a, "world");
191 }
192
TEST(CallbackWithDefaultTest,SetString_Destruction)193 TEST(CallbackWithDefaultTest, SetString_Destruction) {
194 std::string a;
195 {
196 auto cb = WrapCallbackWithDefaultInvokeIfNotRun(
197 base::BindOnce(&SetString, &a), "hello");
198 }
199 EXPECT_EQ(a, "hello");
200 }
201
202 } // namespace mojo
203