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/choices.h"
6
7 #include "base/strings/string_piece.h"
8 #include "testing/gtest/include/gtest/gtest.h"
9 #include "tools/json_schema_compiler/test/test_util.h"
10
11 namespace {
12
13 using namespace test::api::choices;
14 using json_schema_compiler::test_util::Dictionary;
15 using json_schema_compiler::test_util::List;
16 using json_schema_compiler::test_util::ReadJson;
17 using json_schema_compiler::test_util::Vector;
18
TEST(JsonSchemaCompilerChoicesTest,TakesIntegersParamsCreate)19 TEST(JsonSchemaCompilerChoicesTest, TakesIntegersParamsCreate) {
20 {
21 scoped_ptr<TakesIntegers::Params> params(
22 TakesIntegers::Params::Create(*List(new base::FundamentalValue(true))));
23 EXPECT_FALSE(params);
24 }
25 {
26 scoped_ptr<TakesIntegers::Params> params(
27 TakesIntegers::Params::Create(*List(new base::FundamentalValue(6))));
28 ASSERT_TRUE(params);
29 EXPECT_FALSE(params->nums.as_integers);
30 EXPECT_EQ(6, *params->nums.as_integer);
31 }
32 {
33 scoped_ptr<TakesIntegers::Params> params(TakesIntegers::Params::Create(
34 *List(List(new base::FundamentalValue(2),
35 new base::FundamentalValue(6),
36 new base::FundamentalValue(8)).release())));
37 ASSERT_TRUE(params);
38 ASSERT_TRUE(params->nums.as_integers);
39 EXPECT_EQ(Vector(2, 6, 8), *params->nums.as_integers);
40 }
41 }
42
TEST(JsonSchemaCompilerChoicesTest,ObjectWithChoicesParamsCreate)43 TEST(JsonSchemaCompilerChoicesTest, ObjectWithChoicesParamsCreate) {
44 {
45 scoped_ptr<ObjectWithChoices::Params> params(
46 ObjectWithChoices::Params::Create(*List(
47 Dictionary("strings", new base::StringValue("asdf")).release())));
48 ASSERT_TRUE(params);
49 EXPECT_FALSE(params->string_info.strings.as_strings);
50 EXPECT_EQ("asdf", *params->string_info.strings.as_string);
51 EXPECT_FALSE(params->string_info.integers);
52 }
53 {
54 scoped_ptr<ObjectWithChoices::Params> params(
55 ObjectWithChoices::Params::Create(*List(
56 Dictionary("strings", new base::StringValue("asdf"),
57 "integers", new base::FundamentalValue(6)).release())));
58 ASSERT_TRUE(params);
59 EXPECT_FALSE(params->string_info.strings.as_strings);
60 EXPECT_EQ("asdf", *params->string_info.strings.as_string);
61 ASSERT_TRUE(params->string_info.integers);
62 EXPECT_FALSE(params->string_info.integers->as_integers);
63 EXPECT_EQ(6, *params->string_info.integers->as_integer);
64 }
65 }
66
67 // TODO(kalman): Clean up the rest of these tests to use the
68 // Vector/List/Dictionary helpers.
69
TEST(JsonSchemaCompilerChoicesTest,ObjectWithChoicesParamsCreateFail)70 TEST(JsonSchemaCompilerChoicesTest, ObjectWithChoicesParamsCreateFail) {
71 {
72 scoped_ptr<base::DictionaryValue> object_param(new base::DictionaryValue());
73 object_param->SetWithoutPathExpansion("strings",
74 new base::FundamentalValue(5));
75 scoped_ptr<base::ListValue> params_value(new base::ListValue());
76 params_value->Append(object_param.release());
77 scoped_ptr<ObjectWithChoices::Params> params(
78 ObjectWithChoices::Params::Create(*params_value));
79 EXPECT_FALSE(params.get());
80 }
81 {
82 scoped_ptr<base::DictionaryValue> object_param(new base::DictionaryValue());
83 object_param->SetWithoutPathExpansion("strings",
84 new base::StringValue("asdf"));
85 object_param->SetWithoutPathExpansion("integers",
86 new base::StringValue("asdf"));
87 scoped_ptr<base::ListValue> params_value(new base::ListValue());
88 params_value->Append(object_param.release());
89 scoped_ptr<ObjectWithChoices::Params> params(
90 ObjectWithChoices::Params::Create(*params_value));
91 EXPECT_FALSE(params.get());
92 }
93 {
94 scoped_ptr<base::DictionaryValue> object_param(new base::DictionaryValue());
95 object_param->SetWithoutPathExpansion("integers",
96 new base::FundamentalValue(6));
97 scoped_ptr<base::ListValue> params_value(new base::ListValue());
98 params_value->Append(object_param.release());
99 scoped_ptr<ObjectWithChoices::Params> params(
100 ObjectWithChoices::Params::Create(*params_value));
101 EXPECT_FALSE(params.get());
102 }
103 }
104
TEST(JsonSchemaCompilerChoicesTest,PopulateChoiceType)105 TEST(JsonSchemaCompilerChoicesTest, PopulateChoiceType) {
106 std::vector<std::string> strings = Vector(std::string("list"),
107 std::string("of"),
108 std::string("strings"));
109
110 base::ListValue* strings_value = new base::ListValue();
111 for (size_t i = 0; i < strings.size(); ++i)
112 strings_value->Append(new base::StringValue(strings[i]));
113
114 base::DictionaryValue value;
115 value.SetInteger("integers", 4);
116 value.Set("strings", strings_value);
117
118 ChoiceType out;
119 ASSERT_TRUE(ChoiceType::Populate(value, &out));
120 ASSERT_TRUE(out.integers.as_integer.get());
121 EXPECT_FALSE(out.integers.as_integers.get());
122 EXPECT_EQ(4, *out.integers.as_integer);
123
124 EXPECT_FALSE(out.strings->as_string.get());
125 ASSERT_TRUE(out.strings->as_strings.get());
126 EXPECT_EQ(strings, *out.strings->as_strings);
127 }
128
TEST(JsonSchemaCompilerChoicesTest,ChoiceTypeToValue)129 TEST(JsonSchemaCompilerChoicesTest, ChoiceTypeToValue) {
130 base::ListValue* strings_value = new base::ListValue();
131 strings_value->Append(new base::StringValue("list"));
132 strings_value->Append(new base::StringValue("of"));
133 strings_value->Append(new base::StringValue("strings"));
134
135 base::DictionaryValue value;
136 value.SetInteger("integers", 5);
137 value.Set("strings", strings_value);
138
139 ChoiceType out;
140 ASSERT_TRUE(ChoiceType::Populate(value, &out));
141
142 EXPECT_TRUE(value.Equals(out.ToValue().get()));
143 }
144
TEST(JsonSchemaCompilerChoicesTest,ReturnChoices)145 TEST(JsonSchemaCompilerChoicesTest, ReturnChoices) {
146 {
147 ReturnChoices::Results::Result results;
148 results.as_integers.reset(new std::vector<int>(Vector(1, 2)));
149
150 scoped_ptr<base::Value> results_value = results.ToValue();
151 ASSERT_TRUE(results_value);
152
153 base::ListValue expected;
154 expected.AppendInteger(1);
155 expected.AppendInteger(2);
156
157 EXPECT_TRUE(expected.Equals(results_value.get()));
158 }
159 {
160 ReturnChoices::Results::Result results;
161 results.as_integer.reset(new int(5));
162
163 scoped_ptr<base::Value> results_value = results.ToValue();
164 ASSERT_TRUE(results_value);
165
166 base::FundamentalValue expected(5);
167
168 EXPECT_TRUE(expected.Equals(results_value.get()));
169 }
170 }
171
TEST(JsonSchemaCompilerChoicesTest,NestedChoices)172 TEST(JsonSchemaCompilerChoicesTest, NestedChoices) {
173 // These test both ToValue and FromValue for every legitimate configuration of
174 // NestedChoices.
175 {
176 // The plain integer choice.
177 scoped_ptr<base::Value> value = ReadJson("42");
178 scoped_ptr<NestedChoice> obj = NestedChoice::FromValue(*value);
179
180 ASSERT_TRUE(obj);
181 ASSERT_TRUE(obj->as_integer);
182 EXPECT_FALSE(obj->as_choice1);
183 EXPECT_FALSE(obj->as_choice2);
184 EXPECT_EQ(42, *obj->as_integer);
185
186 EXPECT_TRUE(base::Value::Equals(value.get(), obj->ToValue().get()));
187 }
188
189 {
190 // The string choice within the first choice.
191 scoped_ptr<base::Value> value = ReadJson("\"foo\"");
192 scoped_ptr<NestedChoice> obj = NestedChoice::FromValue(*value);
193
194 ASSERT_TRUE(obj);
195 EXPECT_FALSE(obj->as_integer);
196 ASSERT_TRUE(obj->as_choice1);
197 EXPECT_FALSE(obj->as_choice2);
198 ASSERT_TRUE(obj->as_choice1->as_string);
199 EXPECT_FALSE(obj->as_choice1->as_boolean);
200 EXPECT_EQ("foo", *obj->as_choice1->as_string);
201
202 EXPECT_TRUE(base::Value::Equals(value.get(), obj->ToValue().get()));
203 }
204
205 {
206 // The boolean choice within the first choice.
207 scoped_ptr<base::Value> value = ReadJson("true");
208 scoped_ptr<NestedChoice> obj = NestedChoice::FromValue(*value);
209
210 ASSERT_TRUE(obj);
211 EXPECT_FALSE(obj->as_integer);
212 ASSERT_TRUE(obj->as_choice1);
213 EXPECT_FALSE(obj->as_choice2);
214 EXPECT_FALSE(obj->as_choice1->as_string);
215 ASSERT_TRUE(obj->as_choice1->as_boolean);
216 EXPECT_TRUE(*obj->as_choice1->as_boolean);
217
218 EXPECT_TRUE(base::Value::Equals(value.get(), obj->ToValue().get()));
219 }
220
221 {
222 // The double choice within the second choice.
223 scoped_ptr<base::Value> value = ReadJson("42.0");
224 scoped_ptr<NestedChoice> obj = NestedChoice::FromValue(*value);
225
226 ASSERT_TRUE(obj);
227 EXPECT_FALSE(obj->as_integer);
228 EXPECT_FALSE(obj->as_choice1);
229 ASSERT_TRUE(obj->as_choice2);
230 ASSERT_TRUE(obj->as_choice2->as_double);
231 EXPECT_FALSE(obj->as_choice2->as_choice_type);
232 EXPECT_FALSE(obj->as_choice2->as_choice_types);
233 EXPECT_EQ(42.0, *obj->as_choice2->as_double);
234
235 EXPECT_TRUE(base::Value::Equals(value.get(), obj->ToValue().get()));
236 }
237
238 {
239 // The ChoiceType choice within the second choice.
240 scoped_ptr<base::Value> value = ReadJson(
241 "{\"integers\": [1, 2], \"strings\": \"foo\"}");
242 scoped_ptr<NestedChoice> obj = NestedChoice::FromValue(*value);
243
244 ASSERT_TRUE(obj);
245 EXPECT_FALSE(obj->as_integer);
246 EXPECT_FALSE(obj->as_choice1);
247 ASSERT_TRUE(obj->as_choice2);
248 EXPECT_FALSE(obj->as_choice2->as_double);
249 ASSERT_TRUE(obj->as_choice2->as_choice_type);
250 EXPECT_FALSE(obj->as_choice2->as_choice_types);
251 {
252 ChoiceType* choice_type = obj->as_choice2->as_choice_type.get();
253 ASSERT_TRUE(choice_type->integers.as_integers);
254 EXPECT_FALSE(choice_type->integers.as_integer);
255 EXPECT_EQ(Vector(1, 2), *choice_type->integers.as_integers);
256 ASSERT_TRUE(choice_type->strings);
257 EXPECT_FALSE(choice_type->strings->as_strings);
258 ASSERT_TRUE(choice_type->strings->as_string);
259 EXPECT_EQ("foo", *choice_type->strings->as_string);
260 }
261
262 EXPECT_TRUE(base::Value::Equals(value.get(), obj->ToValue().get()));
263 }
264
265 {
266 // The array of ChoiceTypes within the second choice.
267 scoped_ptr<base::Value> value = ReadJson(
268 "["
269 " {\"integers\": [1, 2], \"strings\": \"foo\"},"
270 " {\"integers\": 3, \"strings\": [\"bar\", \"baz\"]}"
271 "]");
272 scoped_ptr<NestedChoice> obj = NestedChoice::FromValue(*value);
273
274 ASSERT_TRUE(obj);
275 EXPECT_FALSE(obj->as_integer);
276 EXPECT_FALSE(obj->as_choice1);
277 ASSERT_TRUE(obj->as_choice2);
278 EXPECT_FALSE(obj->as_choice2->as_double);
279 EXPECT_FALSE(obj->as_choice2->as_choice_type);
280 ASSERT_TRUE(obj->as_choice2->as_choice_types);
281 {
282 std::vector<linked_ptr<ChoiceType> >* choice_types =
283 obj->as_choice2->as_choice_types.get();
284 // Bleh too much effort to test everything.
285 ASSERT_EQ(2u, choice_types->size());
286 }
287
288 EXPECT_TRUE(base::Value::Equals(value.get(), obj->ToValue().get()));
289 }
290 }
291
292 } // namespace
293