blob: 6eb5ff7f855f2497e7d82e1c06fe2b8f45f62555 [file] [log] [blame]
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/callback_list.h"
#include <memory>
#include <utility>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/macros.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace base {
namespace {
class Listener {
public:
Listener() : total_(0), scaler_(1) {}
explicit Listener(int scaler) : total_(0), scaler_(scaler) {}
void IncrementTotal() { total_++; }
void IncrementByMultipleOfScaler(int x) { total_ += x * scaler_; }
int total() const { return total_; }
private:
int total_;
int scaler_;
DISALLOW_COPY_AND_ASSIGN(Listener);
};
class Remover {
public:
Remover() : total_(0) {}
void IncrementTotalAndRemove() {
total_++;
removal_subscription_.reset();
}
void SetSubscriptionToRemove(
std::unique_ptr<CallbackList<void(void)>::Subscription> sub) {
removal_subscription_ = std::move(sub);
}
int total() const { return total_; }
private:
int total_;
std::unique_ptr<CallbackList<void(void)>::Subscription> removal_subscription_;
DISALLOW_COPY_AND_ASSIGN(Remover);
};
class Adder {
public:
explicit Adder(CallbackList<void(void)>* cb_reg)
: added_(false),
total_(0),
cb_reg_(cb_reg) {
}
void AddCallback() {
if (!added_) {
added_ = true;
subscription_ =
cb_reg_->Add(Bind(&Adder::IncrementTotal, Unretained(this)));
}
}
void IncrementTotal() { total_++; }
bool added() const { return added_; }
int total() const { return total_; }
private:
bool added_;
int total_;
CallbackList<void(void)>* cb_reg_;
std::unique_ptr<CallbackList<void(void)>::Subscription> subscription_;
DISALLOW_COPY_AND_ASSIGN(Adder);
};
class Summer {
public:
Summer() : value_(0) {}
void AddOneParam(int a) { value_ = a; }
void AddTwoParam(int a, int b) { value_ = a + b; }
void AddThreeParam(int a, int b, int c) { value_ = a + b + c; }
void AddFourParam(int a, int b, int c, int d) { value_ = a + b + c + d; }
void AddFiveParam(int a, int b, int c, int d, int e) {
value_ = a + b + c + d + e;
}
void AddSixParam(int a, int b, int c, int d, int e , int f) {
value_ = a + b + c + d + e + f;
}
int value() const { return value_; }
private:
int value_;
DISALLOW_COPY_AND_ASSIGN(Summer);
};
class Counter {
public:
Counter() : value_(0) {}
void Increment() { value_++; }
int value() const { return value_; }
private:
int value_;
DISALLOW_COPY_AND_ASSIGN(Counter);
};
// Sanity check that we can instantiate a CallbackList for each arity.
TEST(CallbackListTest, ArityTest) {
Summer s;
CallbackList<void(int)> c1;
std::unique_ptr<CallbackList<void(int)>::Subscription> subscription1 =
c1.Add(Bind(&Summer::AddOneParam, Unretained(&s)));
c1.Notify(1);
EXPECT_EQ(1, s.value());
CallbackList<void(int, int)> c2;
std::unique_ptr<CallbackList<void(int, int)>::Subscription> subscription2 =
c2.Add(Bind(&Summer::AddTwoParam, Unretained(&s)));
c2.Notify(1, 2);
EXPECT_EQ(3, s.value());
CallbackList<void(int, int, int)> c3;
std::unique_ptr<CallbackList<void(int, int, int)>::Subscription>
subscription3 = c3.Add(Bind(&Summer::AddThreeParam, Unretained(&s)));
c3.Notify(1, 2, 3);
EXPECT_EQ(6, s.value());
CallbackList<void(int, int, int, int)> c4;
std::unique_ptr<CallbackList<void(int, int, int, int)>::Subscription>
subscription4 = c4.Add(Bind(&Summer::AddFourParam, Unretained(&s)));
c4.Notify(1, 2, 3, 4);
EXPECT_EQ(10, s.value());
CallbackList<void(int, int, int, int, int)> c5;
std::unique_ptr<CallbackList<void(int, int, int, int, int)>::Subscription>
subscription5 = c5.Add(Bind(&Summer::AddFiveParam, Unretained(&s)));
c5.Notify(1, 2, 3, 4, 5);
EXPECT_EQ(15, s.value());
CallbackList<void(int, int, int, int, int, int)> c6;
std::unique_ptr<
CallbackList<void(int, int, int, int, int, int)>::Subscription>
subscription6 = c6.Add(Bind(&Summer::AddSixParam, Unretained(&s)));
c6.Notify(1, 2, 3, 4, 5, 6);
EXPECT_EQ(21, s.value());
}
// Sanity check that closures added to the list will be run, and those removed
// from the list will not be run.
TEST(CallbackListTest, BasicTest) {
CallbackList<void(void)> cb_reg;
Listener a, b, c;
std::unique_ptr<CallbackList<void(void)>::Subscription> a_subscription =
cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a)));
std::unique_ptr<CallbackList<void(void)>::Subscription> b_subscription =
cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
EXPECT_TRUE(a_subscription.get());
EXPECT_TRUE(b_subscription.get());
cb_reg.Notify();
EXPECT_EQ(1, a.total());
EXPECT_EQ(1, b.total());
b_subscription.reset();
std::unique_ptr<CallbackList<void(void)>::Subscription> c_subscription =
cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&c)));
cb_reg.Notify();
EXPECT_EQ(2, a.total());
EXPECT_EQ(1, b.total());
EXPECT_EQ(1, c.total());
a_subscription.reset();
b_subscription.reset();
c_subscription.reset();
}
// Sanity check that callbacks with details added to the list will be run, with
// the correct details, and those removed from the list will not be run.
TEST(CallbackListTest, BasicTestWithParams) {
CallbackList<void(int)> cb_reg;
Listener a(1), b(-1), c(1);
std::unique_ptr<CallbackList<void(int)>::Subscription> a_subscription =
cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&a)));
std::unique_ptr<CallbackList<void(int)>::Subscription> b_subscription =
cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&b)));
EXPECT_TRUE(a_subscription.get());
EXPECT_TRUE(b_subscription.get());
cb_reg.Notify(10);
EXPECT_EQ(10, a.total());
EXPECT_EQ(-10, b.total());
b_subscription.reset();
std::unique_ptr<CallbackList<void(int)>::Subscription> c_subscription =
cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&c)));
cb_reg.Notify(10);
EXPECT_EQ(20, a.total());
EXPECT_EQ(-10, b.total());
EXPECT_EQ(10, c.total());
a_subscription.reset();
b_subscription.reset();
c_subscription.reset();
}
// Test the a callback can remove itself or a different callback from the list
// during iteration without invalidating the iterator.
TEST(CallbackListTest, RemoveCallbacksDuringIteration) {
CallbackList<void(void)> cb_reg;
Listener a, b;
Remover remover_1, remover_2;
std::unique_ptr<CallbackList<void(void)>::Subscription> remover_1_sub =
cb_reg.Add(
Bind(&Remover::IncrementTotalAndRemove, Unretained(&remover_1)));
std::unique_ptr<CallbackList<void(void)>::Subscription> remover_2_sub =
cb_reg.Add(
Bind(&Remover::IncrementTotalAndRemove, Unretained(&remover_2)));
std::unique_ptr<CallbackList<void(void)>::Subscription> a_subscription =
cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a)));
std::unique_ptr<CallbackList<void(void)>::Subscription> b_subscription =
cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
// |remover_1| will remove itself.
remover_1.SetSubscriptionToRemove(std::move(remover_1_sub));
// |remover_2| will remove a.
remover_2.SetSubscriptionToRemove(std::move(a_subscription));
cb_reg.Notify();
// |remover_1| runs once (and removes itself), |remover_2| runs once (and
// removes a), |a| never runs, and |b| runs once.
EXPECT_EQ(1, remover_1.total());
EXPECT_EQ(1, remover_2.total());
EXPECT_EQ(0, a.total());
EXPECT_EQ(1, b.total());
cb_reg.Notify();
// Only |remover_2| and |b| run this time.
EXPECT_EQ(1, remover_1.total());
EXPECT_EQ(2, remover_2.total());
EXPECT_EQ(0, a.total());
EXPECT_EQ(2, b.total());
}
// Test that a callback can add another callback to the list durning iteration
// without invalidating the iterator. The newly added callback should be run on
// the current iteration as will all other callbacks in the list.
TEST(CallbackListTest, AddCallbacksDuringIteration) {
CallbackList<void(void)> cb_reg;
Adder a(&cb_reg);
Listener b;
std::unique_ptr<CallbackList<void(void)>::Subscription> a_subscription =
cb_reg.Add(Bind(&Adder::AddCallback, Unretained(&a)));
std::unique_ptr<CallbackList<void(void)>::Subscription> b_subscription =
cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
cb_reg.Notify();
EXPECT_EQ(1, a.total());
EXPECT_EQ(1, b.total());
EXPECT_TRUE(a.added());
cb_reg.Notify();
EXPECT_EQ(2, a.total());
EXPECT_EQ(2, b.total());
}
// Sanity check: notifying an empty list is a no-op.
TEST(CallbackListTest, EmptyList) {
CallbackList<void(void)> cb_reg;
cb_reg.Notify();
}
TEST(CallbackList, RemovalCallback) {
Counter remove_count;
CallbackList<void(void)> cb_reg;
cb_reg.set_removal_callback(
Bind(&Counter::Increment, Unretained(&remove_count)));
std::unique_ptr<CallbackList<void(void)>::Subscription> subscription =
cb_reg.Add(DoNothing());
// Removing a subscription outside of iteration signals the callback.
EXPECT_EQ(0, remove_count.value());
subscription.reset();
EXPECT_EQ(1, remove_count.value());
// Configure two subscriptions to remove themselves.
Remover remover_1, remover_2;
std::unique_ptr<CallbackList<void(void)>::Subscription> remover_1_sub =
cb_reg.Add(
Bind(&Remover::IncrementTotalAndRemove, Unretained(&remover_1)));
std::unique_ptr<CallbackList<void(void)>::Subscription> remover_2_sub =
cb_reg.Add(
Bind(&Remover::IncrementTotalAndRemove, Unretained(&remover_2)));
remover_1.SetSubscriptionToRemove(std::move(remover_1_sub));
remover_2.SetSubscriptionToRemove(std::move(remover_2_sub));
// The callback should be signaled exactly once.
EXPECT_EQ(1, remove_count.value());
cb_reg.Notify();
EXPECT_EQ(2, remove_count.value());
EXPECT_TRUE(cb_reg.empty());
}
} // namespace
} // namespace base