Callback API Change: is_null, Reset, and Equals

base/callback_unittest.cc

Index: base/callback_unittest.cc
diff --git a/base/callback_unittest.cc b/base/callback_unittest.cc
index bc15927ddade2d6278e60d6e51c567430a2b8cbc..bf2b606b070bde743b9d8a07d056c6278d5230ab 100644
--- a/base/callback_unittest.cc
+++ b/base/callback_unittest.cc
@@ -3,10 +3,12 @@
 // found in the LICENSE file.
 
 #include "base/callback.h"
+#include "base/callback_helpers.h"
 #include "base/scoped_ptr.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace base {
 namespace {
 
 class HelperObject {
@@ -19,9 +21,24 @@ class HelperObject {
   int next_number_;
 };
 
-}  // namespace
+struct FakeTraits {
+  static void DoInvoke(internal::InvokerStorageBase*) {
+  }
+};
+
+// White-box testpoints to inject into a Callback<> object for checking
+// comparators and emptiness APIs.
+class FakeInvokerStorage1 : public internal::InvokerStorageBase {
+ public:
+  typedef FakeTraits FunctionTraits;
+};
+
+class FakeInvokerStorage2 : public internal::InvokerStorageBase {
+ public:
+  typedef FakeTraits FunctionTraits;
+};
 
-TEST(Callback, OneArg) {
+TEST(CallbackOld, OneArg) {
   HelperObject obj;
   scoped_ptr<Callback1<int*>::Type> callback(
       NewCallback(&obj, &HelperObject::GetNextNumberArg));
@@ -31,10 +48,83 @@ TEST(Callback, OneArg) {
   EXPECT_EQ(number, 1);
 }
 
-TEST(Callback, ReturnValue) {
+TEST(CallbackOld, ReturnValue) {
   HelperObject obj;
   scoped_ptr<CallbackWithReturnValue<int>::Type> callback(
       NewCallbackWithReturnValue(&obj, &HelperObject::GetNextNumber));
 
   EXPECT_EQ(callback->Run(), 1);
 }
+
+class CallbackTest : public ::testing::Test {
+ public:
+  CallbackTest()
+      : callback_a_(MakeInvokerStorageHolder(new FakeInvokerStorage1())),
+        callback_b_(MakeInvokerStorageHolder(new FakeInvokerStorage2())) {
+  }
+
+  virtual ~CallbackTest() {
+  }
+
+ protected:
+  Callback<void(void)> callback_a_;
+  const Callback<void(void)> callback_b_;  // Ensure APIs work with const.
+  Callback<void(void)> null_callback_;
+};
+
+// Ensure we can create unbound callbacks. We need this to be able to store
+// them in class members that can be initialized later.
+TEST_F(CallbackTest, DefaultConstruction) {
+  Callback<void(void)> c0;
+  Callback<void(int)> c1;
+  Callback<void(int,int)> c2;
+  Callback<void(int,int,int)> c3;
+  Callback<void(int,int,int,int)> c4;
+  Callback<void(int,int,int,int,int)> c5;
+  Callback<void(int,int,int,int,int,int)> c6;
+
+  EXPECT_TRUE(c0.is_null());
+  EXPECT_TRUE(c1.is_null());
+  EXPECT_TRUE(c2.is_null());
+  EXPECT_TRUE(c3.is_null());
+  EXPECT_TRUE(c4.is_null());
+  EXPECT_TRUE(c5.is_null());
+  EXPECT_TRUE(c6.is_null());
+}
+
+TEST_F(CallbackTest, IsNull) {
+  EXPECT_TRUE(null_callback_.is_null());
+  EXPECT_FALSE(callback_a_.is_null());
+  EXPECT_FALSE(callback_b_.is_null());
+}
+
+TEST_F(CallbackTest, Equals) {
+  EXPECT_TRUE(callback_a_.Equals(callback_a_));
+  EXPECT_FALSE(callback_a_.Equals(callback_b_));
+  EXPECT_FALSE(callback_b_.Equals(callback_a_));
+
+  // We should compare based on instance, not type.
+  Callback<void(void)> callback_c(
+      MakeInvokerStorageHolder(new FakeInvokerStorage1()));
+  Callback<void(void)> callback_a2 = callback_a_;
+  EXPECT_TRUE(callback_a_.Equals(callback_a2));
+  EXPECT_FALSE(callback_a_.Equals(callback_c));
+
+  // Empty, however, is always equal to empty.
+  Callback<void(void)> empty2;
+  EXPECT_TRUE(null_callback_.Equals(empty2));
+}
+
+TEST_F(CallbackTest, Reset) {
+  // Resetting should bring us back to empty.
+  ASSERT_FALSE(callback_a_.is_null());

[akalin, 2011/02/17 20:29:44]

no need for these to be asserts, I think

[awong, 2011/02/18 00:42:41]

The rest of the test is invalid if these assumptions are false...

+  ASSERT_FALSE(callback_a_.Equals(null_callback_));
+
+  callback_a_.Reset();
+
+  EXPECT_TRUE(callback_a_.is_null());
+  EXPECT_TRUE(callback_a_.Equals(null_callback_));
+}
+
+}  // namespace
+}  // namespace base