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