tools/json_schema_compiler/test/enums_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 "tools/json_schema_compiler/test/enums.h"
   6
   7 #include "testing/gtest/include/gtest/gtest.h"
   8 #include "tools/json_schema_compiler/test/test_util.h"
   9
  10 using namespace test::api::enums;
  11 using json_schema_compiler::test_util::List;
  12
  13 TEST(JsonSchemaCompilerEnumsTest, EnumTypePopulate) {
  14   {
  15     EnumType enum_type;
  16     base::DictionaryValue value;
  17     value.Set("type", new base::StringValue("one"));
  18     EXPECT_TRUE(EnumType::Populate(value, &enum_type));
  19     EXPECT_EQ(ENUMERATION_ONE, enum_type.type);
  20     EXPECT_TRUE(value.Equals(enum_type.ToValue().get()));
  21   }
  22   {
  23     EnumType enum_type;
  24     base::DictionaryValue value;
  25     value.Set("type", new base::StringValue("invalid"));
  26     EXPECT_FALSE(EnumType::Populate(value, &enum_type));
  27   }
  28 }
  29
  30 TEST(JsonSchemaCompilerEnumsTest, EnumsAsTypes) {
  31   {
  32     base::ListValue args;
  33     args.Append(new base::StringValue("one"));
  34
  35     scoped_ptr<TakesEnumAsType::Params> params(
  36         TakesEnumAsType::Params::Create(args));
  37     ASSERT_TRUE(params.get());
  38     EXPECT_EQ(ENUMERATION_ONE, params->enumeration);
  39
  40     EXPECT_TRUE(args.Equals(ReturnsEnumAsType::Results::Create(
  41         ENUMERATION_ONE).get()));
  42   }
  43   {
  44     HasEnumeration enumeration;
  45     EXPECT_EQ(ENUMERATION_NONE, enumeration.enumeration);
  46     EXPECT_EQ(ENUMERATION_NONE, enumeration.optional_enumeration);
  47   }
  48   {
  49     HasEnumeration enumeration;
  50     base::DictionaryValue value;
  51     ASSERT_FALSE(HasEnumeration::Populate(value, &enumeration));
  52
  53     value.Set("enumeration", new base::StringValue("one"));
  54     ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration));
  55     EXPECT_TRUE(value.Equals(enumeration.ToValue().get()));
  56
  57     value.Set("optional_enumeration", new base::StringValue("two"));
  58     ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration));
  59     EXPECT_TRUE(value.Equals(enumeration.ToValue().get()));
  60   }
  61   {
  62     ReferenceEnum enumeration;
  63     base::DictionaryValue value;
  64     ASSERT_FALSE(ReferenceEnum::Populate(value, &enumeration));
  65
  66     value.Set("reference_enum", new base::StringValue("one"));
  67     ASSERT_TRUE(ReferenceEnum::Populate(value, &enumeration));
  68     EXPECT_TRUE(value.Equals(enumeration.ToValue().get()));
  69   }
  70 }
  71
  72 TEST(JsonSchemaCompilerEnumsTest, EnumsArrayAsType) {
  73   {
  74     base::ListValue params_value;
  75     params_value.Append(List(new base::StringValue("one"),
  76                              new base::StringValue("two")).release());
  77     scoped_ptr<TakesEnumArrayAsType::Params> params(
  78         TakesEnumArrayAsType::Params::Create(params_value));
  79     ASSERT_TRUE(params);
  80     EXPECT_EQ(2U, params->values.size());
  81     EXPECT_EQ(ENUMERATION_ONE, params->values[0]);
  82     EXPECT_EQ(ENUMERATION_TWO, params->values[1]);
  83   }
  84   {
  85     base::ListValue params_value;
  86     params_value.Append(List(new base::StringValue("invalid")).release());
  87     scoped_ptr<TakesEnumArrayAsType::Params> params(
  88         TakesEnumArrayAsType::Params::Create(params_value));
  89     EXPECT_FALSE(params);
  90   }
  91 }
  92
  93 TEST(JsonSchemaCompilerEnumsTest, ReturnsEnumCreate) {
  94   {
  95     Enumeration state = ENUMERATION_ONE;
  96     scoped_ptr<base::Value> result(new base::StringValue(ToString(state)));
  97     scoped_ptr<base::Value> expected(new base::StringValue("one"));
  98     EXPECT_TRUE(result->Equals(expected.get()));
  99   }
 100   {
 101     Enumeration state = ENUMERATION_ONE;
 102     scoped_ptr<base::ListValue> results = ReturnsEnum::Results::Create(state);
 103     base::ListValue expected;
 104     expected.Append(new base::StringValue("one"));
 105     EXPECT_TRUE(results->Equals(&expected));
 106   }
 107 }
 108
 109 TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) {
 110   {
 111     scoped_ptr<base::ListValue> results = ReturnsTwoEnums::Results::Create(
 112         ENUMERATION_ONE, OTHER_ENUMERATION_HAM);
 113     base::ListValue expected;
 114     expected.Append(new base::StringValue("one"));
 115     expected.Append(new base::StringValue("ham"));
 116     EXPECT_TRUE(results->Equals(&expected));
 117   }
 118 }
 119
 120 TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) {
 121   {
 122     OptionalEnumType enum_type;
 123     base::DictionaryValue value;
 124     value.Set("type", new base::StringValue("two"));
 125     EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type));
 126     EXPECT_EQ(ENUMERATION_TWO, enum_type.type);
 127     EXPECT_TRUE(value.Equals(enum_type.ToValue().get()));
 128   }
 129   {
 130     OptionalEnumType enum_type;
 131     base::DictionaryValue value;
 132     EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type));
 133     EXPECT_EQ(ENUMERATION_NONE, enum_type.type);
 134     EXPECT_TRUE(value.Equals(enum_type.ToValue().get()));
 135   }
 136   {
 137     OptionalEnumType enum_type;
 138     base::DictionaryValue value;
 139     value.Set("type", new base::StringValue("invalid"));
 140     EXPECT_FALSE(OptionalEnumType::Populate(value, &enum_type));
 141   }
 142 }
 143
 144 TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) {
 145   {
 146     base::ListValue params_value;
 147     params_value.Append(new base::StringValue("two"));
 148     scoped_ptr<TakesEnum::Params> params(
 149         TakesEnum::Params::Create(params_value));
 150     EXPECT_TRUE(params.get());
 151     EXPECT_EQ(ENUMERATION_TWO, params->state);
 152   }
 153   {
 154     base::ListValue params_value;
 155     params_value.Append(new base::StringValue("invalid"));
 156     scoped_ptr<TakesEnum::Params> params(
 157         TakesEnum::Params::Create(params_value));
 158     EXPECT_FALSE(params.get());
 159   }
 160 }
 161
 162 TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) {
 163   {
 164     base::ListValue params_value;
 165     params_value.Append(List(new base::StringValue("one"),
 166                              new base::StringValue("two")).release());
 167     scoped_ptr<TakesEnumArray::Params> params(
 168         TakesEnumArray::Params::Create(params_value));
 169     ASSERT_TRUE(params);
 170     EXPECT_EQ(2U, params->values.size());
 171     EXPECT_EQ(ENUMERATION_ONE, params->values[0]);
 172     EXPECT_EQ(ENUMERATION_TWO, params->values[1]);
 173   }
 174   {
 175     base::ListValue params_value;
 176     params_value.Append(List(new base::StringValue("invalid")).release());
 177     scoped_ptr<TakesEnumArray::Params> params(
 178         TakesEnumArray::Params::Create(params_value));
 179     EXPECT_FALSE(params);
 180   }
 181 }
 182
 183 TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) {
 184   {
 185     base::ListValue params_value;
 186     params_value.Append(new base::StringValue("three"));
 187     scoped_ptr<TakesOptionalEnum::Params> params(
 188         TakesOptionalEnum::Params::Create(params_value));
 189     EXPECT_TRUE(params.get());
 190     EXPECT_EQ(ENUMERATION_THREE, params->state);
 191   }
 192   {
 193     base::ListValue params_value;
 194     scoped_ptr<TakesOptionalEnum::Params> params(
 195         TakesOptionalEnum::Params::Create(params_value));
 196     EXPECT_TRUE(params.get());
 197     EXPECT_EQ(ENUMERATION_NONE, params->state);
 198   }
 199   {
 200     base::ListValue params_value;
 201     params_value.Append(new base::StringValue("invalid"));
 202     scoped_ptr<TakesOptionalEnum::Params> params(
 203         TakesOptionalEnum::Params::Create(params_value));
 204     EXPECT_FALSE(params.get());
 205   }
 206 }
 207
 208 TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) {
 209   {
 210     base::ListValue params_value;
 211     params_value.Append(new base::StringValue("one"));
 212     params_value.Append(new base::StringValue("ham"));
 213     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
 214         TakesMultipleOptionalEnums::Params::Create(params_value));
 215     EXPECT_TRUE(params.get());
 216     EXPECT_EQ(ENUMERATION_ONE, params->state);
 217     EXPECT_EQ(OTHER_ENUMERATION_HAM, params->type);
 218   }
 219   {
 220     base::ListValue params_value;
 221     params_value.Append(new base::StringValue("one"));
 222     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
 223         TakesMultipleOptionalEnums::Params::Create(params_value));
 224     EXPECT_TRUE(params.get());
 225     EXPECT_EQ(ENUMERATION_ONE, params->state);
 226     EXPECT_EQ(OTHER_ENUMERATION_NONE, params->type);
 227   }
 228   {
 229     base::ListValue params_value;
 230     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
 231         TakesMultipleOptionalEnums::Params::Create(params_value));
 232     EXPECT_TRUE(params.get());
 233     EXPECT_EQ(ENUMERATION_NONE, params->state);
 234     EXPECT_EQ(OTHER_ENUMERATION_NONE, params->type);
 235   }
 236   {
 237     base::ListValue params_value;
 238     params_value.Append(new base::StringValue("three"));
 239     params_value.Append(new base::StringValue("invalid"));
 240     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
 241         TakesMultipleOptionalEnums::Params::Create(params_value));
 242     EXPECT_FALSE(params.get());
 243   }
 244 }
 245
 246 TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) {
 247   {
 248     Enumeration some_enum = ENUMERATION_ONE;
 249     scoped_ptr<base::Value> result(new base::StringValue(ToString(some_enum)));
 250     scoped_ptr<base::Value> expected(new base::StringValue("one"));
 251     EXPECT_TRUE(result->Equals(expected.get()));
 252   }
 253   {
 254     Enumeration some_enum = ENUMERATION_ONE;
 255     scoped_ptr<base::ListValue> results(OnEnumFired::Create(some_enum));
 256     base::ListValue expected;
 257     expected.Append(new base::StringValue("one"));
 258     EXPECT_TRUE(results->Equals(&expected));
 259   }
 260 }
 261
 262 TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) {
 263   {
 264     scoped_ptr<base::Value> results(
 265         OnTwoEnumsFired::Create(ENUMERATION_ONE, OTHER_ENUMERATION_HAM));
 266     base::ListValue expected;
 267     expected.Append(new base::StringValue("one"));
 268     expected.Append(new base::StringValue("ham"));
 269     EXPECT_TRUE(results->Equals(&expected));
 270   }
 271 }