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
10using namespace test::api::enums;
11using json_schema_compiler::test_util::List;
12
13TEST(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
30TEST(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
58TEST(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
79TEST(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
96TEST(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
108TEST(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
132TEST(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
150TEST(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
171TEST(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
196TEST(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
234TEST(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
251TEST(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