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> |
| 10 |
9 #include "base/macros.h" | 11 #include "base/macros.h" |
10 #include "testing/gtest/include/gtest/gtest.h" | 12 #include "testing/gtest/include/gtest/gtest.h" |
11 #include "tools/json_schema_compiler/test/enums.h" | 13 #include "tools/json_schema_compiler/test/enums.h" |
12 | 14 |
13 using namespace test::api::arrays; | 15 using namespace test::api::arrays; |
14 | 16 |
15 namespace { | 17 namespace { |
16 | 18 |
17 // 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 |
18 static scoped_ptr<base::DictionaryValue> CreateBasicArrayTypeDictionary() { | 20 static std::unique_ptr<base::DictionaryValue> CreateBasicArrayTypeDictionary() { |
19 base::DictionaryValue* value = new base::DictionaryValue(); | 21 std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue()); |
20 base::ListValue* strings_value = new base::ListValue(); | 22 base::ListValue* strings_value = new base::ListValue(); |
21 strings_value->Append(new base::StringValue("a")); | 23 strings_value->Append(new base::StringValue("a")); |
22 strings_value->Append(new base::StringValue("b")); | 24 strings_value->Append(new base::StringValue("b")); |
23 strings_value->Append(new base::StringValue("c")); | 25 strings_value->Append(new base::StringValue("c")); |
24 strings_value->Append(new base::StringValue("it's easy as")); | 26 strings_value->Append(new base::StringValue("it's easy as")); |
25 base::ListValue* integers_value = new base::ListValue(); | 27 base::ListValue* integers_value = new base::ListValue(); |
26 integers_value->Append(new base::FundamentalValue(1)); | 28 integers_value->Append(new base::FundamentalValue(1)); |
27 integers_value->Append(new base::FundamentalValue(2)); | 29 integers_value->Append(new base::FundamentalValue(2)); |
28 integers_value->Append(new base::FundamentalValue(3)); | 30 integers_value->Append(new base::FundamentalValue(3)); |
29 base::ListValue* booleans_value = new base::ListValue(); | 31 base::ListValue* booleans_value = new base::ListValue(); |
30 booleans_value->Append(new base::FundamentalValue(false)); | 32 booleans_value->Append(new base::FundamentalValue(false)); |
31 booleans_value->Append(new base::FundamentalValue(true)); | 33 booleans_value->Append(new base::FundamentalValue(true)); |
32 base::ListValue* numbers_value = new base::ListValue(); | 34 base::ListValue* numbers_value = new base::ListValue(); |
33 numbers_value->Append(new base::FundamentalValue(6.1)); | 35 numbers_value->Append(new base::FundamentalValue(6.1)); |
34 value->Set("numbers", numbers_value); | 36 value->Set("numbers", numbers_value); |
35 value->Set("booleans", booleans_value); | 37 value->Set("booleans", booleans_value); |
36 value->Set("strings", strings_value); | 38 value->Set("strings", strings_value); |
37 value->Set("integers", integers_value); | 39 value->Set("integers", integers_value); |
38 return scoped_ptr<base::DictionaryValue>(value); | 40 return value; |
39 } | 41 } |
40 | 42 |
41 static base::Value* CreateItemValue(int val) { | 43 static base::Value* CreateItemValue(int val) { |
42 base::DictionaryValue* value(new base::DictionaryValue()); | 44 base::DictionaryValue* value(new base::DictionaryValue()); |
43 value->Set("val", new base::FundamentalValue(val)); | 45 value->Set("val", new base::FundamentalValue(val)); |
44 return value; | 46 return value; |
45 } | 47 } |
46 | 48 |
47 } // namespace | 49 } // namespace |
48 | 50 |
49 TEST(JsonSchemaCompilerArrayTest, BasicArrayType) { | 51 TEST(JsonSchemaCompilerArrayTest, BasicArrayType) { |
50 { | 52 { |
51 scoped_ptr<base::DictionaryValue> value = CreateBasicArrayTypeDictionary(); | 53 std::unique_ptr<base::DictionaryValue> value = |
52 scoped_ptr<BasicArrayType> basic_array_type(new BasicArrayType()); | 54 CreateBasicArrayTypeDictionary(); |
| 55 std::unique_ptr<BasicArrayType> basic_array_type(new BasicArrayType()); |
53 ASSERT_TRUE(BasicArrayType::Populate(*value, basic_array_type.get())); | 56 ASSERT_TRUE(BasicArrayType::Populate(*value, basic_array_type.get())); |
54 EXPECT_TRUE(value->Equals(basic_array_type->ToValue().get())); | 57 EXPECT_TRUE(value->Equals(basic_array_type->ToValue().get())); |
55 } | 58 } |
56 } | 59 } |
57 | 60 |
58 TEST(JsonSchemaCompilerArrayTest, EnumArrayReference) { | 61 TEST(JsonSchemaCompilerArrayTest, EnumArrayReference) { |
59 // { "types": ["one", "two", "three"] } | 62 // { "types": ["one", "two", "three"] } |
60 base::ListValue* types = new base::ListValue(); | 63 base::ListValue* types = new base::ListValue(); |
61 types->AppendString("one"); | 64 types->AppendString("one"); |
62 types->AppendString("two"); | 65 types->AppendString("two"); |
63 types->AppendString("three"); | 66 types->AppendString("three"); |
64 base::DictionaryValue value; | 67 base::DictionaryValue value; |
65 value.Set("types", types); | 68 value.Set("types", types); |
66 | 69 |
67 EnumArrayReference enum_array_reference; | 70 EnumArrayReference enum_array_reference; |
68 | 71 |
69 // Test Populate. | 72 // Test Populate. |
70 ASSERT_TRUE(EnumArrayReference::Populate(value, &enum_array_reference)); | 73 ASSERT_TRUE(EnumArrayReference::Populate(value, &enum_array_reference)); |
71 | 74 |
72 Enumeration expected_types[] = {ENUMERATION_ONE, ENUMERATION_TWO, | 75 Enumeration expected_types[] = {ENUMERATION_ONE, ENUMERATION_TWO, |
73 ENUMERATION_THREE}; | 76 ENUMERATION_THREE}; |
74 EXPECT_EQ(std::vector<Enumeration>( | 77 EXPECT_EQ(std::vector<Enumeration>( |
75 expected_types, expected_types + arraysize(expected_types)), | 78 expected_types, expected_types + arraysize(expected_types)), |
76 enum_array_reference.types); | 79 enum_array_reference.types); |
77 | 80 |
78 // Test ToValue. | 81 // Test ToValue. |
79 scoped_ptr<base::Value> as_value(enum_array_reference.ToValue()); | 82 std::unique_ptr<base::Value> as_value(enum_array_reference.ToValue()); |
80 EXPECT_TRUE(value.Equals(as_value.get())) << value << " != " << *as_value; | 83 EXPECT_TRUE(value.Equals(as_value.get())) << value << " != " << *as_value; |
81 } | 84 } |
82 | 85 |
83 TEST(JsonSchemaCompilerArrayTest, EnumArrayMixed) { | 86 TEST(JsonSchemaCompilerArrayTest, EnumArrayMixed) { |
84 // { "types": ["one", "two", "three"] } | 87 // { "types": ["one", "two", "three"] } |
85 base::ListValue* infile_enums = new base::ListValue(); | 88 base::ListValue* infile_enums = new base::ListValue(); |
86 infile_enums->AppendString("one"); | 89 infile_enums->AppendString("one"); |
87 infile_enums->AppendString("two"); | 90 infile_enums->AppendString("two"); |
88 infile_enums->AppendString("three"); | 91 infile_enums->AppendString("three"); |
89 | 92 |
(...skipping 20 matching lines...) Expand all Loading... |
110 | 113 |
111 test::api::enums::Enumeration expected_external_types[] = { | 114 test::api::enums::Enumeration expected_external_types[] = { |
112 test::api::enums::ENUMERATION_ONE, test::api::enums::ENUMERATION_TWO, | 115 test::api::enums::ENUMERATION_ONE, test::api::enums::ENUMERATION_TWO, |
113 test::api::enums::ENUMERATION_THREE}; | 116 test::api::enums::ENUMERATION_THREE}; |
114 EXPECT_EQ(std::vector<test::api::enums::Enumeration>( | 117 EXPECT_EQ(std::vector<test::api::enums::Enumeration>( |
115 expected_external_types, | 118 expected_external_types, |
116 expected_external_types + arraysize(expected_external_types)), | 119 expected_external_types + arraysize(expected_external_types)), |
117 enum_array_mixed.external_enums); | 120 enum_array_mixed.external_enums); |
118 | 121 |
119 // Test ToValue. | 122 // Test ToValue. |
120 scoped_ptr<base::Value> as_value(enum_array_mixed.ToValue()); | 123 std::unique_ptr<base::Value> as_value(enum_array_mixed.ToValue()); |
121 EXPECT_TRUE(value.Equals(as_value.get())) << value << " != " << *as_value; | 124 EXPECT_TRUE(value.Equals(as_value.get())) << value << " != " << *as_value; |
122 } | 125 } |
123 | 126 |
124 TEST(JsonSchemaCompilerArrayTest, OptionalEnumArrayType) { | 127 TEST(JsonSchemaCompilerArrayTest, OptionalEnumArrayType) { |
125 { | 128 { |
126 std::vector<Enumeration> enums; | 129 std::vector<Enumeration> enums; |
127 enums.push_back(ENUMERATION_ONE); | 130 enums.push_back(ENUMERATION_ONE); |
128 enums.push_back(ENUMERATION_TWO); | 131 enums.push_back(ENUMERATION_TWO); |
129 enums.push_back(ENUMERATION_THREE); | 132 enums.push_back(ENUMERATION_THREE); |
130 | 133 |
131 scoped_ptr<base::ListValue> types(new base::ListValue()); | 134 std::unique_ptr<base::ListValue> types(new base::ListValue()); |
132 for (size_t i = 0; i < enums.size(); ++i) | 135 for (size_t i = 0; i < enums.size(); ++i) |
133 types->Append(new base::StringValue(ToString(enums[i]))); | 136 types->Append(new base::StringValue(ToString(enums[i]))); |
134 | 137 |
135 base::DictionaryValue value; | 138 base::DictionaryValue value; |
136 value.Set("types", types.release()); | 139 value.Set("types", types.release()); |
137 | 140 |
138 OptionalEnumArrayType enum_array_type; | 141 OptionalEnumArrayType enum_array_type; |
139 ASSERT_TRUE(OptionalEnumArrayType::Populate(value, &enum_array_type)); | 142 ASSERT_TRUE(OptionalEnumArrayType::Populate(value, &enum_array_type)); |
140 EXPECT_EQ(enums, *enum_array_type.types); | 143 EXPECT_EQ(enums, *enum_array_type.types); |
141 } | 144 } |
142 { | 145 { |
143 base::DictionaryValue value; | 146 base::DictionaryValue value; |
144 scoped_ptr<base::ListValue> enum_array(new base::ListValue()); | 147 std::unique_ptr<base::ListValue> enum_array(new base::ListValue()); |
145 enum_array->Append(new base::StringValue("invalid")); | 148 enum_array->Append(new base::StringValue("invalid")); |
146 | 149 |
147 value.Set("types", enum_array.release()); | 150 value.Set("types", enum_array.release()); |
148 OptionalEnumArrayType enum_array_type; | 151 OptionalEnumArrayType enum_array_type; |
149 ASSERT_FALSE(OptionalEnumArrayType::Populate(value, &enum_array_type)); | 152 ASSERT_FALSE(OptionalEnumArrayType::Populate(value, &enum_array_type)); |
150 EXPECT_TRUE(enum_array_type.types->empty()); | 153 EXPECT_TRUE(enum_array_type.types->empty()); |
151 } | 154 } |
152 } | 155 } |
153 | 156 |
154 TEST(JsonSchemaCompilerArrayTest, RefArrayType) { | 157 TEST(JsonSchemaCompilerArrayTest, RefArrayType) { |
155 { | 158 { |
156 scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue()); | 159 std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue()); |
157 scoped_ptr<base::ListValue> ref_array(new base::ListValue()); | 160 std::unique_ptr<base::ListValue> ref_array(new base::ListValue()); |
158 ref_array->Append(CreateItemValue(1)); | 161 ref_array->Append(CreateItemValue(1)); |
159 ref_array->Append(CreateItemValue(2)); | 162 ref_array->Append(CreateItemValue(2)); |
160 ref_array->Append(CreateItemValue(3)); | 163 ref_array->Append(CreateItemValue(3)); |
161 value->Set("refs", ref_array.release()); | 164 value->Set("refs", ref_array.release()); |
162 scoped_ptr<RefArrayType> ref_array_type(new RefArrayType()); | 165 std::unique_ptr<RefArrayType> ref_array_type(new RefArrayType()); |
163 EXPECT_TRUE(RefArrayType::Populate(*value, ref_array_type.get())); | 166 EXPECT_TRUE(RefArrayType::Populate(*value, ref_array_type.get())); |
164 ASSERT_EQ(3u, ref_array_type->refs.size()); | 167 ASSERT_EQ(3u, ref_array_type->refs.size()); |
165 EXPECT_EQ(1, ref_array_type->refs[0].val); | 168 EXPECT_EQ(1, ref_array_type->refs[0].val); |
166 EXPECT_EQ(2, ref_array_type->refs[1].val); | 169 EXPECT_EQ(2, ref_array_type->refs[1].val); |
167 EXPECT_EQ(3, ref_array_type->refs[2].val); | 170 EXPECT_EQ(3, ref_array_type->refs[2].val); |
168 } | 171 } |
169 { | 172 { |
170 scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue()); | 173 std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue()); |
171 scoped_ptr<base::ListValue> not_ref_array(new base::ListValue()); | 174 std::unique_ptr<base::ListValue> not_ref_array(new base::ListValue()); |
172 not_ref_array->Append(CreateItemValue(1)); | 175 not_ref_array->Append(CreateItemValue(1)); |
173 not_ref_array->Append(new base::FundamentalValue(3)); | 176 not_ref_array->Append(new base::FundamentalValue(3)); |
174 value->Set("refs", not_ref_array.release()); | 177 value->Set("refs", not_ref_array.release()); |
175 scoped_ptr<RefArrayType> ref_array_type(new RefArrayType()); | 178 std::unique_ptr<RefArrayType> ref_array_type(new RefArrayType()); |
176 EXPECT_FALSE(RefArrayType::Populate(*value, ref_array_type.get())); | 179 EXPECT_FALSE(RefArrayType::Populate(*value, ref_array_type.get())); |
177 } | 180 } |
178 } | 181 } |
179 | 182 |
180 TEST(JsonSchemaCompilerArrayTest, IntegerArrayParamsCreate) { | 183 TEST(JsonSchemaCompilerArrayTest, IntegerArrayParamsCreate) { |
181 scoped_ptr<base::ListValue> params_value(new base::ListValue()); | 184 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
182 scoped_ptr<base::ListValue> integer_array(new base::ListValue()); | 185 std::unique_ptr<base::ListValue> integer_array(new base::ListValue()); |
183 integer_array->Append(new base::FundamentalValue(2)); | 186 integer_array->Append(new base::FundamentalValue(2)); |
184 integer_array->Append(new base::FundamentalValue(4)); | 187 integer_array->Append(new base::FundamentalValue(4)); |
185 integer_array->Append(new base::FundamentalValue(8)); | 188 integer_array->Append(new base::FundamentalValue(8)); |
186 params_value->Append(integer_array.release()); | 189 params_value->Append(integer_array.release()); |
187 scoped_ptr<IntegerArray::Params> params( | 190 std::unique_ptr<IntegerArray::Params> params( |
188 IntegerArray::Params::Create(*params_value)); | 191 IntegerArray::Params::Create(*params_value)); |
189 EXPECT_TRUE(params.get()); | 192 EXPECT_TRUE(params.get()); |
190 ASSERT_EQ(3u, params->nums.size()); | 193 ASSERT_EQ(3u, params->nums.size()); |
191 EXPECT_EQ(2, params->nums[0]); | 194 EXPECT_EQ(2, params->nums[0]); |
192 EXPECT_EQ(4, params->nums[1]); | 195 EXPECT_EQ(4, params->nums[1]); |
193 EXPECT_EQ(8, params->nums[2]); | 196 EXPECT_EQ(8, params->nums[2]); |
194 } | 197 } |
195 | 198 |
196 TEST(JsonSchemaCompilerArrayTest, AnyArrayParamsCreate) { | 199 TEST(JsonSchemaCompilerArrayTest, AnyArrayParamsCreate) { |
197 scoped_ptr<base::ListValue> params_value(new base::ListValue()); | 200 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
198 scoped_ptr<base::ListValue> any_array(new base::ListValue()); | 201 std::unique_ptr<base::ListValue> any_array(new base::ListValue()); |
199 any_array->Append(new base::FundamentalValue(1)); | 202 any_array->Append(new base::FundamentalValue(1)); |
200 any_array->Append(new base::StringValue("test")); | 203 any_array->Append(new base::StringValue("test")); |
201 any_array->Append(CreateItemValue(2)); | 204 any_array->Append(CreateItemValue(2)); |
202 params_value->Append(any_array.release()); | 205 params_value->Append(any_array.release()); |
203 scoped_ptr<AnyArray::Params> params( | 206 std::unique_ptr<AnyArray::Params> params( |
204 AnyArray::Params::Create(*params_value)); | 207 AnyArray::Params::Create(*params_value)); |
205 EXPECT_TRUE(params.get()); | 208 EXPECT_TRUE(params.get()); |
206 ASSERT_EQ(3u, params->anys.size()); | 209 ASSERT_EQ(3u, params->anys.size()); |
207 int int_temp = 0; | 210 int int_temp = 0; |
208 EXPECT_TRUE(params->anys[0]->GetAsInteger(&int_temp)); | 211 EXPECT_TRUE(params->anys[0]->GetAsInteger(&int_temp)); |
209 EXPECT_EQ(1, int_temp); | 212 EXPECT_EQ(1, int_temp); |
210 } | 213 } |
211 | 214 |
212 TEST(JsonSchemaCompilerArrayTest, ObjectArrayParamsCreate) { | 215 TEST(JsonSchemaCompilerArrayTest, ObjectArrayParamsCreate) { |
213 scoped_ptr<base::ListValue> params_value(new base::ListValue()); | 216 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
214 scoped_ptr<base::ListValue> item_array(new base::ListValue()); | 217 std::unique_ptr<base::ListValue> item_array(new base::ListValue()); |
215 item_array->Append(CreateItemValue(1)); | 218 item_array->Append(CreateItemValue(1)); |
216 item_array->Append(CreateItemValue(2)); | 219 item_array->Append(CreateItemValue(2)); |
217 params_value->Append(item_array.release()); | 220 params_value->Append(item_array.release()); |
218 scoped_ptr<ObjectArray::Params> params( | 221 std::unique_ptr<ObjectArray::Params> params( |
219 ObjectArray::Params::Create(*params_value)); | 222 ObjectArray::Params::Create(*params_value)); |
220 EXPECT_TRUE(params.get()); | 223 EXPECT_TRUE(params.get()); |
221 ASSERT_EQ(2u, params->objects.size()); | 224 ASSERT_EQ(2u, params->objects.size()); |
222 EXPECT_EQ(1, params->objects[0].additional_properties["val"]); | 225 EXPECT_EQ(1, params->objects[0].additional_properties["val"]); |
223 EXPECT_EQ(2, params->objects[1].additional_properties["val"]); | 226 EXPECT_EQ(2, params->objects[1].additional_properties["val"]); |
224 } | 227 } |
225 | 228 |
226 TEST(JsonSchemaCompilerArrayTest, RefArrayParamsCreate) { | 229 TEST(JsonSchemaCompilerArrayTest, RefArrayParamsCreate) { |
227 scoped_ptr<base::ListValue> params_value(new base::ListValue()); | 230 std::unique_ptr<base::ListValue> params_value(new base::ListValue()); |
228 scoped_ptr<base::ListValue> item_array(new base::ListValue()); | 231 std::unique_ptr<base::ListValue> item_array(new base::ListValue()); |
229 item_array->Append(CreateItemValue(1)); | 232 item_array->Append(CreateItemValue(1)); |
230 item_array->Append(CreateItemValue(2)); | 233 item_array->Append(CreateItemValue(2)); |
231 params_value->Append(item_array.release()); | 234 params_value->Append(item_array.release()); |
232 scoped_ptr<RefArray::Params> params( | 235 std::unique_ptr<RefArray::Params> params( |
233 RefArray::Params::Create(*params_value)); | 236 RefArray::Params::Create(*params_value)); |
234 EXPECT_TRUE(params.get()); | 237 EXPECT_TRUE(params.get()); |
235 ASSERT_EQ(2u, params->refs.size()); | 238 ASSERT_EQ(2u, params->refs.size()); |
236 EXPECT_EQ(1, params->refs[0].val); | 239 EXPECT_EQ(1, params->refs[0].val); |
237 EXPECT_EQ(2, params->refs[1].val); | 240 EXPECT_EQ(2, params->refs[1].val); |
238 } | 241 } |
239 | 242 |
240 TEST(JsonSchemaCompilerArrayTest, ReturnIntegerArrayResultCreate) { | 243 TEST(JsonSchemaCompilerArrayTest, ReturnIntegerArrayResultCreate) { |
241 std::vector<int> integers; | 244 std::vector<int> integers; |
242 integers.push_back(1); | 245 integers.push_back(1); |
243 integers.push_back(2); | 246 integers.push_back(2); |
244 scoped_ptr<base::ListValue> results = | 247 std::unique_ptr<base::ListValue> results = |
245 ReturnIntegerArray::Results::Create(integers); | 248 ReturnIntegerArray::Results::Create(integers); |
246 | 249 |
247 base::ListValue expected; | 250 base::ListValue expected; |
248 base::ListValue* expected_argument = new base::ListValue(); | 251 base::ListValue* expected_argument = new base::ListValue(); |
249 expected_argument->Append(new base::FundamentalValue(1)); | 252 expected_argument->Append(new base::FundamentalValue(1)); |
250 expected_argument->Append(new base::FundamentalValue(2)); | 253 expected_argument->Append(new base::FundamentalValue(2)); |
251 expected.Append(expected_argument); | 254 expected.Append(expected_argument); |
252 EXPECT_TRUE(results->Equals(&expected)); | 255 EXPECT_TRUE(results->Equals(&expected)); |
253 } | 256 } |
254 | 257 |
255 TEST(JsonSchemaCompilerArrayTest, ReturnRefArrayResultCreate) { | 258 TEST(JsonSchemaCompilerArrayTest, ReturnRefArrayResultCreate) { |
256 std::vector<Item> items; | 259 std::vector<Item> items; |
257 items.push_back(Item()); | 260 items.push_back(Item()); |
258 items.push_back(Item()); | 261 items.push_back(Item()); |
259 items[0].val = 1; | 262 items[0].val = 1; |
260 items[1].val = 2; | 263 items[1].val = 2; |
261 scoped_ptr<base::ListValue> results = | 264 std::unique_ptr<base::ListValue> results = |
262 ReturnRefArray::Results::Create(items); | 265 ReturnRefArray::Results::Create(items); |
263 | 266 |
264 base::ListValue expected; | 267 base::ListValue expected; |
265 base::ListValue* expected_argument = new base::ListValue(); | 268 base::ListValue* expected_argument = new base::ListValue(); |
266 base::DictionaryValue* first = new base::DictionaryValue(); | 269 base::DictionaryValue* first = new base::DictionaryValue(); |
267 first->SetInteger("val", 1); | 270 first->SetInteger("val", 1); |
268 expected_argument->Append(first); | 271 expected_argument->Append(first); |
269 base::DictionaryValue* second = new base::DictionaryValue(); | 272 base::DictionaryValue* second = new base::DictionaryValue(); |
270 second->SetInteger("val", 2); | 273 second->SetInteger("val", 2); |
271 expected_argument->Append(second); | 274 expected_argument->Append(second); |
272 expected.Append(expected_argument); | 275 expected.Append(expected_argument); |
273 EXPECT_TRUE(results->Equals(&expected)); | 276 EXPECT_TRUE(results->Equals(&expected)); |
274 } | 277 } |
OLD | NEW |