Refactor common invalidation framework types

sync/notifier/object_id_invalidation_map_unittest.cc

Index: sync/notifier/object_id_invalidation_map_unittest.cc
diff --git a/sync/notifier/object_id_invalidation_map_unittest.cc b/sync/notifier/object_id_invalidation_map_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ac42365f0bb9b2587ae49705a1700cd7476f9263
--- /dev/null
+++ b/sync/notifier/object_id_invalidation_map_unittest.cc
@@ -0,0 +1,104 @@
+// Copyright (c) 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 "sync/notifier/object_id_invalidation_map.h"
+
+#include "google/cacheinvalidation/types.pb.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace syncer {
+
+namespace {
+
+class ObjectIdInvalidationMapTest : public testing::Test {
+ public:
+  ObjectIdInvalidationMapTest()
+      : kIdOne(ipc::invalidation::ObjectSource::TEST, "one"),
+        kIdTwo(ipc::invalidation::ObjectSource::TEST, "two"),
+        kInv1(Invalidation::Init(kIdOne, 10, "ten")) {
+    set1.insert(kIdOne);
+    set2.insert(kIdTwo);
+    all_set.insert(kIdOne);
+    all_set.insert(kIdTwo);
+
+    one_invalidation.Insert(kInv1);
+    invalidate_all = ObjectIdInvalidationMap::InvalidateAll(all_set);
+  }
+
+ protected:
+  const invalidation::ObjectId kIdOne;
+  const invalidation::ObjectId kIdTwo;
+  const Invalidation kInv1;
+
+  ObjectIdSet set1;
+  ObjectIdSet set2;
+  ObjectIdSet all_set;
+  ObjectIdInvalidationMap empty;
+  ObjectIdInvalidationMap one_invalidation;
+  ObjectIdInvalidationMap invalidate_all;
+};
+
+TEST_F(ObjectIdInvalidationMapTest, Empty) {
+  EXPECT_TRUE(empty.Empty());
+  EXPECT_FALSE(one_invalidation.Empty());
+  EXPECT_FALSE(invalidate_all.Empty());
+}
+
+TEST_F(ObjectIdInvalidationMapTest, Equality) {
+  ObjectIdInvalidationMap empty2;
+  EXPECT_TRUE(empty == empty2);
+
+  ObjectIdInvalidationMap one_invalidation2;
+  one_invalidation2.Insert(kInv1);
+  EXPECT_TRUE(one_invalidation == one_invalidation2);
+
+  EXPECT_FALSE(empty == invalidate_all);
+}
+
+TEST_F(ObjectIdInvalidationMapTest, GetObjectIds) {
+  EXPECT_EQ(ObjectIdSet(), empty.GetObjectIds());
+  EXPECT_EQ(set1, one_invalidation.GetObjectIds());
+  EXPECT_EQ(all_set, invalidate_all.GetObjectIds());
+}
+
+TEST_F(ObjectIdInvalidationMapTest, GetSubsetWithObjectIds) {
+  EXPECT_TRUE(empty.GetSubsetWithObjectIds(set1).Empty());
+
+  EXPECT_TRUE(one_invalidation.GetSubsetWithObjectIds(set1) ==
+              one_invalidation);
+  EXPECT_TRUE(one_invalidation.GetSubsetWithObjectIds(all_set) ==
+              one_invalidation);
+  EXPECT_TRUE(one_invalidation.GetSubsetWithObjectIds(set2).Empty());
+
+  EXPECT_TRUE(invalidate_all.GetSubsetWithObjectIds(ObjectIdSet()).Empty());
+}
+
+TEST_F(ObjectIdInvalidationMapTest, SerializeEmpty) {
+  scoped_ptr<base::ListValue> value = empty.ToValue();
+  ASSERT_TRUE(value.get());
+  ObjectIdInvalidationMap deserialized;
+  deserialized.ResetFromValue(*value.get());
+  EXPECT_TRUE(empty == deserialized);
+}
+
+TEST_F(ObjectIdInvalidationMapTest, SerializeOneInvalidation) {
+  scoped_ptr<base::ListValue> value = one_invalidation.ToValue();
+  ASSERT_TRUE(value.get());
+  ObjectIdInvalidationMap deserialized;
+  deserialized.ResetFromValue(*value.get());
+  EXPECT_TRUE(one_invalidation == deserialized);
+}
+
+TEST_F(ObjectIdInvalidationMapTest, SerializeInvalidateAll) {
+  scoped_ptr<base::ListValue> value = invalidate_all.ToValue();
+  ASSERT_TRUE(value.get());
+  ObjectIdInvalidationMap deserialized;
+  deserialized.ResetFromValue(*value.get());
+  EXPECT_TRUE(invalidate_all == deserialized);
+}
+
+}  // namespace
+
+}  // namespace syncer