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