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/callback.h"
6
7 #include <gtest/gtest.h>
8
9 #include "base/bind.h"
10 #include "base/callback_internal.h"
11 #include "base/memory/ref_counted.h"
12 #include "base/memory/scoped_ptr.h"
13
14 namespace base {
15
16 namespace {
17
18 struct FakeInvoker {
19 // MSVC 2013 doesn't support Type Alias of function types.
20 // Revisit this after we update it to newer version.
21 typedef void RunType(internal::BindStateBase*);
Runbase::__anonc270cd450111::FakeInvoker22 static void Run(internal::BindStateBase*) {
23 }
24 };
25
26 } // namespace
27
28 namespace internal {
29
30 // White-box testpoints to inject into a Callback<> object for checking
31 // comparators and emptiness APIs. Use a BindState that is specialized
32 // based on a type we declared in the anonymous namespace above to remove any
33 // chance of colliding with another instantiation and breaking the
34 // one-definition-rule.
35 template <>
36 struct BindState<void(), void(), FakeInvoker>
37 : public BindStateBase {
38 public:
BindStatebase::internal::BindState39 BindState() : BindStateBase(&Destroy) {}
40 using InvokerType = FakeInvoker;
41 private:
~BindStatebase::internal::BindState42 ~BindState() {}
Destroybase::internal::BindState43 static void Destroy(BindStateBase* self) {
44 delete static_cast<BindState*>(self);
45 }
46 };
47
48 template <>
49 struct BindState<void(), void(), FakeInvoker, FakeInvoker>
50 : public BindStateBase {
51 public:
BindStatebase::internal::BindState52 BindState() : BindStateBase(&Destroy) {}
53 using InvokerType = FakeInvoker;
54 private:
~BindStatebase::internal::BindState55 ~BindState() {}
Destroybase::internal::BindState56 static void Destroy(BindStateBase* self) {
57 delete static_cast<BindState*>(self);
58 }
59 };
60 } // namespace internal
61
62 namespace {
63
64 using FakeBindState1 = internal::BindState<void(), void(), FakeInvoker>;
65 using FakeBindState2 =
66 internal::BindState<void(), void(), FakeInvoker, FakeInvoker>;
67
68 class CallbackTest : public ::testing::Test {
69 public:
CallbackTest()70 CallbackTest()
71 : callback_a_(new FakeBindState1()),
72 callback_b_(new FakeBindState2()) {
73 }
74
~CallbackTest()75 ~CallbackTest() override {}
76
77 protected:
78 Callback<void()> callback_a_;
79 const Callback<void()> callback_b_; // Ensure APIs work with const.
80 Callback<void()> null_callback_;
81 };
82
83 // Ensure we can create unbound callbacks. We need this to be able to store
84 // them in class members that can be initialized later.
TEST_F(CallbackTest,DefaultConstruction)85 TEST_F(CallbackTest, DefaultConstruction) {
86 Callback<void()> c0;
87 Callback<void(int)> c1;
88 Callback<void(int,int)> c2;
89 Callback<void(int,int,int)> c3;
90 Callback<void(int,int,int,int)> c4;
91 Callback<void(int,int,int,int,int)> c5;
92 Callback<void(int,int,int,int,int,int)> c6;
93
94 EXPECT_TRUE(c0.is_null());
95 EXPECT_TRUE(c1.is_null());
96 EXPECT_TRUE(c2.is_null());
97 EXPECT_TRUE(c3.is_null());
98 EXPECT_TRUE(c4.is_null());
99 EXPECT_TRUE(c5.is_null());
100 EXPECT_TRUE(c6.is_null());
101 }
102
TEST_F(CallbackTest,IsNull)103 TEST_F(CallbackTest, IsNull) {
104 EXPECT_TRUE(null_callback_.is_null());
105 EXPECT_FALSE(callback_a_.is_null());
106 EXPECT_FALSE(callback_b_.is_null());
107 }
108
TEST_F(CallbackTest,Equals)109 TEST_F(CallbackTest, Equals) {
110 EXPECT_TRUE(callback_a_.Equals(callback_a_));
111 EXPECT_FALSE(callback_a_.Equals(callback_b_));
112 EXPECT_FALSE(callback_b_.Equals(callback_a_));
113
114 // We should compare based on instance, not type.
115 Callback<void()> callback_c(new FakeBindState1());
116 Callback<void()> callback_a2 = callback_a_;
117 EXPECT_TRUE(callback_a_.Equals(callback_a2));
118 EXPECT_FALSE(callback_a_.Equals(callback_c));
119
120 // Empty, however, is always equal to empty.
121 Callback<void()> empty2;
122 EXPECT_TRUE(null_callback_.Equals(empty2));
123 }
124
TEST_F(CallbackTest,Reset)125 TEST_F(CallbackTest, Reset) {
126 // Resetting should bring us back to empty.
127 ASSERT_FALSE(callback_a_.is_null());
128 ASSERT_FALSE(callback_a_.Equals(null_callback_));
129
130 callback_a_.Reset();
131
132 EXPECT_TRUE(callback_a_.is_null());
133 EXPECT_TRUE(callback_a_.Equals(null_callback_));
134 }
135
136 struct TestForReentrancy {
TestForReentrancybase::__anonc270cd450211::TestForReentrancy137 TestForReentrancy()
138 : cb_already_run(false),
139 cb(Bind(&TestForReentrancy::AssertCBIsNull, Unretained(this))) {
140 }
AssertCBIsNullbase::__anonc270cd450211::TestForReentrancy141 void AssertCBIsNull() {
142 ASSERT_TRUE(cb.is_null());
143 cb_already_run = true;
144 }
145 bool cb_already_run;
146 Closure cb;
147 };
148
149 class CallbackOwner : public base::RefCounted<CallbackOwner> {
150 public:
CallbackOwner(bool * deleted)151 explicit CallbackOwner(bool* deleted) {
152 callback_ = Bind(&CallbackOwner::Unused, this);
153 deleted_ = deleted;
154 }
Reset()155 void Reset() {
156 callback_.Reset();
157 // We are deleted here if no-one else had a ref to us.
158 }
159
160 private:
161 friend class base::RefCounted<CallbackOwner>;
~CallbackOwner()162 virtual ~CallbackOwner() {
163 *deleted_ = true;
164 }
Unused()165 void Unused() {
166 FAIL() << "Should never be called";
167 }
168
169 Closure callback_;
170 bool* deleted_;
171 };
172
TEST_F(CallbackTest,CallbackHasLastRefOnContainingObject)173 TEST_F(CallbackTest, CallbackHasLastRefOnContainingObject) {
174 bool deleted = false;
175 CallbackOwner* owner = new CallbackOwner(&deleted);
176 owner->Reset();
177 ASSERT_TRUE(deleted);
178 }
179
180 } // namespace
181 } // namespace base
182