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    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
30TEST(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
75TEST(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
96TEST(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
113TEST(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
125TEST(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
149TEST(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
167TEST(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
188TEST(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
213TEST(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
251TEST(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
268TEST(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}
279