Home | History | Annotate | Download | only in test 
      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 }
    262