src/sync/syncable/model_type_unittest.cc

   1 // Copyright (c) 2012 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 "sync/internal_api/public/base/model_type.h"
   6
   7 #include <string>
   8
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/test/values_test_util.h"
  11 #include "base/values.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace syncer {
  15 namespace {
  16
  17 class ModelTypeTest : public testing::Test {};
  18
  19 TEST_F(ModelTypeTest, ModelTypeToValue) {
  20   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
  21     ModelType model_type = ModelTypeFromInt(i);
  22     base::ExpectStringValue(ModelTypeToString(model_type),
  23                             ModelTypeToValue(model_type));
  24   }
  25   base::ExpectStringValue("Top-level folder",
  26                           ModelTypeToValue(TOP_LEVEL_FOLDER));
  27   base::ExpectStringValue("Unspecified",
  28                           ModelTypeToValue(UNSPECIFIED));
  29 }
  30
  31 TEST_F(ModelTypeTest, ModelTypeFromValue) {
  32   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
  33     ModelType model_type = ModelTypeFromInt(i);
  34     scoped_ptr<StringValue> value(ModelTypeToValue(model_type));
  35     EXPECT_EQ(model_type, ModelTypeFromValue(*value));
  36   }
  37 }
  38
  39 TEST_F(ModelTypeTest, ModelTypeSetToValue) {
  40   const ModelTypeSet model_types(BOOKMARKS, APPS);
  41
  42   scoped_ptr<base::ListValue> value(ModelTypeSetToValue(model_types));
  43   EXPECT_EQ(2u, value->GetSize());
  44   std::string types[2];
  45   EXPECT_TRUE(value->GetString(0, &types[0]));
  46   EXPECT_TRUE(value->GetString(1, &types[1]));
  47   EXPECT_EQ("Bookmarks", types[0]);
  48   EXPECT_EQ("Apps", types[1]);
  49 }
  50
  51 TEST_F(ModelTypeTest, ModelTypeSetFromValue) {
  52   // Try empty set first.
  53   ModelTypeSet model_types;
  54   scoped_ptr<base::ListValue> value(ModelTypeSetToValue(model_types));
  55   EXPECT_TRUE(model_types.Equals(ModelTypeSetFromValue(*value)));
  56
  57   // Now try with a few random types.
  58   model_types.Put(BOOKMARKS);
  59   model_types.Put(APPS);
  60   value.reset(ModelTypeSetToValue(model_types));
  61   EXPECT_TRUE(model_types.Equals(ModelTypeSetFromValue(*value)));
  62 }
  63
  64 TEST_F(ModelTypeTest, IsRealDataType) {
  65   EXPECT_FALSE(IsRealDataType(UNSPECIFIED));
  66   EXPECT_FALSE(IsRealDataType(MODEL_TYPE_COUNT));
  67   EXPECT_FALSE(IsRealDataType(TOP_LEVEL_FOLDER));
  68   EXPECT_TRUE(IsRealDataType(FIRST_REAL_MODEL_TYPE));
  69   EXPECT_TRUE(IsRealDataType(BOOKMARKS));
  70   EXPECT_TRUE(IsRealDataType(APPS));
  71 }
  72
  73 // Make sure we can convert ModelTypes to and from specifics field
  74 // numbers.
  75 TEST_F(ModelTypeTest, ModelTypeToFromSpecificsFieldNumber) {
  76   ModelTypeSet protocol_types = ProtocolTypes();
  77   for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
  78        iter.Inc()) {
  79     int field_number = GetSpecificsFieldNumberFromModelType(iter.Get());
  80     EXPECT_EQ(iter.Get(),
  81               GetModelTypeFromSpecificsFieldNumber(field_number));
  82   }
  83 }
  84
  85 TEST_F(ModelTypeTest, ModelTypeOfInvalidSpecificsFieldNumber) {
  86   EXPECT_EQ(UNSPECIFIED, GetModelTypeFromSpecificsFieldNumber(0));
  87 }
  88
  89 TEST_F(ModelTypeTest, ModelTypeHistogramMapping) {
  90   std::set<int> histogram_values;
  91   ModelTypeSet all_types = ModelTypeSet::All();
  92   for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
  93     SCOPED_TRACE(ModelTypeToString(it.Get()));
  94     int histogram_value = ModelTypeToHistogramInt(it.Get());
  95
  96     EXPECT_TRUE(histogram_values.insert(histogram_value).second)
  97         << "Expected histogram values to be unique";
  98
  99     // This is not necessary for the mapping to be valid, but most instances of
 100     // UMA_HISTOGRAM that use this mapping specify MODEL_TYPE_COUNT as the
 101     // maximum possible value.  If you break this assumption, you should update
 102     // those histograms.
 103     EXPECT_LT(histogram_value, MODEL_TYPE_COUNT);
 104   }
 105 }
 106
 107 }  // namespace
 108 }  // namespace syncer