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