OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "tools/json_schema_compiler/test/arrays.h" | 5 #include "tools/json_schema_compiler/test/arrays.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 | 10 |
11 #include "base/macros.h" | 11 #include "base/macros.h" |
12 #include "testing/gtest/include/gtest/gtest.h" | 12 #include "testing/gtest/include/gtest/gtest.h" |
13 #include "tools/json_schema_compiler/test/enums.h" | 13 #include "tools/json_schema_compiler/test/enums.h" |
14 | 14 |
15 using namespace test::api::arrays; | 15 using namespace test::api::arrays; |
16 | 16 |
17 namespace { | 17 namespace { |
18 | 18 |
19 // TODO(calamity): Change to AppendString etc once kalman's patch goes through | 19 // TODO(calamity): Change to AppendString etc once kalman's patch goes through |
20 static std::unique_ptr<base::DictionaryValue> CreateBasicArrayTypeDictionary() { | 20 static std::unique_ptr<base::DictionaryValue> CreateBasicArrayTypeDictionary() { |
21 std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue()); | 21 std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue()); |
22 base::ListValue* strings_value = new base::ListValue(); | 22 base::ListValue* strings_value = new base::ListValue(); |
23 strings_value->Append(new base::StringValue("a")); | 23 strings_value->AppendString("a"); |
24 strings_value->Append(new base::StringValue("b")); | 24 strings_value->AppendString("b"); |
25 strings_value->Append(new base::StringValue("c")); | 25 strings_value->AppendString("c"); |
26 strings_value->Append(new base::StringValue("it's easy as")); | 26 strings_value->AppendString("it's easy as"); |
27 base::ListValue* integers_value = new base::ListValue(); | 27 base::ListValue* integers_value = new base::ListValue(); |
28 integers_value->Append(new base::FundamentalValue(1)); | 28 integers_value->AppendInteger(1); |
29 integers_value->Append(new base::FundamentalValue(2)); | 29 integers_value->AppendInteger(2); |
30 integers_value->Append(new base::FundamentalValue(3)); | 30 integers_value->AppendInteger(3); |
31 base::ListValue* booleans_value = new base::ListValue(); | 31 base::ListValue* booleans_value = new base::ListValue(); |
32 booleans_value->Append(new base::FundamentalValue(false)); | 32 booleans_value->AppendBoolean(false); |
33 booleans_value->Append(new base::FundamentalValue(true)); | 33 booleans_value->AppendBoolean(true); |
34 base::ListValue* numbers_value = new base::ListValue(); | 34 base::ListValue* numbers_value = new base::ListValue(); |
35 numbers_value->Append(new base::FundamentalValue(6.1)); | 35 numbers_value->AppendDouble(6.1); |
36 value->Set("numbers", numbers_value); | 36 value->Set("numbers", numbers_value); |
37 value->Set("booleans", booleans_value); | 37 value->Set("booleans", booleans_value); |
38 value->Set("strings", strings_value); | 38 value->Set("strings", strings_value); |
39 value->Set("integers", integers_value); | 39 value->Set("integers", integers_value); |
40 return value; | 40 return value; |
41 } | 41 } |
42 | 42 |
43 static base::Value* CreateItemValue(int val) { | 43 static base::Value* CreateItemValue(int val) { |
44 base::DictionaryValue* value(new base::DictionaryValue()); | 44 base::DictionaryValue* value(new base::DictionaryValue()); |
45 value->Set("val", new base::FundamentalValue(val)); | 45 value->Set("val", new base::FundamentalValue(val)); |
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
126 | 126 |
127 TEST(JsonSchemaCompilerArrayTest, OptionalEnumArrayType) { | 127 TEST(JsonSchemaCompilerArrayTest, OptionalEnumArrayType) { |
128 { | 128 { |
129 std::vector<Enumeration> enums; | 129 std::vector<Enumeration> enums; |
130 enums.push_back(ENUMERATION_ONE); | 130 enums.push_back(ENUMERATION_ONE); |
131 enums.push_back(ENUMERATION_TWO); | 131 enums.push_back(ENUMERATION_TWO); |
132 enums.push_back(ENUMERATION_THREE); | 132 enums.push_back(ENUMERATION_THREE); |
133 | 133 |
134 std::unique_ptr<base::ListValue> types(new base::ListValue()); | 134 std::unique_ptr<base::ListValue> types(new base::ListValue()); |
135 for (size_t i = 0; i < enums.size(); ++i) | 135 for (size_t i = 0; i < enums.size(); ++i) |
136 types->Append(new base::StringValue(ToString(enums[i]))); | 136 types->AppendString(ToString(enums[i])); |
137 | 137 |
138 base::DictionaryValue value; | 138 base::DictionaryValue value; |
139 value.Set("types", types.release()); | 139 value.Set("types", types.release()); |
140 | 140 |
141 OptionalEnumArrayType enum_array_type; | 141 OptionalEnumArrayType enum_array_type; |
142 ASSERT_TRUE(OptionalEnumArrayType::Populate(value, &enum_array_type)); | 142 ASSERT_TRUE(OptionalEnumArrayType::Populate(value, &enum_array_type)); |
143 EXPECT_EQ(enums, *enum_array_type.types); | 143 EXPECT_EQ(enums, *enum_array_type.types); |
144 } | 144 } |
145 { | 145 { |
146 base::DictionaryValue value; | 146 base::DictionaryValue value; |
147 std::unique_ptr<base::ListValue> enum_array(new base::ListValue()); | 147 std::unique_ptr<base::ListValue> enum_array(new base::ListValue()); |
148 enum_array->Append(new base::StringValue("invalid")); | 148 enum_array->AppendString("invalid"); |
149 | 149 |
150 value.Set("types", enum_array.release()); | 150 value.Set("types", enum_array.release()); |
151 OptionalEnumArrayType enum_array_type; | 151 OptionalEnumArrayType enum_array_type; |
152 ASSERT_FALSE(OptionalEnumArrayType::Populate(value, &enum_array_type)); | 152 ASSERT_FALSE(OptionalEnumArrayType::Populate(value, &enum_array_type)); |
153 EXPECT_TRUE(enum_array_type.types->empty()); | 153 EXPECT_TRUE(enum_array_type.types->empty()); |
154 } | 154 } |
155 } | 155 } |
156 | 156 |
157 TEST(JsonSchemaCompilerArrayTest, RefArrayType) { | 157 TEST(JsonSchemaCompilerArrayTest, RefArrayType) { |
158 { | 158 { |
159 std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue()); | 159 std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue()); |
160 std::unique_ptr<base::ListValue> ref_array(new base::ListValue()); | 160 std::unique_ptr<base::ListValue> ref_array(new base::ListValue()); |
161 ref_array->Append(CreateItemValue(1)); | 161 ref_array->Append(CreateItemValue(1)); |
162 ref_array->Append(CreateItemValue(2)); | 162 ref_array->Append(CreateItemValue(2)); |
163 ref_array->Append(CreateItemValue(3)); | 163 ref_array->Append(CreateItemValue(3)); |
164 value->Set("refs", ref_array.release()); | 164 value->Set("refs", ref_array.release()); |
165 std::unique_ptr<RefArrayType> ref_array_type(new RefArrayType()); | 165 std::unique_ptr<RefArrayType> ref_array_type(new RefArrayType()); |
166 EXPECT_TRUE(RefArrayType::Populate(*value, ref_array_type.get())); | 166 EXPECT_TRUE(RefArrayType::Populate(*value, ref_array_type.get())); |
167 ASSERT_EQ(3u, ref_array_type->refs.size()); | 167 ASSERT_EQ(3u, ref_array_type->refs.size()); |
168 EXPECT_EQ(1, ref_array_type->refs[0].val); | 168 EXPECT_EQ(1, ref_array_type->refs[0].val); |
169 EXPECT_EQ(2, ref_array_type->refs[1].val); | 169 EXPECT_EQ(2, ref_array_type->refs[1].val); |
170 EXPECT_EQ(3, ref_array_type->refs[2].val); | 170 EXPECT_EQ(3, ref_array_type->refs[2].val); |
171 } | 171 } |
172 { | 172 { |
173 std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue()); | 173 std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue()); |
174 std::unique_ptr<base::ListValue> not_ref_array(new base::ListValue()); | 174 std::unique_ptr<base::ListValue> not_ref_array(new base::ListValue()); |
175 not_ref_array->Append(CreateItemValue(1)); | 175 not_ref_array->Append(CreateItemValue(1)); |
176 not_ref_array->Append(new base::FundamentalValue(3)); | 176 not_ref_array->AppendInteger(3); |
177 value->Set("refs", not_ref_array.release()); | 177 value->Set("refs", not_ref_array.release()); |
178 std::unique_ptr<RefArrayType> ref_array_type(new RefArrayType()); | 178 std::unique_ptr<RefArrayType> ref_array_type(new RefArrayType()); |
179 EXPECT_FALSE(RefArrayType::Populate(*value, ref_array_type.get())); | 179 EXPECT_FALSE(RefArrayType::Populate(*value, ref_array_type.get())); |
180 } | 180 } |
181 } | 181 } |
182 | 182 |
183 TEST(JsonSchemaCompilerArrayTest, IntegerArrayParamsCreate) { | 183 TEST(JsonSchemaCompilerArrayTest, IntegerArrayParamsCreate) { |
184 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); | 184 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
185 std::unique_ptr<base::ListValue> integer_array(new base::ListValue()); | 185 std::unique_ptr<base::ListValue> integer_array(new base::ListValue()); |
186 integer_array->Append(new base::FundamentalValue(2)); | 186 integer_array->AppendInteger(2); |
187 integer_array->Append(new base::FundamentalValue(4)); | 187 integer_array->AppendInteger(4); |
188 integer_array->Append(new base::FundamentalValue(8)); | 188 integer_array->AppendInteger(8); |
189 params_value->Append(integer_array.release()); | 189 params_value->Append(integer_array.release()); |
190 std::unique_ptr<IntegerArray::Params> params( | 190 std::unique_ptr<IntegerArray::Params> params( |
191 IntegerArray::Params::Create(*params_value)); | 191 IntegerArray::Params::Create(*params_value)); |
192 EXPECT_TRUE(params.get()); | 192 EXPECT_TRUE(params.get()); |
193 ASSERT_EQ(3u, params->nums.size()); | 193 ASSERT_EQ(3u, params->nums.size()); |
194 EXPECT_EQ(2, params->nums[0]); | 194 EXPECT_EQ(2, params->nums[0]); |
195 EXPECT_EQ(4, params->nums[1]); | 195 EXPECT_EQ(4, params->nums[1]); |
196 EXPECT_EQ(8, params->nums[2]); | 196 EXPECT_EQ(8, params->nums[2]); |
197 } | 197 } |
198 | 198 |
199 TEST(JsonSchemaCompilerArrayTest, AnyArrayParamsCreate) { | 199 TEST(JsonSchemaCompilerArrayTest, AnyArrayParamsCreate) { |
200 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); | 200 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
201 std::unique_ptr<base::ListValue> any_array(new base::ListValue()); | 201 std::unique_ptr<base::ListValue> any_array(new base::ListValue()); |
202 any_array->Append(new base::FundamentalValue(1)); | 202 any_array->AppendInteger(1); |
203 any_array->Append(new base::StringValue("test")); | 203 any_array->AppendString("test"); |
204 any_array->Append(CreateItemValue(2)); | 204 any_array->Append(CreateItemValue(2)); |
205 params_value->Append(any_array.release()); | 205 params_value->Append(any_array.release()); |
206 std::unique_ptr<AnyArray::Params> params( | 206 std::unique_ptr<AnyArray::Params> params( |
207 AnyArray::Params::Create(*params_value)); | 207 AnyArray::Params::Create(*params_value)); |
208 EXPECT_TRUE(params.get()); | 208 EXPECT_TRUE(params.get()); |
209 ASSERT_EQ(3u, params->anys.size()); | 209 ASSERT_EQ(3u, params->anys.size()); |
210 int int_temp = 0; | 210 int int_temp = 0; |
211 EXPECT_TRUE(params->anys[0]->GetAsInteger(&int_temp)); | 211 EXPECT_TRUE(params->anys[0]->GetAsInteger(&int_temp)); |
212 EXPECT_EQ(1, int_temp); | 212 EXPECT_EQ(1, int_temp); |
213 } | 213 } |
(...skipping 28 matching lines...) Expand all Loading... |
242 | 242 |
243 TEST(JsonSchemaCompilerArrayTest, ReturnIntegerArrayResultCreate) { | 243 TEST(JsonSchemaCompilerArrayTest, ReturnIntegerArrayResultCreate) { |
244 std::vector<int> integers; | 244 std::vector<int> integers; |
245 integers.push_back(1); | 245 integers.push_back(1); |
246 integers.push_back(2); | 246 integers.push_back(2); |
247 std::unique_ptr<base::ListValue> results = | 247 std::unique_ptr<base::ListValue> results = |
248 ReturnIntegerArray::Results::Create(integers); | 248 ReturnIntegerArray::Results::Create(integers); |
249 | 249 |
250 base::ListValue expected; | 250 base::ListValue expected; |
251 base::ListValue* expected_argument = new base::ListValue(); | 251 base::ListValue* expected_argument = new base::ListValue(); |
252 expected_argument->Append(new base::FundamentalValue(1)); | 252 expected_argument->AppendInteger(1); |
253 expected_argument->Append(new base::FundamentalValue(2)); | 253 expected_argument->AppendInteger(2); |
254 expected.Append(expected_argument); | 254 expected.Append(expected_argument); |
255 EXPECT_TRUE(results->Equals(&expected)); | 255 EXPECT_TRUE(results->Equals(&expected)); |
256 } | 256 } |
257 | 257 |
258 TEST(JsonSchemaCompilerArrayTest, ReturnRefArrayResultCreate) { | 258 TEST(JsonSchemaCompilerArrayTest, ReturnRefArrayResultCreate) { |
259 std::vector<Item> items; | 259 std::vector<Item> items; |
260 items.push_back(Item()); | 260 items.push_back(Item()); |
261 items.push_back(Item()); | 261 items.push_back(Item()); |
262 items[0].val = 1; | 262 items[0].val = 1; |
263 items[1].val = 2; | 263 items[1].val = 2; |
264 std::unique_ptr<base::ListValue> results = | 264 std::unique_ptr<base::ListValue> results = |
265 ReturnRefArray::Results::Create(items); | 265 ReturnRefArray::Results::Create(items); |
266 | 266 |
267 base::ListValue expected; | 267 base::ListValue expected; |
268 base::ListValue* expected_argument = new base::ListValue(); | 268 base::ListValue* expected_argument = new base::ListValue(); |
269 base::DictionaryValue* first = new base::DictionaryValue(); | 269 base::DictionaryValue* first = new base::DictionaryValue(); |
270 first->SetInteger("val", 1); | 270 first->SetInteger("val", 1); |
271 expected_argument->Append(first); | 271 expected_argument->Append(first); |
272 base::DictionaryValue* second = new base::DictionaryValue(); | 272 base::DictionaryValue* second = new base::DictionaryValue(); |
273 second->SetInteger("val", 2); | 273 second->SetInteger("val", 2); |
274 expected_argument->Append(second); | 274 expected_argument->Append(second); |
275 expected.Append(expected_argument); | 275 expected.Append(expected_argument); |
276 EXPECT_TRUE(results->Equals(&expected)); | 276 EXPECT_TRUE(results->Equals(&expected)); |
277 } | 277 } |
OLD | NEW |