1// Copyright 2013 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_list.h"
6
7#include <memory>
8#include <utility>
9
10#include "base/bind.h"
11#include "base/bind_helpers.h"
12#include "base/macros.h"
13#include "testing/gtest/include/gtest/gtest.h"
14
15namespace base {
16namespace {
17
18class Listener {
19 public:
20  Listener() : total_(0), scaler_(1) {}
21  explicit Listener(int scaler) : total_(0), scaler_(scaler) {}
22  void IncrementTotal() { total_++; }
23  void IncrementByMultipleOfScaler(int x) { total_ += x * scaler_; }
24
25  int total() const { return total_; }
26
27 private:
28  int total_;
29  int scaler_;
30  DISALLOW_COPY_AND_ASSIGN(Listener);
31};
32
33class Remover {
34 public:
35  Remover() : total_(0) {}
36  void IncrementTotalAndRemove() {
37    total_++;
38    removal_subscription_.reset();
39  }
40  void SetSubscriptionToRemove(
41      std::unique_ptr<CallbackList<void(void)>::Subscription> sub) {
42    removal_subscription_ = std::move(sub);
43  }
44
45  int total() const { return total_; }
46
47 private:
48  int total_;
49  std::unique_ptr<CallbackList<void(void)>::Subscription> removal_subscription_;
50  DISALLOW_COPY_AND_ASSIGN(Remover);
51};
52
53class Adder {
54 public:
55  explicit Adder(CallbackList<void(void)>* cb_reg)
56      : added_(false),
57        total_(0),
58        cb_reg_(cb_reg) {
59  }
60  void AddCallback() {
61    if (!added_) {
62      added_ = true;
63      subscription_ =
64          cb_reg_->Add(Bind(&Adder::IncrementTotal, Unretained(this)));
65    }
66  }
67  void IncrementTotal() { total_++; }
68
69  bool added() const { return added_; }
70
71  int total() const { return total_; }
72
73 private:
74  bool added_;
75  int total_;
76  CallbackList<void(void)>* cb_reg_;
77  std::unique_ptr<CallbackList<void(void)>::Subscription> subscription_;
78  DISALLOW_COPY_AND_ASSIGN(Adder);
79};
80
81class Summer {
82 public:
83  Summer() : value_(0) {}
84
85  void AddOneParam(int a) { value_ = a; }
86  void AddTwoParam(int a, int b) { value_ = a + b; }
87  void AddThreeParam(int a, int b, int c) { value_ = a + b + c; }
88  void AddFourParam(int a, int b, int c, int d) { value_ = a + b + c + d; }
89  void AddFiveParam(int a, int b, int c, int d, int e) {
90    value_ = a + b + c + d + e;
91  }
92  void AddSixParam(int a, int b, int c, int d, int e , int f) {
93    value_ = a + b + c + d + e + f;
94  }
95
96  int value() const { return value_; }
97
98 private:
99  int value_;
100  DISALLOW_COPY_AND_ASSIGN(Summer);
101};
102
103class Counter {
104 public:
105  Counter() : value_(0) {}
106
107  void Increment() { value_++; }
108
109  int value() const { return value_; }
110
111 private:
112  int value_;
113  DISALLOW_COPY_AND_ASSIGN(Counter);
114};
115
116// Sanity check that we can instantiate a CallbackList for each arity.
117TEST(CallbackListTest, ArityTest) {
118  Summer s;
119
120  CallbackList<void(int)> c1;
121  std::unique_ptr<CallbackList<void(int)>::Subscription> subscription1 =
122      c1.Add(Bind(&Summer::AddOneParam, Unretained(&s)));
123
124  c1.Notify(1);
125  EXPECT_EQ(1, s.value());
126
127  CallbackList<void(int, int)> c2;
128  std::unique_ptr<CallbackList<void(int, int)>::Subscription> subscription2 =
129      c2.Add(Bind(&Summer::AddTwoParam, Unretained(&s)));
130
131  c2.Notify(1, 2);
132  EXPECT_EQ(3, s.value());
133
134  CallbackList<void(int, int, int)> c3;
135  std::unique_ptr<CallbackList<void(int, int, int)>::Subscription>
136      subscription3 = c3.Add(Bind(&Summer::AddThreeParam, Unretained(&s)));
137
138  c3.Notify(1, 2, 3);
139  EXPECT_EQ(6, s.value());
140
141  CallbackList<void(int, int, int, int)> c4;
142  std::unique_ptr<CallbackList<void(int, int, int, int)>::Subscription>
143      subscription4 = c4.Add(Bind(&Summer::AddFourParam, Unretained(&s)));
144
145  c4.Notify(1, 2, 3, 4);
146  EXPECT_EQ(10, s.value());
147
148  CallbackList<void(int, int, int, int, int)> c5;
149  std::unique_ptr<CallbackList<void(int, int, int, int, int)>::Subscription>
150      subscription5 = c5.Add(Bind(&Summer::AddFiveParam, Unretained(&s)));
151
152  c5.Notify(1, 2, 3, 4, 5);
153  EXPECT_EQ(15, s.value());
154
155  CallbackList<void(int, int, int, int, int, int)> c6;
156  std::unique_ptr<
157      CallbackList<void(int, int, int, int, int, int)>::Subscription>
158      subscription6 = c6.Add(Bind(&Summer::AddSixParam, Unretained(&s)));
159
160  c6.Notify(1, 2, 3, 4, 5, 6);
161  EXPECT_EQ(21, s.value());
162}
163
164// Sanity check that closures added to the list will be run, and those removed
165// from the list will not be run.
166TEST(CallbackListTest, BasicTest) {
167  CallbackList<void(void)> cb_reg;
168  Listener a, b, c;
169
170  std::unique_ptr<CallbackList<void(void)>::Subscription> a_subscription =
171      cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a)));
172  std::unique_ptr<CallbackList<void(void)>::Subscription> b_subscription =
173      cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
174
175  EXPECT_TRUE(a_subscription.get());
176  EXPECT_TRUE(b_subscription.get());
177
178  cb_reg.Notify();
179
180  EXPECT_EQ(1, a.total());
181  EXPECT_EQ(1, b.total());
182
183  b_subscription.reset();
184
185  std::unique_ptr<CallbackList<void(void)>::Subscription> c_subscription =
186      cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&c)));
187
188  cb_reg.Notify();
189
190  EXPECT_EQ(2, a.total());
191  EXPECT_EQ(1, b.total());
192  EXPECT_EQ(1, c.total());
193
194  a_subscription.reset();
195  b_subscription.reset();
196  c_subscription.reset();
197}
198
199// Sanity check that callbacks with details added to the list will be run, with
200// the correct details, and those removed from the list will not be run.
201TEST(CallbackListTest, BasicTestWithParams) {
202  CallbackList<void(int)> cb_reg;
203  Listener a(1), b(-1), c(1);
204
205  std::unique_ptr<CallbackList<void(int)>::Subscription> a_subscription =
206      cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&a)));
207  std::unique_ptr<CallbackList<void(int)>::Subscription> b_subscription =
208      cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&b)));
209
210  EXPECT_TRUE(a_subscription.get());
211  EXPECT_TRUE(b_subscription.get());
212
213  cb_reg.Notify(10);
214
215  EXPECT_EQ(10, a.total());
216  EXPECT_EQ(-10, b.total());
217
218  b_subscription.reset();
219
220  std::unique_ptr<CallbackList<void(int)>::Subscription> c_subscription =
221      cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&c)));
222
223  cb_reg.Notify(10);
224
225  EXPECT_EQ(20, a.total());
226  EXPECT_EQ(-10, b.total());
227  EXPECT_EQ(10, c.total());
228
229  a_subscription.reset();
230  b_subscription.reset();
231  c_subscription.reset();
232}
233
234// Test the a callback can remove itself or a different callback from the list
235// during iteration without invalidating the iterator.
236TEST(CallbackListTest, RemoveCallbacksDuringIteration) {
237  CallbackList<void(void)> cb_reg;
238  Listener a, b;
239  Remover remover_1, remover_2;
240
241  std::unique_ptr<CallbackList<void(void)>::Subscription> remover_1_sub =
242      cb_reg.Add(
243          Bind(&Remover::IncrementTotalAndRemove, Unretained(&remover_1)));
244  std::unique_ptr<CallbackList<void(void)>::Subscription> remover_2_sub =
245      cb_reg.Add(
246          Bind(&Remover::IncrementTotalAndRemove, Unretained(&remover_2)));
247  std::unique_ptr<CallbackList<void(void)>::Subscription> a_subscription =
248      cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a)));
249  std::unique_ptr<CallbackList<void(void)>::Subscription> b_subscription =
250      cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
251
252  // |remover_1| will remove itself.
253  remover_1.SetSubscriptionToRemove(std::move(remover_1_sub));
254  // |remover_2| will remove a.
255  remover_2.SetSubscriptionToRemove(std::move(a_subscription));
256
257  cb_reg.Notify();
258
259  // |remover_1| runs once (and removes itself), |remover_2| runs once (and
260  // removes a), |a| never runs, and |b| runs once.
261  EXPECT_EQ(1, remover_1.total());
262  EXPECT_EQ(1, remover_2.total());
263  EXPECT_EQ(0, a.total());
264  EXPECT_EQ(1, b.total());
265
266  cb_reg.Notify();
267
268  // Only |remover_2| and |b| run this time.
269  EXPECT_EQ(1, remover_1.total());
270  EXPECT_EQ(2, remover_2.total());
271  EXPECT_EQ(0, a.total());
272  EXPECT_EQ(2, b.total());
273}
274
275// Test that a callback can add another callback to the list durning iteration
276// without invalidating the iterator. The newly added callback should be run on
277// the current iteration as will all other callbacks in the list.
278TEST(CallbackListTest, AddCallbacksDuringIteration) {
279  CallbackList<void(void)> cb_reg;
280  Adder a(&cb_reg);
281  Listener b;
282  std::unique_ptr<CallbackList<void(void)>::Subscription> a_subscription =
283      cb_reg.Add(Bind(&Adder::AddCallback, Unretained(&a)));
284  std::unique_ptr<CallbackList<void(void)>::Subscription> b_subscription =
285      cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
286
287  cb_reg.Notify();
288
289  EXPECT_EQ(1, a.total());
290  EXPECT_EQ(1, b.total());
291  EXPECT_TRUE(a.added());
292
293  cb_reg.Notify();
294
295  EXPECT_EQ(2, a.total());
296  EXPECT_EQ(2, b.total());
297}
298
299// Sanity check: notifying an empty list is a no-op.
300TEST(CallbackListTest, EmptyList) {
301  CallbackList<void(void)> cb_reg;
302
303  cb_reg.Notify();
304}
305
306TEST(CallbackList, RemovalCallback) {
307  Counter remove_count;
308  CallbackList<void(void)> cb_reg;
309  cb_reg.set_removal_callback(
310      Bind(&Counter::Increment, Unretained(&remove_count)));
311
312  std::unique_ptr<CallbackList<void(void)>::Subscription> subscription =
313      cb_reg.Add(Bind(&DoNothing));
314
315  // Removing a subscription outside of iteration signals the callback.
316  EXPECT_EQ(0, remove_count.value());
317  subscription.reset();
318  EXPECT_EQ(1, remove_count.value());
319
320  // Configure two subscriptions to remove themselves.
321  Remover remover_1, remover_2;
322  std::unique_ptr<CallbackList<void(void)>::Subscription> remover_1_sub =
323      cb_reg.Add(
324          Bind(&Remover::IncrementTotalAndRemove, Unretained(&remover_1)));
325  std::unique_ptr<CallbackList<void(void)>::Subscription> remover_2_sub =
326      cb_reg.Add(
327          Bind(&Remover::IncrementTotalAndRemove, Unretained(&remover_2)));
328  remover_1.SetSubscriptionToRemove(std::move(remover_1_sub));
329  remover_2.SetSubscriptionToRemove(std::move(remover_2_sub));
330
331  // The callback should be signaled exactly once.
332  EXPECT_EQ(1, remove_count.value());
333  cb_reg.Notify();
334  EXPECT_EQ(2, remove_count.value());
335  EXPECT_TRUE(cb_reg.empty());
336}
337
338}  // namespace
339}  // namespace base
340