Organizing model type, notification type, root tag and model type string in map.

sync/syncable/model_type_unittest.cc

 // Copyright (c) 2012 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/internal_api/public/base/model_type.h"
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
+#include "base/strings/string_util.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 namespace {
 
 class ModelTypeTest : public testing::Test {};
 
@@ skipping 117 matching lines @@
     EXPECT_TRUE(specifics.SerializeToString(&tmp));
 
     sync_pb::EntitySpecifics from_string;
     EXPECT_TRUE(from_string.ParseFromString(tmp));
     EXPECT_TRUE(from_string.IsInitialized());
 
     EXPECT_EQ(it.Get(), syncer::GetModelTypeFromSpecifics(from_string));
   }
 }
 
+TEST_F(ModelTypeTest, ModelTypeToRootTagValues) {
+  ModelTypeSet all_types = ModelTypeSet::All();
+  for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
+    ModelType model_type = it.Get();
+    std::string root_tag = ModelTypeToRootTag(model_type);
+    if (IsProxyType(model_type)) {
+      EXPECT_EQ(root_tag, std::string());
+    } else if (IsRealDataType(model_type)) {
+      EXPECT_TRUE(base::StartsWith(root_tag, "google_chrome_",
+                                   base::CompareCase::INSENSITIVE_ASCII));
+    } else {
+      EXPECT_EQ(root_tag, "INVALID");
+    }
+  }
+}
+
+TEST_F(ModelTypeTest, ModelTypeStingMapping) {

[Nicolas Zea, 2015/10/29 22:50:43]

nit: ModelTypeStingMapping -> ModelTypeStringMapping

[Deepak, 2015/10/30 05:27:34]

Done.

+  ModelTypeSet all_types = ModelTypeSet::All();
+  for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
+    ModelType model_type = it.Get();
+    const char* model_type_string = ModelTypeToString(model_type);
+    ModelType converted_model_type = ModelTypeFromString(model_type_string);
+    if (IsRealDataType(model_type))
+      EXPECT_EQ(converted_model_type, model_type);
+    else
+      EXPECT_EQ(converted_model_type, UNSPECIFIED);
+  }
+}
+
+TEST_F(ModelTypeTest, ModelTypeNotificationTypeMapping) {
+  ModelTypeSet all_types = ModelTypeSet::All();
+  for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
+    ModelType model_type = it.Get();
+    std::string notification_type;
+    bool ret = RealModelTypeToNotificationType(model_type, &notification_type);
+    if (ret) {
+      ModelType notified_model_type;
+      EXPECT_TRUE(NotificationTypeToRealModelType(notification_type,
+                                                  &notified_model_type));
+      EXPECT_EQ(notified_model_type, model_type);
+    } else {
+      EXPECT_FALSE(ProtocolTypes().Has(model_type));
+      EXPECT_TRUE(notification_type.empty());
+    }
+  }
+}
+
 }  // namespace
 }  // namespace syncer