base/callback_registry_unittest.cc

   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_registry.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/bind_helpers.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace base {
  14 namespace {
  15
  16 class Listener {
  17  public:
  18   Listener() : total_(0), scaler_(1) {}
  19   explicit Listener(int scaler) : total_(0), scaler_(scaler) {}
  20   void IncrementTotal() { total_++; }
  21   void IncrementByMultipleOfScaler(const int& x) { total_ += x * scaler_; }
  22
  23   int total_;
  24
  25  private:
  26   int scaler_;
  27   DISALLOW_COPY_AND_ASSIGN(Listener);
  28 };
  29
  30 class Remover {
  31  public:
  32   Remover() : total_(0) {}
  33   void IncrementTotalAndRemove() {
  34     total_++;
  35     removal_subscription_.reset();
  36   }
  37   void SetSubscriptionToRemove(
  38       scoped_ptr<CallbackRegistry<void>::Subscription> sub) {
  39     removal_subscription_ = sub.Pass();
  40   }
  41
  42   int total_;
  43
  44  private:
  45   scoped_ptr<CallbackRegistry<void>::Subscription> removal_subscription_;
  46   DISALLOW_COPY_AND_ASSIGN(Remover);
  47 };
  48
  49 class Adder {
  50  public:
  51   explicit Adder(CallbackRegistry<void>* cb_reg)
  52       : added_(false),
  53         total_(0),
  54         cb_reg_(cb_reg) {}
  55   void AddCallback() {
  56     if (!added_) {
  57       added_ = true;
  58       subscription_ =
  59           cb_reg_->Add(Bind(&Adder::IncrementTotal, Unretained(this)));
  60     }
  61   }
  62   void IncrementTotal() { total_++; }
  63
  64   bool added_;
  65   int total_;
  66
  67  private:
  68   CallbackRegistry<void>* cb_reg_;
  69   scoped_ptr<CallbackRegistry<void>::Subscription> subscription_;
  70   DISALLOW_COPY_AND_ASSIGN(Adder);
  71 };
  72
  73 // Sanity check that closures added to the list will be run, and those removed
  74 // from the list will not be run.
  75 TEST(CallbackRegistryTest, BasicTest) {
  76   CallbackRegistry<void> cb_reg;
  77   Listener a, b, c;
  78
  79   scoped_ptr<CallbackRegistry<void>::Subscription> a_subscription =
  80       cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a)));
  81   scoped_ptr<CallbackRegistry<void>::Subscription> b_subscription =
  82       cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
  83
  84   EXPECT_TRUE(a_subscription.get());
  85   EXPECT_TRUE(b_subscription.get());
  86
  87   cb_reg.Notify();
  88
  89   EXPECT_EQ(1, a.total_);
  90   EXPECT_EQ(1, b.total_);
  91
  92   b_subscription.reset();
  93
  94   scoped_ptr<CallbackRegistry<void>::Subscription> c_subscription =
  95       cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&c)));
  96
  97   cb_reg.Notify();
  98
  99   EXPECT_EQ(2, a.total_);
 100   EXPECT_EQ(1, b.total_);
 101   EXPECT_EQ(1, c.total_);
 102
 103   a_subscription.reset();
 104   b_subscription.reset();
 105   c_subscription.reset();
 106 }
 107
 108 // Sanity check that callbacks with details added to the list will be run, with
 109 // the correct details, and those removed from the list will not be run.
 110 TEST(CallbackRegistryTest, BasicTestWithParams) {
 111   CallbackRegistry<int> cb_reg;
 112   Listener a(1), b(-1), c(1);
 113
 114   scoped_ptr<CallbackRegistry<int>::Subscription> a_subscription =
 115       cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&a)));
 116   scoped_ptr<CallbackRegistry<int>::Subscription> b_subscription =
 117       cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&b)));
 118
 119   EXPECT_TRUE(a_subscription.get());
 120   EXPECT_TRUE(b_subscription.get());
 121
 122   cb_reg.Notify(10);
 123
 124   EXPECT_EQ(10, a.total_);
 125   EXPECT_EQ(-10, b.total_);
 126
 127   b_subscription.reset();
 128
 129   scoped_ptr<CallbackRegistry<int>::Subscription> c_subscription =
 130       cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&c)));
 131
 132   cb_reg.Notify(10);
 133
 134   EXPECT_EQ(20, a.total_);
 135   EXPECT_EQ(-10, b.total_);
 136   EXPECT_EQ(10, c.total_);
 137
 138   a_subscription.reset();
 139   b_subscription.reset();
 140   c_subscription.reset();
 141 }
 142
 143 // Test the a callback can remove itself or a different callback from the list
 144 // during iteration without invalidating the iterator.
 145 TEST(CallbackRegistryTest, RemoveCallbacksDuringIteration) {
 146   CallbackRegistry<void> cb_reg;
 147   Listener a, b;
 148   Remover remover_1, remover_2;
 149
 150   scoped_ptr<CallbackRegistry<void>::Subscription> remover_1_subscription =
 151       cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove,
 152           Unretained(&remover_1)));
 153   scoped_ptr<CallbackRegistry<void>::Subscription> remover_2_subscription =
 154       cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove,
 155           Unretained(&remover_2)));
 156   scoped_ptr<CallbackRegistry<void>::Subscription> a_subscription =
 157       cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a)));
 158   scoped_ptr<CallbackRegistry<void>::Subscription> b_subscription =
 159       cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
 160
 161   // |remover_1| will remove itself.
 162   remover_1.SetSubscriptionToRemove(remover_1_subscription.Pass());
 163   // |remover_2| will remove a.
 164   remover_2.SetSubscriptionToRemove(a_subscription.Pass());
 165
 166   cb_reg.Notify();
 167
 168   // |remover_1| runs once (and removes itself), |remover_2| runs once (and
 169   // removes a), |a| never runs, and |b| runs once.
 170   EXPECT_EQ(1, remover_1.total_);
 171   EXPECT_EQ(1, remover_2.total_);
 172   EXPECT_EQ(0, a.total_);
 173   EXPECT_EQ(1, b.total_);
 174
 175   cb_reg.Notify();
 176
 177   // Only |remover_2| and |b| run this time.
 178   EXPECT_EQ(1, remover_1.total_);
 179   EXPECT_EQ(2, remover_2.total_);
 180   EXPECT_EQ(0, a.total_);
 181   EXPECT_EQ(2, b.total_);
 182 }
 183
 184 // Test that a callback can add another callback to the list durning iteration
 185 // without invalidating the iterator. The newly added callback should be run on
 186 // the current iteration as will all other callbacks in the list.
 187 TEST(CallbackRegistryTest, AddCallbacksDuringIteration) {
 188   CallbackRegistry<void> cb_reg;
 189   Adder a(&cb_reg);
 190   Listener b;
 191   scoped_ptr<CallbackRegistry<void>::Subscription> a_subscription =
 192       cb_reg.Add(Bind(&Adder::AddCallback, Unretained(&a)));
 193   scoped_ptr<CallbackRegistry<void>::Subscription> b_subscription =
 194       cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
 195
 196   cb_reg.Notify();
 197
 198   EXPECT_EQ(1, a.total_);
 199   EXPECT_EQ(1, b.total_);
 200   EXPECT_TRUE(a.added_);
 201
 202   cb_reg.Notify();
 203
 204   EXPECT_EQ(2, a.total_);
 205   EXPECT_EQ(2, b.total_);
 206 }
 207
 208 // Sanity check: notifying an empty list is a no-op.
 209 TEST(CallbackRegistryTest, EmptyList) {
 210   CallbackRegistry<void> cb_reg;
 211
 212   cb_reg.Notify();
 213 }
 214
 215 }  // namespace
 216 }  // namespace base