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 "base/values.h"
6
7 #include <stddef.h>
8
9 #include <limits>
10 #include <memory>
11 #include <string>
12 #include <type_traits>
13 #include <utility>
14 #include <vector>
15
16 #include "base/memory/ptr_util.h"
17 #include "base/strings/string16.h"
18 #include "base/strings/utf_string_conversions.h"
19 #include "testing/gtest/include/gtest/gtest.h"
20
21 namespace base {
22
TEST(ValuesTest,TestNothrow)23 TEST(ValuesTest, TestNothrow) {
24 static_assert(std::is_nothrow_move_constructible<Value>::value,
25 "IsNothrowMoveConstructible");
26 static_assert(std::is_nothrow_default_constructible<Value>::value,
27 "IsNothrowDefaultConstructible");
28 static_assert(std::is_nothrow_constructible<Value, std::string&&>::value,
29 "IsNothrowMoveConstructibleFromString");
30 static_assert(
31 std::is_nothrow_constructible<Value, std::vector<char>&&>::value,
32 "IsNothrowMoveConstructibleFromBlob");
33 static_assert(std::is_nothrow_move_assignable<Value>::value,
34 "IsNothrowMoveAssignable");
35 }
36
37 // Group of tests for the value constructors.
TEST(ValuesTest,ConstructBool)38 TEST(ValuesTest, ConstructBool) {
39 Value true_value(true);
40 EXPECT_EQ(Value::Type::BOOLEAN, true_value.type());
41 EXPECT_TRUE(true_value.GetBool());
42
43 Value false_value(false);
44 EXPECT_EQ(Value::Type::BOOLEAN, false_value.type());
45 EXPECT_FALSE(false_value.GetBool());
46 }
47
TEST(ValuesTest,ConstructInt)48 TEST(ValuesTest, ConstructInt) {
49 Value value(-37);
50 EXPECT_EQ(Value::Type::INTEGER, value.type());
51 EXPECT_EQ(-37, value.GetInt());
52 }
53
TEST(ValuesTest,ConstructDouble)54 TEST(ValuesTest, ConstructDouble) {
55 Value value(-4.655);
56 EXPECT_EQ(Value::Type::DOUBLE, value.type());
57 EXPECT_EQ(-4.655, value.GetDouble());
58 }
59
TEST(ValuesTest,ConstructStringFromConstCharPtr)60 TEST(ValuesTest, ConstructStringFromConstCharPtr) {
61 const char* str = "foobar";
62 Value value(str);
63 EXPECT_EQ(Value::Type::STRING, value.type());
64 EXPECT_EQ("foobar", value.GetString());
65 }
66
TEST(ValuesTest,ConstructStringFromStdStringConstRef)67 TEST(ValuesTest, ConstructStringFromStdStringConstRef) {
68 std::string str = "foobar";
69 Value value(str);
70 EXPECT_EQ(Value::Type::STRING, value.type());
71 EXPECT_EQ("foobar", value.GetString());
72 }
73
TEST(ValuesTest,ConstructStringFromStdStringRefRef)74 TEST(ValuesTest, ConstructStringFromStdStringRefRef) {
75 std::string str = "foobar";
76 Value value(std::move(str));
77 EXPECT_EQ(Value::Type::STRING, value.type());
78 EXPECT_EQ("foobar", value.GetString());
79 }
80
TEST(ValuesTest,ConstructStringFromConstChar16Ptr)81 TEST(ValuesTest, ConstructStringFromConstChar16Ptr) {
82 string16 str = ASCIIToUTF16("foobar");
83 Value value(str.c_str());
84 EXPECT_EQ(Value::Type::STRING, value.type());
85 EXPECT_EQ("foobar", value.GetString());
86 }
87
TEST(ValuesTest,ConstructStringFromString16)88 TEST(ValuesTest, ConstructStringFromString16) {
89 string16 str = ASCIIToUTF16("foobar");
90 Value value(str);
91 EXPECT_EQ(Value::Type::STRING, value.type());
92 EXPECT_EQ("foobar", value.GetString());
93 }
94
TEST(ValuesTest,ConstructStringFromStringPiece)95 TEST(ValuesTest, ConstructStringFromStringPiece) {
96 StringPiece str = "foobar";
97 Value value(str);
98 EXPECT_EQ(Value::Type::STRING, value.type());
99 EXPECT_EQ("foobar", value.GetString());
100 }
101
TEST(ValuesTest,ConstructBinary)102 TEST(ValuesTest, ConstructBinary) {
103 BinaryValue value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
104 EXPECT_EQ(Value::Type::BINARY, value.type());
105 EXPECT_EQ(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}), value.GetBlob());
106 }
107
TEST(ValuesTest,ConstructDict)108 TEST(ValuesTest, ConstructDict) {
109 DictionaryValue value;
110 EXPECT_EQ(Value::Type::DICTIONARY, value.type());
111 }
112
TEST(ValuesTest,ConstructList)113 TEST(ValuesTest, ConstructList) {
114 ListValue value;
115 EXPECT_EQ(Value::Type::LIST, value.type());
116 }
117
118 // Group of tests for the copy constructors and copy-assigmnent. For equality
119 // checks comparisons of the interesting fields are done instead of relying on
120 // Equals being correct.
TEST(ValuesTest,CopyBool)121 TEST(ValuesTest, CopyBool) {
122 Value true_value(true);
123 Value copied_true_value(true_value);
124 EXPECT_EQ(true_value.type(), copied_true_value.type());
125 EXPECT_EQ(true_value.GetBool(), copied_true_value.GetBool());
126
127 Value false_value(false);
128 Value copied_false_value(false_value);
129 EXPECT_EQ(false_value.type(), copied_false_value.type());
130 EXPECT_EQ(false_value.GetBool(), copied_false_value.GetBool());
131
132 Value blank;
133
134 blank = true_value;
135 EXPECT_EQ(true_value.type(), blank.type());
136 EXPECT_EQ(true_value.GetBool(), blank.GetBool());
137
138 blank = false_value;
139 EXPECT_EQ(false_value.type(), blank.type());
140 EXPECT_EQ(false_value.GetBool(), blank.GetBool());
141 }
142
TEST(ValuesTest,CopyInt)143 TEST(ValuesTest, CopyInt) {
144 Value value(74);
145 Value copied_value(value);
146 EXPECT_EQ(value.type(), copied_value.type());
147 EXPECT_EQ(value.GetInt(), copied_value.GetInt());
148
149 Value blank;
150
151 blank = value;
152 EXPECT_EQ(value.type(), blank.type());
153 EXPECT_EQ(value.GetInt(), blank.GetInt());
154 }
155
TEST(ValuesTest,CopyDouble)156 TEST(ValuesTest, CopyDouble) {
157 Value value(74.896);
158 Value copied_value(value);
159 EXPECT_EQ(value.type(), copied_value.type());
160 EXPECT_EQ(value.GetDouble(), copied_value.GetDouble());
161
162 Value blank;
163
164 blank = value;
165 EXPECT_EQ(value.type(), blank.type());
166 EXPECT_EQ(value.GetDouble(), blank.GetDouble());
167 }
168
TEST(ValuesTest,CopyString)169 TEST(ValuesTest, CopyString) {
170 Value value("foobar");
171 Value copied_value(value);
172 EXPECT_EQ(value.type(), copied_value.type());
173 EXPECT_EQ(value.GetString(), copied_value.GetString());
174
175 Value blank;
176
177 blank = value;
178 EXPECT_EQ(value.type(), blank.type());
179 EXPECT_EQ(value.GetString(), blank.GetString());
180 }
181
TEST(ValuesTest,CopyBinary)182 TEST(ValuesTest, CopyBinary) {
183 BinaryValue value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
184 BinaryValue copied_value(value);
185 EXPECT_EQ(value.type(), copied_value.type());
186 EXPECT_EQ(value.GetBlob(), copied_value.GetBlob());
187
188 Value blank;
189
190 blank = value;
191 EXPECT_EQ(value.type(), blank.type());
192 EXPECT_EQ(value.GetBlob(), blank.GetBlob());
193 }
194
TEST(ValuesTest,CopyDictionary)195 TEST(ValuesTest, CopyDictionary) {
196 // TODO(crbug.com/646113): Clean this up once DictionaryValue switched to
197 // value semantics.
198 int copy;
199 DictionaryValue value;
200 value.SetInteger("Int", 123);
201
202 DictionaryValue copied_value(value);
203 copied_value.GetInteger("Int", ©);
204
205 EXPECT_EQ(value.type(), copied_value.type());
206 EXPECT_EQ(123, copy);
207
208 auto blank = MakeUnique<Value>();
209
210 *blank = value;
211 EXPECT_EQ(Value::Type::DICTIONARY, blank->type());
212
213 static_cast<DictionaryValue*>(blank.get())->GetInteger("Int", ©);
214 EXPECT_EQ(123, copy);
215 }
216
TEST(ValuesTest,CopyList)217 TEST(ValuesTest, CopyList) {
218 // TODO(crbug.com/646113): Clean this up once ListValue switched to
219 // value semantics.
220 int copy;
221 ListValue value;
222 value.AppendInteger(123);
223
224 ListValue copied_value(value);
225 copied_value.GetInteger(0, ©);
226
227 EXPECT_EQ(value.type(), copied_value.type());
228 EXPECT_EQ(123, copy);
229
230 auto blank = MakeUnique<Value>();
231
232 *blank = value;
233 EXPECT_EQ(Value::Type::LIST, blank->type());
234
235 static_cast<ListValue*>(blank.get())->GetInteger(0, ©);
236 EXPECT_EQ(123, copy);
237 }
238
239 // Group of tests for the move constructors and move-assigmnent.
TEST(ValuesTest,MoveBool)240 TEST(ValuesTest, MoveBool) {
241 Value true_value(true);
242 Value moved_true_value(std::move(true_value));
243 EXPECT_EQ(Value::Type::BOOLEAN, moved_true_value.type());
244 EXPECT_TRUE(moved_true_value.GetBool());
245
246 Value false_value(false);
247 Value moved_false_value(std::move(false_value));
248 EXPECT_EQ(Value::Type::BOOLEAN, moved_false_value.type());
249 EXPECT_FALSE(moved_false_value.GetBool());
250
251 Value blank;
252
253 blank = Value(true);
254 EXPECT_EQ(Value::Type::BOOLEAN, blank.type());
255 EXPECT_TRUE(blank.GetBool());
256
257 blank = Value(false);
258 EXPECT_EQ(Value::Type::BOOLEAN, blank.type());
259 EXPECT_FALSE(blank.GetBool());
260 }
261
TEST(ValuesTest,MoveInt)262 TEST(ValuesTest, MoveInt) {
263 Value value(74);
264 Value moved_value(std::move(value));
265 EXPECT_EQ(Value::Type::INTEGER, moved_value.type());
266 EXPECT_EQ(74, moved_value.GetInt());
267
268 Value blank;
269
270 blank = Value(47);
271 EXPECT_EQ(Value::Type::INTEGER, blank.type());
272 EXPECT_EQ(47, blank.GetInt());
273 }
274
TEST(ValuesTest,MoveDouble)275 TEST(ValuesTest, MoveDouble) {
276 Value value(74.896);
277 Value moved_value(std::move(value));
278 EXPECT_EQ(Value::Type::DOUBLE, moved_value.type());
279 EXPECT_EQ(74.896, moved_value.GetDouble());
280
281 Value blank;
282
283 blank = Value(654.38);
284 EXPECT_EQ(Value::Type::DOUBLE, blank.type());
285 EXPECT_EQ(654.38, blank.GetDouble());
286 }
287
TEST(ValuesTest,MoveString)288 TEST(ValuesTest, MoveString) {
289 Value value("foobar");
290 Value moved_value(std::move(value));
291 EXPECT_EQ(Value::Type::STRING, moved_value.type());
292 EXPECT_EQ("foobar", moved_value.GetString());
293
294 Value blank;
295
296 blank = Value("foobar");
297 EXPECT_EQ(Value::Type::STRING, blank.type());
298 EXPECT_EQ("foobar", blank.GetString());
299 }
300
TEST(ValuesTest,MoveBinary)301 TEST(ValuesTest, MoveBinary) {
302 const std::vector<char> buffer = {0xF, 0x0, 0x0, 0xB, 0xA, 0x2};
303 BinaryValue value(buffer);
304 BinaryValue moved_value(std::move(value));
305 EXPECT_EQ(Value::Type::BINARY, moved_value.type());
306 EXPECT_EQ(buffer, moved_value.GetBlob());
307
308 Value blank;
309
310 blank = BinaryValue(buffer);
311 EXPECT_EQ(Value::Type::BINARY, blank.type());
312 EXPECT_EQ(buffer, blank.GetBlob());
313 }
314
TEST(ValuesTest,MoveDictionary)315 TEST(ValuesTest, MoveDictionary) {
316 // TODO(crbug.com/646113): Clean this up once DictionaryValue switched to
317 // value semantics.
318 int move;
319 DictionaryValue value;
320 value.SetInteger("Int", 123);
321
322 DictionaryValue moved_value(std::move(value));
323 moved_value.GetInteger("Int", &move);
324
325 EXPECT_EQ(Value::Type::DICTIONARY, moved_value.type());
326 EXPECT_EQ(123, move);
327
328 Value blank;
329
330 blank = DictionaryValue();
331 EXPECT_EQ(Value::Type::DICTIONARY, blank.type());
332 }
333
TEST(ValuesTest,MoveList)334 TEST(ValuesTest, MoveList) {
335 // TODO(crbug.com/646113): Clean this up once ListValue switched to
336 // value semantics.
337 int move;
338 ListValue value;
339 value.AppendInteger(123);
340
341 ListValue moved_value(std::move(value));
342 moved_value.GetInteger(0, &move);
343
344 EXPECT_EQ(Value::Type::LIST, moved_value.type());
345 EXPECT_EQ(123, move);
346
347 Value blank;
348
349 blank = ListValue();
350 EXPECT_EQ(Value::Type::LIST, blank.type());
351 }
352
TEST(ValuesTest,Basic)353 TEST(ValuesTest, Basic) {
354 // Test basic dictionary getting/setting
355 DictionaryValue settings;
356 std::string homepage = "http://google.com";
357 ASSERT_FALSE(settings.GetString("global.homepage", &homepage));
358 ASSERT_EQ(std::string("http://google.com"), homepage);
359
360 ASSERT_FALSE(settings.Get("global", NULL));
361 settings.SetBoolean("global", true);
362 ASSERT_TRUE(settings.Get("global", NULL));
363 settings.SetString("global.homepage", "http://scurvy.com");
364 ASSERT_TRUE(settings.Get("global", NULL));
365 homepage = "http://google.com";
366 ASSERT_TRUE(settings.GetString("global.homepage", &homepage));
367 ASSERT_EQ(std::string("http://scurvy.com"), homepage);
368
369 // Test storing a dictionary in a list.
370 ListValue* toolbar_bookmarks;
371 ASSERT_FALSE(
372 settings.GetList("global.toolbar.bookmarks", &toolbar_bookmarks));
373
374 std::unique_ptr<ListValue> new_toolbar_bookmarks(new ListValue);
375 settings.Set("global.toolbar.bookmarks", std::move(new_toolbar_bookmarks));
376 ASSERT_TRUE(settings.GetList("global.toolbar.bookmarks", &toolbar_bookmarks));
377
378 std::unique_ptr<DictionaryValue> new_bookmark(new DictionaryValue);
379 new_bookmark->SetString("name", "Froogle");
380 new_bookmark->SetString("url", "http://froogle.com");
381 toolbar_bookmarks->Append(std::move(new_bookmark));
382
383 ListValue* bookmark_list;
384 ASSERT_TRUE(settings.GetList("global.toolbar.bookmarks", &bookmark_list));
385 DictionaryValue* bookmark;
386 ASSERT_EQ(1U, bookmark_list->GetSize());
387 ASSERT_TRUE(bookmark_list->GetDictionary(0, &bookmark));
388 std::string bookmark_name = "Unnamed";
389 ASSERT_TRUE(bookmark->GetString("name", &bookmark_name));
390 ASSERT_EQ(std::string("Froogle"), bookmark_name);
391 std::string bookmark_url;
392 ASSERT_TRUE(bookmark->GetString("url", &bookmark_url));
393 ASSERT_EQ(std::string("http://froogle.com"), bookmark_url);
394 }
395
TEST(ValuesTest,List)396 TEST(ValuesTest, List) {
397 std::unique_ptr<ListValue> mixed_list(new ListValue());
398 mixed_list->Set(0, MakeUnique<Value>(true));
399 mixed_list->Set(1, MakeUnique<Value>(42));
400 mixed_list->Set(2, MakeUnique<Value>(88.8));
401 mixed_list->Set(3, MakeUnique<Value>("foo"));
402 ASSERT_EQ(4u, mixed_list->GetSize());
403
404 Value *value = NULL;
405 bool bool_value = false;
406 int int_value = 0;
407 double double_value = 0.0;
408 std::string string_value;
409
410 ASSERT_FALSE(mixed_list->Get(4, &value));
411
412 ASSERT_FALSE(mixed_list->GetInteger(0, &int_value));
413 ASSERT_EQ(0, int_value);
414 ASSERT_FALSE(mixed_list->GetBoolean(1, &bool_value));
415 ASSERT_FALSE(bool_value);
416 ASSERT_FALSE(mixed_list->GetString(2, &string_value));
417 ASSERT_EQ("", string_value);
418 ASSERT_FALSE(mixed_list->GetInteger(2, &int_value));
419 ASSERT_EQ(0, int_value);
420 ASSERT_FALSE(mixed_list->GetBoolean(3, &bool_value));
421 ASSERT_FALSE(bool_value);
422
423 ASSERT_TRUE(mixed_list->GetBoolean(0, &bool_value));
424 ASSERT_TRUE(bool_value);
425 ASSERT_TRUE(mixed_list->GetInteger(1, &int_value));
426 ASSERT_EQ(42, int_value);
427 // implicit conversion from Integer to Double should be possible.
428 ASSERT_TRUE(mixed_list->GetDouble(1, &double_value));
429 ASSERT_EQ(42, double_value);
430 ASSERT_TRUE(mixed_list->GetDouble(2, &double_value));
431 ASSERT_EQ(88.8, double_value);
432 ASSERT_TRUE(mixed_list->GetString(3, &string_value));
433 ASSERT_EQ("foo", string_value);
434
435 // Try searching in the mixed list.
436 base::Value sought_value(42);
437 base::Value not_found_value(false);
438
439 ASSERT_NE(mixed_list->end(), mixed_list->Find(sought_value));
440 ASSERT_TRUE((*mixed_list->Find(sought_value))->GetAsInteger(&int_value));
441 ASSERT_EQ(42, int_value);
442 ASSERT_EQ(mixed_list->end(), mixed_list->Find(not_found_value));
443 }
444
TEST(ValuesTest,BinaryValue)445 TEST(ValuesTest, BinaryValue) {
446 // Default constructor creates a BinaryValue with a buffer of size 0.
447 auto binary = MakeUnique<Value>(Value::Type::BINARY);
448 ASSERT_TRUE(binary.get());
449 ASSERT_EQ(0U, binary->GetSize());
450
451 // Test the common case of a non-empty buffer
452 std::vector<char> buffer(15);
453 char* original_buffer = buffer.data();
454 binary.reset(new BinaryValue(std::move(buffer)));
455 ASSERT_TRUE(binary.get());
456 ASSERT_TRUE(binary->GetBuffer());
457 ASSERT_EQ(original_buffer, binary->GetBuffer());
458 ASSERT_EQ(15U, binary->GetSize());
459
460 char stack_buffer[42];
461 memset(stack_buffer, '!', 42);
462 binary = BinaryValue::CreateWithCopiedBuffer(stack_buffer, 42);
463 ASSERT_TRUE(binary.get());
464 ASSERT_TRUE(binary->GetBuffer());
465 ASSERT_NE(stack_buffer, binary->GetBuffer());
466 ASSERT_EQ(42U, binary->GetSize());
467 ASSERT_EQ(0, memcmp(stack_buffer, binary->GetBuffer(), binary->GetSize()));
468
469 // Test overloaded GetAsBinary.
470 Value* narrow_value = binary.get();
471 const BinaryValue* narrow_binary = NULL;
472 ASSERT_TRUE(narrow_value->GetAsBinary(&narrow_binary));
473 EXPECT_EQ(binary.get(), narrow_binary);
474 }
475
TEST(ValuesTest,StringValue)476 TEST(ValuesTest, StringValue) {
477 // Test overloaded StringValue constructor.
478 std::unique_ptr<Value> narrow_value(new Value("narrow"));
479 ASSERT_TRUE(narrow_value.get());
480 ASSERT_TRUE(narrow_value->IsType(Value::Type::STRING));
481 std::unique_ptr<Value> utf16_value(new Value(ASCIIToUTF16("utf16")));
482 ASSERT_TRUE(utf16_value.get());
483 ASSERT_TRUE(utf16_value->IsType(Value::Type::STRING));
484
485 // Test overloaded GetAsString.
486 std::string narrow = "http://google.com";
487 string16 utf16 = ASCIIToUTF16("http://google.com");
488 const Value* string_value = NULL;
489 ASSERT_TRUE(narrow_value->GetAsString(&narrow));
490 ASSERT_TRUE(narrow_value->GetAsString(&utf16));
491 ASSERT_TRUE(narrow_value->GetAsString(&string_value));
492 ASSERT_EQ(std::string("narrow"), narrow);
493 ASSERT_EQ(ASCIIToUTF16("narrow"), utf16);
494 ASSERT_EQ(string_value->GetString(), narrow);
495
496 ASSERT_TRUE(utf16_value->GetAsString(&narrow));
497 ASSERT_TRUE(utf16_value->GetAsString(&utf16));
498 ASSERT_TRUE(utf16_value->GetAsString(&string_value));
499 ASSERT_EQ(std::string("utf16"), narrow);
500 ASSERT_EQ(ASCIIToUTF16("utf16"), utf16);
501 ASSERT_EQ(string_value->GetString(), narrow);
502
503 // Don't choke on NULL values.
504 ASSERT_TRUE(narrow_value->GetAsString(static_cast<string16*>(NULL)));
505 ASSERT_TRUE(narrow_value->GetAsString(static_cast<std::string*>(NULL)));
506 ASSERT_TRUE(narrow_value->GetAsString(static_cast<const Value**>(NULL)));
507 }
508
TEST(ValuesTest,ListDeletion)509 TEST(ValuesTest, ListDeletion) {
510 ListValue list;
511 list.Append(MakeUnique<Value>());
512 EXPECT_FALSE(list.empty());
513 list.Clear();
514 EXPECT_TRUE(list.empty());
515 }
516
TEST(ValuesTest,ListRemoval)517 TEST(ValuesTest, ListRemoval) {
518 std::unique_ptr<Value> removed_item;
519
520 {
521 ListValue list;
522 list.Append(MakeUnique<Value>());
523 EXPECT_EQ(1U, list.GetSize());
524 EXPECT_FALSE(list.Remove(std::numeric_limits<size_t>::max(),
525 &removed_item));
526 EXPECT_FALSE(list.Remove(1, &removed_item));
527 EXPECT_TRUE(list.Remove(0, &removed_item));
528 ASSERT_TRUE(removed_item);
529 EXPECT_EQ(0U, list.GetSize());
530 }
531 removed_item.reset();
532
533 {
534 ListValue list;
535 list.Append(MakeUnique<Value>());
536 EXPECT_TRUE(list.Remove(0, NULL));
537 EXPECT_EQ(0U, list.GetSize());
538 }
539
540 {
541 ListValue list;
542 auto value = MakeUnique<Value>();
543 Value* original_value = value.get();
544 list.Append(std::move(value));
545 size_t index = 0;
546 list.Remove(*original_value, &index);
547 EXPECT_EQ(0U, index);
548 EXPECT_EQ(0U, list.GetSize());
549 }
550 }
551
TEST(ValuesTest,DictionaryDeletion)552 TEST(ValuesTest, DictionaryDeletion) {
553 std::string key = "test";
554 DictionaryValue dict;
555 dict.Set(key, MakeUnique<Value>());
556 EXPECT_FALSE(dict.empty());
557 dict.Clear();
558 EXPECT_TRUE(dict.empty());
559 }
560
TEST(ValuesTest,DictionaryRemoval)561 TEST(ValuesTest, DictionaryRemoval) {
562 std::string key = "test";
563 std::unique_ptr<Value> removed_item;
564
565 {
566 DictionaryValue dict;
567 dict.Set(key, MakeUnique<Value>());
568 EXPECT_TRUE(dict.HasKey(key));
569 EXPECT_FALSE(dict.Remove("absent key", &removed_item));
570 EXPECT_TRUE(dict.Remove(key, &removed_item));
571 EXPECT_FALSE(dict.HasKey(key));
572 ASSERT_TRUE(removed_item);
573 }
574
575 {
576 DictionaryValue dict;
577 dict.Set(key, MakeUnique<Value>());
578 EXPECT_TRUE(dict.HasKey(key));
579 EXPECT_TRUE(dict.Remove(key, NULL));
580 EXPECT_FALSE(dict.HasKey(key));
581 }
582 }
583
TEST(ValuesTest,DictionaryWithoutPathExpansion)584 TEST(ValuesTest, DictionaryWithoutPathExpansion) {
585 DictionaryValue dict;
586 dict.Set("this.is.expanded", Value::CreateNullValue());
587 dict.SetWithoutPathExpansion("this.isnt.expanded", Value::CreateNullValue());
588
589 EXPECT_FALSE(dict.HasKey("this.is.expanded"));
590 EXPECT_TRUE(dict.HasKey("this"));
591 Value* value1;
592 EXPECT_TRUE(dict.Get("this", &value1));
593 DictionaryValue* value2;
594 ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2));
595 EXPECT_EQ(value1, value2);
596 EXPECT_EQ(1U, value2->size());
597
598 EXPECT_TRUE(dict.HasKey("this.isnt.expanded"));
599 Value* value3;
600 EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3));
601 Value* value4;
602 ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4));
603 EXPECT_EQ(Value::Type::NONE, value4->GetType());
604 }
605
606 // Tests the deprecated version of SetWithoutPathExpansion.
607 // TODO(estade): remove.
TEST(ValuesTest,DictionaryWithoutPathExpansionDeprecated)608 TEST(ValuesTest, DictionaryWithoutPathExpansionDeprecated) {
609 DictionaryValue dict;
610 dict.Set("this.is.expanded", Value::CreateNullValue());
611 dict.SetWithoutPathExpansion("this.isnt.expanded", Value::CreateNullValue());
612
613 EXPECT_FALSE(dict.HasKey("this.is.expanded"));
614 EXPECT_TRUE(dict.HasKey("this"));
615 Value* value1;
616 EXPECT_TRUE(dict.Get("this", &value1));
617 DictionaryValue* value2;
618 ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2));
619 EXPECT_EQ(value1, value2);
620 EXPECT_EQ(1U, value2->size());
621
622 EXPECT_TRUE(dict.HasKey("this.isnt.expanded"));
623 Value* value3;
624 EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3));
625 Value* value4;
626 ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4));
627 EXPECT_EQ(Value::Type::NONE, value4->GetType());
628 }
629
TEST(ValuesTest,DictionaryRemovePath)630 TEST(ValuesTest, DictionaryRemovePath) {
631 DictionaryValue dict;
632 dict.SetInteger("a.long.way.down", 1);
633 dict.SetBoolean("a.long.key.path", true);
634
635 std::unique_ptr<Value> removed_item;
636 EXPECT_TRUE(dict.RemovePath("a.long.way.down", &removed_item));
637 ASSERT_TRUE(removed_item);
638 EXPECT_TRUE(removed_item->IsType(base::Value::Type::INTEGER));
639 EXPECT_FALSE(dict.HasKey("a.long.way.down"));
640 EXPECT_FALSE(dict.HasKey("a.long.way"));
641 EXPECT_TRUE(dict.Get("a.long.key.path", NULL));
642
643 removed_item.reset();
644 EXPECT_FALSE(dict.RemovePath("a.long.way.down", &removed_item));
645 EXPECT_FALSE(removed_item);
646 EXPECT_TRUE(dict.Get("a.long.key.path", NULL));
647
648 removed_item.reset();
649 EXPECT_TRUE(dict.RemovePath("a.long.key.path", &removed_item));
650 ASSERT_TRUE(removed_item);
651 EXPECT_TRUE(removed_item->IsType(base::Value::Type::BOOLEAN));
652 EXPECT_TRUE(dict.empty());
653 }
654
TEST(ValuesTest,DeepCopy)655 TEST(ValuesTest, DeepCopy) {
656 DictionaryValue original_dict;
657 std::unique_ptr<Value> scoped_null = Value::CreateNullValue();
658 Value* original_null = scoped_null.get();
659 original_dict.Set("null", std::move(scoped_null));
660 std::unique_ptr<Value> scoped_bool(new Value(true));
661 Value* original_bool = scoped_bool.get();
662 original_dict.Set("bool", std::move(scoped_bool));
663 std::unique_ptr<Value> scoped_int(new Value(42));
664 Value* original_int = scoped_int.get();
665 original_dict.Set("int", std::move(scoped_int));
666 std::unique_ptr<Value> scoped_double(new Value(3.14));
667 Value* original_double = scoped_double.get();
668 original_dict.Set("double", std::move(scoped_double));
669 std::unique_ptr<Value> scoped_string(new Value("hello"));
670 Value* original_string = scoped_string.get();
671 original_dict.Set("string", std::move(scoped_string));
672 std::unique_ptr<Value> scoped_string16(new Value(ASCIIToUTF16("hello16")));
673 Value* original_string16 = scoped_string16.get();
674 original_dict.Set("string16", std::move(scoped_string16));
675
676 std::vector<char> original_buffer(42, '!');
677 std::unique_ptr<BinaryValue> scoped_binary(
678 new BinaryValue(std::move(original_buffer)));
679 BinaryValue* original_binary = scoped_binary.get();
680 original_dict.Set("binary", std::move(scoped_binary));
681
682 std::unique_ptr<ListValue> scoped_list(new ListValue());
683 Value* original_list = scoped_list.get();
684 std::unique_ptr<Value> scoped_list_element_0(new Value(0));
685 Value* original_list_element_0 = scoped_list_element_0.get();
686 scoped_list->Append(std::move(scoped_list_element_0));
687 std::unique_ptr<Value> scoped_list_element_1(new Value(1));
688 Value* original_list_element_1 = scoped_list_element_1.get();
689 scoped_list->Append(std::move(scoped_list_element_1));
690 original_dict.Set("list", std::move(scoped_list));
691
692 std::unique_ptr<DictionaryValue> scoped_nested_dictionary(
693 new DictionaryValue());
694 Value* original_nested_dictionary = scoped_nested_dictionary.get();
695 scoped_nested_dictionary->SetString("key", "value");
696 original_dict.Set("dictionary", std::move(scoped_nested_dictionary));
697
698 auto copy_dict = MakeUnique<DictionaryValue>(original_dict);
699 ASSERT_TRUE(copy_dict.get());
700 ASSERT_NE(copy_dict.get(), &original_dict);
701
702 Value* copy_null = NULL;
703 ASSERT_TRUE(copy_dict->Get("null", ©_null));
704 ASSERT_TRUE(copy_null);
705 ASSERT_NE(copy_null, original_null);
706 ASSERT_TRUE(copy_null->IsType(Value::Type::NONE));
707
708 Value* copy_bool = NULL;
709 ASSERT_TRUE(copy_dict->Get("bool", ©_bool));
710 ASSERT_TRUE(copy_bool);
711 ASSERT_NE(copy_bool, original_bool);
712 ASSERT_TRUE(copy_bool->IsType(Value::Type::BOOLEAN));
713 bool copy_bool_value = false;
714 ASSERT_TRUE(copy_bool->GetAsBoolean(©_bool_value));
715 ASSERT_TRUE(copy_bool_value);
716
717 Value* copy_int = NULL;
718 ASSERT_TRUE(copy_dict->Get("int", ©_int));
719 ASSERT_TRUE(copy_int);
720 ASSERT_NE(copy_int, original_int);
721 ASSERT_TRUE(copy_int->IsType(Value::Type::INTEGER));
722 int copy_int_value = 0;
723 ASSERT_TRUE(copy_int->GetAsInteger(©_int_value));
724 ASSERT_EQ(42, copy_int_value);
725
726 Value* copy_double = NULL;
727 ASSERT_TRUE(copy_dict->Get("double", ©_double));
728 ASSERT_TRUE(copy_double);
729 ASSERT_NE(copy_double, original_double);
730 ASSERT_TRUE(copy_double->IsType(Value::Type::DOUBLE));
731 double copy_double_value = 0;
732 ASSERT_TRUE(copy_double->GetAsDouble(©_double_value));
733 ASSERT_EQ(3.14, copy_double_value);
734
735 Value* copy_string = NULL;
736 ASSERT_TRUE(copy_dict->Get("string", ©_string));
737 ASSERT_TRUE(copy_string);
738 ASSERT_NE(copy_string, original_string);
739 ASSERT_TRUE(copy_string->IsType(Value::Type::STRING));
740 std::string copy_string_value;
741 string16 copy_string16_value;
742 ASSERT_TRUE(copy_string->GetAsString(©_string_value));
743 ASSERT_TRUE(copy_string->GetAsString(©_string16_value));
744 ASSERT_EQ(std::string("hello"), copy_string_value);
745 ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value);
746
747 Value* copy_string16 = NULL;
748 ASSERT_TRUE(copy_dict->Get("string16", ©_string16));
749 ASSERT_TRUE(copy_string16);
750 ASSERT_NE(copy_string16, original_string16);
751 ASSERT_TRUE(copy_string16->IsType(Value::Type::STRING));
752 ASSERT_TRUE(copy_string16->GetAsString(©_string_value));
753 ASSERT_TRUE(copy_string16->GetAsString(©_string16_value));
754 ASSERT_EQ(std::string("hello16"), copy_string_value);
755 ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value);
756
757 Value* copy_binary = NULL;
758 ASSERT_TRUE(copy_dict->Get("binary", ©_binary));
759 ASSERT_TRUE(copy_binary);
760 ASSERT_NE(copy_binary, original_binary);
761 ASSERT_TRUE(copy_binary->IsType(Value::Type::BINARY));
762 ASSERT_NE(original_binary->GetBuffer(), copy_binary->GetBuffer());
763 ASSERT_EQ(original_binary->GetSize(), copy_binary->GetSize());
764 ASSERT_EQ(0, memcmp(original_binary->GetBuffer(), copy_binary->GetBuffer(),
765 original_binary->GetSize()));
766
767 Value* copy_value = NULL;
768 ASSERT_TRUE(copy_dict->Get("list", ©_value));
769 ASSERT_TRUE(copy_value);
770 ASSERT_NE(copy_value, original_list);
771 ASSERT_TRUE(copy_value->IsType(Value::Type::LIST));
772 ListValue* copy_list = NULL;
773 ASSERT_TRUE(copy_value->GetAsList(©_list));
774 ASSERT_TRUE(copy_list);
775 ASSERT_EQ(2U, copy_list->GetSize());
776
777 Value* copy_list_element_0;
778 ASSERT_TRUE(copy_list->Get(0, ©_list_element_0));
779 ASSERT_TRUE(copy_list_element_0);
780 ASSERT_NE(copy_list_element_0, original_list_element_0);
781 int copy_list_element_0_value;
782 ASSERT_TRUE(copy_list_element_0->GetAsInteger(©_list_element_0_value));
783 ASSERT_EQ(0, copy_list_element_0_value);
784
785 Value* copy_list_element_1;
786 ASSERT_TRUE(copy_list->Get(1, ©_list_element_1));
787 ASSERT_TRUE(copy_list_element_1);
788 ASSERT_NE(copy_list_element_1, original_list_element_1);
789 int copy_list_element_1_value;
790 ASSERT_TRUE(copy_list_element_1->GetAsInteger(©_list_element_1_value));
791 ASSERT_EQ(1, copy_list_element_1_value);
792
793 copy_value = NULL;
794 ASSERT_TRUE(copy_dict->Get("dictionary", ©_value));
795 ASSERT_TRUE(copy_value);
796 ASSERT_NE(copy_value, original_nested_dictionary);
797 ASSERT_TRUE(copy_value->IsType(Value::Type::DICTIONARY));
798 DictionaryValue* copy_nested_dictionary = NULL;
799 ASSERT_TRUE(copy_value->GetAsDictionary(©_nested_dictionary));
800 ASSERT_TRUE(copy_nested_dictionary);
801 EXPECT_TRUE(copy_nested_dictionary->HasKey("key"));
802 }
803
TEST(ValuesTest,Equals)804 TEST(ValuesTest, Equals) {
805 std::unique_ptr<Value> null1(Value::CreateNullValue());
806 std::unique_ptr<Value> null2(Value::CreateNullValue());
807 EXPECT_NE(null1.get(), null2.get());
808 EXPECT_EQ(*null1, *null2);
809
810 Value boolean(false);
811 EXPECT_NE(*null1, boolean);
812
813 DictionaryValue dv;
814 dv.SetBoolean("a", false);
815 dv.SetInteger("b", 2);
816 dv.SetDouble("c", 2.5);
817 dv.SetString("d1", "string");
818 dv.SetString("d2", ASCIIToUTF16("http://google.com"));
819 dv.Set("e", Value::CreateNullValue());
820
821 auto copy = MakeUnique<DictionaryValue>(dv);
822 EXPECT_EQ(dv, *copy);
823
824 std::unique_ptr<ListValue> list(new ListValue);
825 ListValue* original_list = list.get();
826 list->Append(Value::CreateNullValue());
827 list->Append(WrapUnique(new DictionaryValue));
828 auto list_copy = MakeUnique<Value>(*list);
829
830 dv.Set("f", std::move(list));
831 EXPECT_NE(dv, *copy);
832 copy->Set("f", std::move(list_copy));
833 EXPECT_EQ(dv, *copy);
834
835 original_list->Append(MakeUnique<Value>(true));
836 EXPECT_NE(dv, *copy);
837
838 // Check if Equals detects differences in only the keys.
839 copy = MakeUnique<DictionaryValue>(dv);
840 EXPECT_EQ(dv, *copy);
841 copy->Remove("a", NULL);
842 copy->SetBoolean("aa", false);
843 EXPECT_NE(dv, *copy);
844 }
845
TEST(ValuesTest,StaticEquals)846 TEST(ValuesTest, StaticEquals) {
847 std::unique_ptr<Value> null1(Value::CreateNullValue());
848 std::unique_ptr<Value> null2(Value::CreateNullValue());
849 EXPECT_TRUE(Value::Equals(null1.get(), null2.get()));
850 EXPECT_TRUE(Value::Equals(NULL, NULL));
851
852 std::unique_ptr<Value> i42(new Value(42));
853 std::unique_ptr<Value> j42(new Value(42));
854 std::unique_ptr<Value> i17(new Value(17));
855 EXPECT_TRUE(Value::Equals(i42.get(), i42.get()));
856 EXPECT_TRUE(Value::Equals(j42.get(), i42.get()));
857 EXPECT_TRUE(Value::Equals(i42.get(), j42.get()));
858 EXPECT_FALSE(Value::Equals(i42.get(), i17.get()));
859 EXPECT_FALSE(Value::Equals(i42.get(), NULL));
860 EXPECT_FALSE(Value::Equals(NULL, i42.get()));
861
862 // NULL and Value::CreateNullValue() are intentionally different: We need
863 // support for NULL as a return value for "undefined" without caring for
864 // ownership of the pointer.
865 EXPECT_FALSE(Value::Equals(null1.get(), NULL));
866 EXPECT_FALSE(Value::Equals(NULL, null1.get()));
867 }
868
TEST(ValuesTest,Comparisons)869 TEST(ValuesTest, Comparisons) {
870 // Test None Values.
871 Value null1;
872 Value null2;
873 EXPECT_EQ(null1, null2);
874 EXPECT_FALSE(null1 != null2);
875 EXPECT_FALSE(null1 < null2);
876 EXPECT_FALSE(null1 > null2);
877 EXPECT_LE(null1, null2);
878 EXPECT_GE(null1, null2);
879
880 // Test Bool Values.
881 Value bool1(false);
882 Value bool2(true);
883 EXPECT_FALSE(bool1 == bool2);
884 EXPECT_NE(bool1, bool2);
885 EXPECT_LT(bool1, bool2);
886 EXPECT_FALSE(bool1 > bool2);
887 EXPECT_LE(bool1, bool2);
888 EXPECT_FALSE(bool1 >= bool2);
889
890 // Test Int Values.
891 Value int1(1);
892 Value int2(2);
893 EXPECT_FALSE(int1 == int2);
894 EXPECT_NE(int1, int2);
895 EXPECT_LT(int1, int2);
896 EXPECT_FALSE(int1 > int2);
897 EXPECT_LE(int1, int2);
898 EXPECT_FALSE(int1 >= int2);
899
900 // Test Double Values.
901 Value double1(1.0);
902 Value double2(2.0);
903 EXPECT_FALSE(double1 == double2);
904 EXPECT_NE(double1, double2);
905 EXPECT_LT(double1, double2);
906 EXPECT_FALSE(double1 > double2);
907 EXPECT_LE(double1, double2);
908 EXPECT_FALSE(double1 >= double2);
909
910 // Test String Values.
911 Value string1("1");
912 Value string2("2");
913 EXPECT_FALSE(string1 == string2);
914 EXPECT_NE(string1, string2);
915 EXPECT_LT(string1, string2);
916 EXPECT_FALSE(string1 > string2);
917 EXPECT_LE(string1, string2);
918 EXPECT_FALSE(string1 >= string2);
919
920 // Test Binary Values.
921 Value binary1(std::vector<char>{0x01});
922 Value binary2(std::vector<char>{0x02});
923 EXPECT_FALSE(binary1 == binary2);
924 EXPECT_NE(binary1, binary2);
925 EXPECT_LT(binary1, binary2);
926 EXPECT_FALSE(binary1 > binary2);
927 EXPECT_LE(binary1, binary2);
928 EXPECT_FALSE(binary1 >= binary2);
929
930 // Test Empty List Values.
931 ListValue null_list1;
932 ListValue null_list2;
933 EXPECT_EQ(null_list1, null_list2);
934 EXPECT_FALSE(null_list1 != null_list2);
935 EXPECT_FALSE(null_list1 < null_list2);
936 EXPECT_FALSE(null_list1 > null_list2);
937 EXPECT_LE(null_list1, null_list2);
938 EXPECT_GE(null_list1, null_list2);
939
940 // Test Non Empty List Values.
941 ListValue int_list1;
942 ListValue int_list2;
943 int_list1.AppendInteger(1);
944 int_list2.AppendInteger(2);
945 EXPECT_FALSE(int_list1 == int_list2);
946 EXPECT_NE(int_list1, int_list2);
947 EXPECT_LT(int_list1, int_list2);
948 EXPECT_FALSE(int_list1 > int_list2);
949 EXPECT_LE(int_list1, int_list2);
950 EXPECT_FALSE(int_list1 >= int_list2);
951
952 // Test Empty Dict Values.
953 DictionaryValue null_dict1;
954 DictionaryValue null_dict2;
955 EXPECT_EQ(null_dict1, null_dict2);
956 EXPECT_FALSE(null_dict1 != null_dict2);
957 EXPECT_FALSE(null_dict1 < null_dict2);
958 EXPECT_FALSE(null_dict1 > null_dict2);
959 EXPECT_LE(null_dict1, null_dict2);
960 EXPECT_GE(null_dict1, null_dict2);
961
962 // Test Non Empty Dict Values.
963 DictionaryValue int_dict1;
964 DictionaryValue int_dict2;
965 int_dict1.SetInteger("key", 1);
966 int_dict2.SetInteger("key", 2);
967 EXPECT_FALSE(int_dict1 == int_dict2);
968 EXPECT_NE(int_dict1, int_dict2);
969 EXPECT_LT(int_dict1, int_dict2);
970 EXPECT_FALSE(int_dict1 > int_dict2);
971 EXPECT_LE(int_dict1, int_dict2);
972 EXPECT_FALSE(int_dict1 >= int_dict2);
973
974 // Test Values of different types.
975 std::vector<Value> values = {null1, bool1, int1, double1,
976 string1, binary1, int_dict1, int_list1};
977 for (size_t i = 0; i < values.size(); ++i) {
978 for (size_t j = i + 1; j < values.size(); ++j) {
979 EXPECT_FALSE(values[i] == values[j]);
980 EXPECT_NE(values[i], values[j]);
981 EXPECT_LT(values[i], values[j]);
982 EXPECT_FALSE(values[i] > values[j]);
983 EXPECT_LE(values[i], values[j]);
984 EXPECT_FALSE(values[i] >= values[j]);
985 }
986 }
987 }
988
TEST(ValuesTest,DeepCopyCovariantReturnTypes)989 TEST(ValuesTest, DeepCopyCovariantReturnTypes) {
990 DictionaryValue original_dict;
991 std::unique_ptr<Value> scoped_null(Value::CreateNullValue());
992 Value* original_null = scoped_null.get();
993 original_dict.Set("null", std::move(scoped_null));
994 std::unique_ptr<Value> scoped_bool(new Value(true));
995 Value* original_bool = scoped_bool.get();
996 original_dict.Set("bool", std::move(scoped_bool));
997 std::unique_ptr<Value> scoped_int(new Value(42));
998 Value* original_int = scoped_int.get();
999 original_dict.Set("int", std::move(scoped_int));
1000 std::unique_ptr<Value> scoped_double(new Value(3.14));
1001 Value* original_double = scoped_double.get();
1002 original_dict.Set("double", std::move(scoped_double));
1003 std::unique_ptr<Value> scoped_string(new Value("hello"));
1004 Value* original_string = scoped_string.get();
1005 original_dict.Set("string", std::move(scoped_string));
1006 std::unique_ptr<Value> scoped_string16(new Value(ASCIIToUTF16("hello16")));
1007 Value* original_string16 = scoped_string16.get();
1008 original_dict.Set("string16", std::move(scoped_string16));
1009
1010 std::vector<char> original_buffer(42, '!');
1011 std::unique_ptr<BinaryValue> scoped_binary(
1012 new BinaryValue(std::move(original_buffer)));
1013 Value* original_binary = scoped_binary.get();
1014 original_dict.Set("binary", std::move(scoped_binary));
1015
1016 std::unique_ptr<ListValue> scoped_list(new ListValue());
1017 Value* original_list = scoped_list.get();
1018 std::unique_ptr<Value> scoped_list_element_0(new Value(0));
1019 scoped_list->Append(std::move(scoped_list_element_0));
1020 std::unique_ptr<Value> scoped_list_element_1(new Value(1));
1021 scoped_list->Append(std::move(scoped_list_element_1));
1022 original_dict.Set("list", std::move(scoped_list));
1023
1024 auto copy_dict = MakeUnique<Value>(original_dict);
1025 auto copy_null = MakeUnique<Value>(*original_null);
1026 auto copy_bool = MakeUnique<Value>(*original_bool);
1027 auto copy_int = MakeUnique<Value>(*original_int);
1028 auto copy_double = MakeUnique<Value>(*original_double);
1029 auto copy_string = MakeUnique<Value>(*original_string);
1030 auto copy_string16 = MakeUnique<Value>(*original_string16);
1031 auto copy_binary = MakeUnique<Value>(*original_binary);
1032 auto copy_list = MakeUnique<Value>(*original_list);
1033
1034 EXPECT_EQ(original_dict, *copy_dict);
1035 EXPECT_EQ(*original_null, *copy_null);
1036 EXPECT_EQ(*original_bool, *copy_bool);
1037 EXPECT_EQ(*original_int, *copy_int);
1038 EXPECT_EQ(*original_double, *copy_double);
1039 EXPECT_EQ(*original_string, *copy_string);
1040 EXPECT_EQ(*original_string16, *copy_string16);
1041 EXPECT_EQ(*original_binary, *copy_binary);
1042 EXPECT_EQ(*original_list, *copy_list);
1043 }
1044
TEST(ValuesTest,RemoveEmptyChildren)1045 TEST(ValuesTest, RemoveEmptyChildren) {
1046 std::unique_ptr<DictionaryValue> root(new DictionaryValue);
1047 // Remove empty lists and dictionaries.
1048 root->Set("empty_dict", WrapUnique(new DictionaryValue));
1049 root->Set("empty_list", WrapUnique(new ListValue));
1050 root->SetWithoutPathExpansion("a.b.c.d.e",
1051 WrapUnique(new DictionaryValue));
1052 root = root->DeepCopyWithoutEmptyChildren();
1053 EXPECT_TRUE(root->empty());
1054
1055 // Make sure we don't prune too much.
1056 root->SetBoolean("bool", true);
1057 root->Set("empty_dict", WrapUnique(new DictionaryValue));
1058 root->SetString("empty_string", std::string());
1059 root = root->DeepCopyWithoutEmptyChildren();
1060 EXPECT_EQ(2U, root->size());
1061
1062 // Should do nothing.
1063 root = root->DeepCopyWithoutEmptyChildren();
1064 EXPECT_EQ(2U, root->size());
1065
1066 // Nested test cases. These should all reduce back to the bool and string
1067 // set above.
1068 {
1069 root->Set("a.b.c.d.e", WrapUnique(new DictionaryValue));
1070 root = root->DeepCopyWithoutEmptyChildren();
1071 EXPECT_EQ(2U, root->size());
1072 }
1073 {
1074 std::unique_ptr<DictionaryValue> inner(new DictionaryValue);
1075 inner->Set("empty_dict", WrapUnique(new DictionaryValue));
1076 inner->Set("empty_list", WrapUnique(new ListValue));
1077 root->Set("dict_with_empty_children", std::move(inner));
1078 root = root->DeepCopyWithoutEmptyChildren();
1079 EXPECT_EQ(2U, root->size());
1080 }
1081 {
1082 std::unique_ptr<ListValue> inner(new ListValue);
1083 inner->Append(WrapUnique(new DictionaryValue));
1084 inner->Append(WrapUnique(new ListValue));
1085 root->Set("list_with_empty_children", std::move(inner));
1086 root = root->DeepCopyWithoutEmptyChildren();
1087 EXPECT_EQ(2U, root->size());
1088 }
1089
1090 // Nested with siblings.
1091 {
1092 std::unique_ptr<ListValue> inner(new ListValue());
1093 inner->Append(WrapUnique(new DictionaryValue));
1094 inner->Append(WrapUnique(new ListValue));
1095 root->Set("list_with_empty_children", std::move(inner));
1096 std::unique_ptr<DictionaryValue> inner2(new DictionaryValue);
1097 inner2->Set("empty_dict", WrapUnique(new DictionaryValue));
1098 inner2->Set("empty_list", WrapUnique(new ListValue));
1099 root->Set("dict_with_empty_children", std::move(inner2));
1100 root = root->DeepCopyWithoutEmptyChildren();
1101 EXPECT_EQ(2U, root->size());
1102 }
1103
1104 // Make sure nested values don't get pruned.
1105 {
1106 std::unique_ptr<ListValue> inner(new ListValue);
1107 std::unique_ptr<ListValue> inner2(new ListValue);
1108 inner2->Append(MakeUnique<Value>("hello"));
1109 inner->Append(WrapUnique(new DictionaryValue));
1110 inner->Append(std::move(inner2));
1111 root->Set("list_with_empty_children", std::move(inner));
1112 root = root->DeepCopyWithoutEmptyChildren();
1113 EXPECT_EQ(3U, root->size());
1114
1115 ListValue* inner_value, *inner_value2;
1116 EXPECT_TRUE(root->GetList("list_with_empty_children", &inner_value));
1117 EXPECT_EQ(1U, inner_value->GetSize()); // Dictionary was pruned.
1118 EXPECT_TRUE(inner_value->GetList(0, &inner_value2));
1119 EXPECT_EQ(1U, inner_value2->GetSize());
1120 }
1121 }
1122
TEST(ValuesTest,MergeDictionary)1123 TEST(ValuesTest, MergeDictionary) {
1124 std::unique_ptr<DictionaryValue> base(new DictionaryValue);
1125 base->SetString("base_key", "base_key_value_base");
1126 base->SetString("collide_key", "collide_key_value_base");
1127 std::unique_ptr<DictionaryValue> base_sub_dict(new DictionaryValue);
1128 base_sub_dict->SetString("sub_base_key", "sub_base_key_value_base");
1129 base_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_base");
1130 base->Set("sub_dict_key", std::move(base_sub_dict));
1131
1132 std::unique_ptr<DictionaryValue> merge(new DictionaryValue);
1133 merge->SetString("merge_key", "merge_key_value_merge");
1134 merge->SetString("collide_key", "collide_key_value_merge");
1135 std::unique_ptr<DictionaryValue> merge_sub_dict(new DictionaryValue);
1136 merge_sub_dict->SetString("sub_merge_key", "sub_merge_key_value_merge");
1137 merge_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_merge");
1138 merge->Set("sub_dict_key", std::move(merge_sub_dict));
1139
1140 base->MergeDictionary(merge.get());
1141
1142 EXPECT_EQ(4U, base->size());
1143 std::string base_key_value;
1144 EXPECT_TRUE(base->GetString("base_key", &base_key_value));
1145 EXPECT_EQ("base_key_value_base", base_key_value); // Base value preserved.
1146 std::string collide_key_value;
1147 EXPECT_TRUE(base->GetString("collide_key", &collide_key_value));
1148 EXPECT_EQ("collide_key_value_merge", collide_key_value); // Replaced.
1149 std::string merge_key_value;
1150 EXPECT_TRUE(base->GetString("merge_key", &merge_key_value));
1151 EXPECT_EQ("merge_key_value_merge", merge_key_value); // Merged in.
1152
1153 DictionaryValue* res_sub_dict;
1154 EXPECT_TRUE(base->GetDictionary("sub_dict_key", &res_sub_dict));
1155 EXPECT_EQ(3U, res_sub_dict->size());
1156 std::string sub_base_key_value;
1157 EXPECT_TRUE(res_sub_dict->GetString("sub_base_key", &sub_base_key_value));
1158 EXPECT_EQ("sub_base_key_value_base", sub_base_key_value); // Preserved.
1159 std::string sub_collide_key_value;
1160 EXPECT_TRUE(res_sub_dict->GetString("sub_collide_key",
1161 &sub_collide_key_value));
1162 EXPECT_EQ("sub_collide_key_value_merge", sub_collide_key_value); // Replaced.
1163 std::string sub_merge_key_value;
1164 EXPECT_TRUE(res_sub_dict->GetString("sub_merge_key", &sub_merge_key_value));
1165 EXPECT_EQ("sub_merge_key_value_merge", sub_merge_key_value); // Merged in.
1166 }
1167
TEST(ValuesTest,MergeDictionaryDeepCopy)1168 TEST(ValuesTest, MergeDictionaryDeepCopy) {
1169 std::unique_ptr<DictionaryValue> child(new DictionaryValue);
1170 DictionaryValue* original_child = child.get();
1171 child->SetString("test", "value");
1172 EXPECT_EQ(1U, child->size());
1173
1174 std::string value;
1175 EXPECT_TRUE(child->GetString("test", &value));
1176 EXPECT_EQ("value", value);
1177
1178 std::unique_ptr<DictionaryValue> base(new DictionaryValue);
1179 base->Set("dict", std::move(child));
1180 EXPECT_EQ(1U, base->size());
1181
1182 DictionaryValue* ptr;
1183 EXPECT_TRUE(base->GetDictionary("dict", &ptr));
1184 EXPECT_EQ(original_child, ptr);
1185
1186 std::unique_ptr<DictionaryValue> merged(new DictionaryValue);
1187 merged->MergeDictionary(base.get());
1188 EXPECT_EQ(1U, merged->size());
1189 EXPECT_TRUE(merged->GetDictionary("dict", &ptr));
1190 EXPECT_NE(original_child, ptr);
1191 EXPECT_TRUE(ptr->GetString("test", &value));
1192 EXPECT_EQ("value", value);
1193
1194 original_child->SetString("test", "overwrite");
1195 base.reset();
1196 EXPECT_TRUE(ptr->GetString("test", &value));
1197 EXPECT_EQ("value", value);
1198 }
1199
TEST(ValuesTest,DictionaryIterator)1200 TEST(ValuesTest, DictionaryIterator) {
1201 DictionaryValue dict;
1202 for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
1203 ADD_FAILURE();
1204 }
1205
1206 Value value1("value1");
1207 dict.Set("key1", MakeUnique<Value>(value1));
1208 bool seen1 = false;
1209 for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
1210 EXPECT_FALSE(seen1);
1211 EXPECT_EQ("key1", it.key());
1212 EXPECT_EQ(value1, it.value());
1213 seen1 = true;
1214 }
1215 EXPECT_TRUE(seen1);
1216
1217 Value value2("value2");
1218 dict.Set("key2", MakeUnique<Value>(value2));
1219 bool seen2 = seen1 = false;
1220 for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
1221 if (it.key() == "key1") {
1222 EXPECT_FALSE(seen1);
1223 EXPECT_EQ(value1, it.value());
1224 seen1 = true;
1225 } else if (it.key() == "key2") {
1226 EXPECT_FALSE(seen2);
1227 EXPECT_EQ(value2, it.value());
1228 seen2 = true;
1229 } else {
1230 ADD_FAILURE();
1231 }
1232 }
1233 EXPECT_TRUE(seen1);
1234 EXPECT_TRUE(seen2);
1235 }
1236
1237 // DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value
1238 // and still return true/false based on success.
TEST(ValuesTest,GetWithNullOutValue)1239 TEST(ValuesTest, GetWithNullOutValue) {
1240 DictionaryValue main_dict;
1241 ListValue main_list;
1242
1243 Value bool_value(false);
1244 Value int_value(1234);
1245 Value double_value(12.34567);
1246 Value string_value("foo");
1247 BinaryValue binary_value(Value::Type::BINARY);
1248 DictionaryValue dict_value;
1249 ListValue list_value;
1250
1251 main_dict.Set("bool", MakeUnique<Value>(bool_value));
1252 main_dict.Set("int", MakeUnique<Value>(int_value));
1253 main_dict.Set("double", MakeUnique<Value>(double_value));
1254 main_dict.Set("string", MakeUnique<Value>(string_value));
1255 main_dict.Set("binary", MakeUnique<Value>(binary_value));
1256 main_dict.Set("dict", MakeUnique<Value>(dict_value));
1257 main_dict.Set("list", MakeUnique<Value>(list_value));
1258
1259 main_list.Append(MakeUnique<Value>(bool_value));
1260 main_list.Append(MakeUnique<Value>(int_value));
1261 main_list.Append(MakeUnique<Value>(double_value));
1262 main_list.Append(MakeUnique<Value>(string_value));
1263 main_list.Append(MakeUnique<Value>(binary_value));
1264 main_list.Append(MakeUnique<Value>(dict_value));
1265 main_list.Append(MakeUnique<Value>(list_value));
1266
1267 EXPECT_TRUE(main_dict.Get("bool", NULL));
1268 EXPECT_TRUE(main_dict.Get("int", NULL));
1269 EXPECT_TRUE(main_dict.Get("double", NULL));
1270 EXPECT_TRUE(main_dict.Get("string", NULL));
1271 EXPECT_TRUE(main_dict.Get("binary", NULL));
1272 EXPECT_TRUE(main_dict.Get("dict", NULL));
1273 EXPECT_TRUE(main_dict.Get("list", NULL));
1274 EXPECT_FALSE(main_dict.Get("DNE", NULL));
1275
1276 EXPECT_TRUE(main_dict.GetBoolean("bool", NULL));
1277 EXPECT_FALSE(main_dict.GetBoolean("int", NULL));
1278 EXPECT_FALSE(main_dict.GetBoolean("double", NULL));
1279 EXPECT_FALSE(main_dict.GetBoolean("string", NULL));
1280 EXPECT_FALSE(main_dict.GetBoolean("binary", NULL));
1281 EXPECT_FALSE(main_dict.GetBoolean("dict", NULL));
1282 EXPECT_FALSE(main_dict.GetBoolean("list", NULL));
1283 EXPECT_FALSE(main_dict.GetBoolean("DNE", NULL));
1284
1285 EXPECT_FALSE(main_dict.GetInteger("bool", NULL));
1286 EXPECT_TRUE(main_dict.GetInteger("int", NULL));
1287 EXPECT_FALSE(main_dict.GetInteger("double", NULL));
1288 EXPECT_FALSE(main_dict.GetInteger("string", NULL));
1289 EXPECT_FALSE(main_dict.GetInteger("binary", NULL));
1290 EXPECT_FALSE(main_dict.GetInteger("dict", NULL));
1291 EXPECT_FALSE(main_dict.GetInteger("list", NULL));
1292 EXPECT_FALSE(main_dict.GetInteger("DNE", NULL));
1293
1294 // Both int and double values can be obtained from GetDouble.
1295 EXPECT_FALSE(main_dict.GetDouble("bool", NULL));
1296 EXPECT_TRUE(main_dict.GetDouble("int", NULL));
1297 EXPECT_TRUE(main_dict.GetDouble("double", NULL));
1298 EXPECT_FALSE(main_dict.GetDouble("string", NULL));
1299 EXPECT_FALSE(main_dict.GetDouble("binary", NULL));
1300 EXPECT_FALSE(main_dict.GetDouble("dict", NULL));
1301 EXPECT_FALSE(main_dict.GetDouble("list", NULL));
1302 EXPECT_FALSE(main_dict.GetDouble("DNE", NULL));
1303
1304 EXPECT_FALSE(main_dict.GetString("bool", static_cast<std::string*>(NULL)));
1305 EXPECT_FALSE(main_dict.GetString("int", static_cast<std::string*>(NULL)));
1306 EXPECT_FALSE(main_dict.GetString("double", static_cast<std::string*>(NULL)));
1307 EXPECT_TRUE(main_dict.GetString("string", static_cast<std::string*>(NULL)));
1308 EXPECT_FALSE(main_dict.GetString("binary", static_cast<std::string*>(NULL)));
1309 EXPECT_FALSE(main_dict.GetString("dict", static_cast<std::string*>(NULL)));
1310 EXPECT_FALSE(main_dict.GetString("list", static_cast<std::string*>(NULL)));
1311 EXPECT_FALSE(main_dict.GetString("DNE", static_cast<std::string*>(NULL)));
1312
1313 EXPECT_FALSE(main_dict.GetString("bool", static_cast<string16*>(NULL)));
1314 EXPECT_FALSE(main_dict.GetString("int", static_cast<string16*>(NULL)));
1315 EXPECT_FALSE(main_dict.GetString("double", static_cast<string16*>(NULL)));
1316 EXPECT_TRUE(main_dict.GetString("string", static_cast<string16*>(NULL)));
1317 EXPECT_FALSE(main_dict.GetString("binary", static_cast<string16*>(NULL)));
1318 EXPECT_FALSE(main_dict.GetString("dict", static_cast<string16*>(NULL)));
1319 EXPECT_FALSE(main_dict.GetString("list", static_cast<string16*>(NULL)));
1320 EXPECT_FALSE(main_dict.GetString("DNE", static_cast<string16*>(NULL)));
1321
1322 EXPECT_FALSE(main_dict.GetBinary("bool", NULL));
1323 EXPECT_FALSE(main_dict.GetBinary("int", NULL));
1324 EXPECT_FALSE(main_dict.GetBinary("double", NULL));
1325 EXPECT_FALSE(main_dict.GetBinary("string", NULL));
1326 EXPECT_TRUE(main_dict.GetBinary("binary", NULL));
1327 EXPECT_FALSE(main_dict.GetBinary("dict", NULL));
1328 EXPECT_FALSE(main_dict.GetBinary("list", NULL));
1329 EXPECT_FALSE(main_dict.GetBinary("DNE", NULL));
1330
1331 EXPECT_FALSE(main_dict.GetDictionary("bool", NULL));
1332 EXPECT_FALSE(main_dict.GetDictionary("int", NULL));
1333 EXPECT_FALSE(main_dict.GetDictionary("double", NULL));
1334 EXPECT_FALSE(main_dict.GetDictionary("string", NULL));
1335 EXPECT_FALSE(main_dict.GetDictionary("binary", NULL));
1336 EXPECT_TRUE(main_dict.GetDictionary("dict", NULL));
1337 EXPECT_FALSE(main_dict.GetDictionary("list", NULL));
1338 EXPECT_FALSE(main_dict.GetDictionary("DNE", NULL));
1339
1340 EXPECT_FALSE(main_dict.GetList("bool", NULL));
1341 EXPECT_FALSE(main_dict.GetList("int", NULL));
1342 EXPECT_FALSE(main_dict.GetList("double", NULL));
1343 EXPECT_FALSE(main_dict.GetList("string", NULL));
1344 EXPECT_FALSE(main_dict.GetList("binary", NULL));
1345 EXPECT_FALSE(main_dict.GetList("dict", NULL));
1346 EXPECT_TRUE(main_dict.GetList("list", NULL));
1347 EXPECT_FALSE(main_dict.GetList("DNE", NULL));
1348
1349 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("bool", NULL));
1350 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("int", NULL));
1351 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("double", NULL));
1352 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("string", NULL));
1353 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("binary", NULL));
1354 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("dict", NULL));
1355 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("list", NULL));
1356 EXPECT_FALSE(main_dict.GetWithoutPathExpansion("DNE", NULL));
1357
1358 EXPECT_TRUE(main_dict.GetBooleanWithoutPathExpansion("bool", NULL));
1359 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("int", NULL));
1360 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("double", NULL));
1361 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("string", NULL));
1362 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("binary", NULL));
1363 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("dict", NULL));
1364 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("list", NULL));
1365 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("DNE", NULL));
1366
1367 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("bool", NULL));
1368 EXPECT_TRUE(main_dict.GetIntegerWithoutPathExpansion("int", NULL));
1369 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("double", NULL));
1370 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("string", NULL));
1371 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("binary", NULL));
1372 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("dict", NULL));
1373 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("list", NULL));
1374 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("DNE", NULL));
1375
1376 EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("bool", NULL));
1377 EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("int", NULL));
1378 EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("double", NULL));
1379 EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("string", NULL));
1380 EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("binary", NULL));
1381 EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("dict", NULL));
1382 EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("list", NULL));
1383 EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("DNE", NULL));
1384
1385 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1386 "bool", static_cast<std::string*>(NULL)));
1387 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1388 "int", static_cast<std::string*>(NULL)));
1389 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1390 "double", static_cast<std::string*>(NULL)));
1391 EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
1392 "string", static_cast<std::string*>(NULL)));
1393 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1394 "binary", static_cast<std::string*>(NULL)));
1395 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1396 "dict", static_cast<std::string*>(NULL)));
1397 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1398 "list", static_cast<std::string*>(NULL)));
1399 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1400 "DNE", static_cast<std::string*>(NULL)));
1401
1402 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1403 "bool", static_cast<string16*>(NULL)));
1404 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1405 "int", static_cast<string16*>(NULL)));
1406 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1407 "double", static_cast<string16*>(NULL)));
1408 EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
1409 "string", static_cast<string16*>(NULL)));
1410 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1411 "binary", static_cast<string16*>(NULL)));
1412 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1413 "dict", static_cast<string16*>(NULL)));
1414 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1415 "list", static_cast<string16*>(NULL)));
1416 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1417 "DNE", static_cast<string16*>(NULL)));
1418
1419 // There is no GetBinaryWithoutPathExpansion for some reason, but if there
1420 // were it should be tested here...
1421
1422 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("bool", NULL));
1423 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("int", NULL));
1424 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("double", NULL));
1425 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("string", NULL));
1426 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("binary", NULL));
1427 EXPECT_TRUE(main_dict.GetDictionaryWithoutPathExpansion("dict", NULL));
1428 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("list", NULL));
1429 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("DNE", NULL));
1430
1431 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("bool", NULL));
1432 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("int", NULL));
1433 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("double", NULL));
1434 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("string", NULL));
1435 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("binary", NULL));
1436 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("dict", NULL));
1437 EXPECT_TRUE(main_dict.GetListWithoutPathExpansion("list", NULL));
1438 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("DNE", NULL));
1439
1440 EXPECT_TRUE(main_list.Get(0, NULL));
1441 EXPECT_TRUE(main_list.Get(1, NULL));
1442 EXPECT_TRUE(main_list.Get(2, NULL));
1443 EXPECT_TRUE(main_list.Get(3, NULL));
1444 EXPECT_TRUE(main_list.Get(4, NULL));
1445 EXPECT_TRUE(main_list.Get(5, NULL));
1446 EXPECT_TRUE(main_list.Get(6, NULL));
1447 EXPECT_FALSE(main_list.Get(7, NULL));
1448
1449 EXPECT_TRUE(main_list.GetBoolean(0, NULL));
1450 EXPECT_FALSE(main_list.GetBoolean(1, NULL));
1451 EXPECT_FALSE(main_list.GetBoolean(2, NULL));
1452 EXPECT_FALSE(main_list.GetBoolean(3, NULL));
1453 EXPECT_FALSE(main_list.GetBoolean(4, NULL));
1454 EXPECT_FALSE(main_list.GetBoolean(5, NULL));
1455 EXPECT_FALSE(main_list.GetBoolean(6, NULL));
1456 EXPECT_FALSE(main_list.GetBoolean(7, NULL));
1457
1458 EXPECT_FALSE(main_list.GetInteger(0, NULL));
1459 EXPECT_TRUE(main_list.GetInteger(1, NULL));
1460 EXPECT_FALSE(main_list.GetInteger(2, NULL));
1461 EXPECT_FALSE(main_list.GetInteger(3, NULL));
1462 EXPECT_FALSE(main_list.GetInteger(4, NULL));
1463 EXPECT_FALSE(main_list.GetInteger(5, NULL));
1464 EXPECT_FALSE(main_list.GetInteger(6, NULL));
1465 EXPECT_FALSE(main_list.GetInteger(7, NULL));
1466
1467 EXPECT_FALSE(main_list.GetDouble(0, NULL));
1468 EXPECT_TRUE(main_list.GetDouble(1, NULL));
1469 EXPECT_TRUE(main_list.GetDouble(2, NULL));
1470 EXPECT_FALSE(main_list.GetDouble(3, NULL));
1471 EXPECT_FALSE(main_list.GetDouble(4, NULL));
1472 EXPECT_FALSE(main_list.GetDouble(5, NULL));
1473 EXPECT_FALSE(main_list.GetDouble(6, NULL));
1474 EXPECT_FALSE(main_list.GetDouble(7, NULL));
1475
1476 EXPECT_FALSE(main_list.GetString(0, static_cast<std::string*>(NULL)));
1477 EXPECT_FALSE(main_list.GetString(1, static_cast<std::string*>(NULL)));
1478 EXPECT_FALSE(main_list.GetString(2, static_cast<std::string*>(NULL)));
1479 EXPECT_TRUE(main_list.GetString(3, static_cast<std::string*>(NULL)));
1480 EXPECT_FALSE(main_list.GetString(4, static_cast<std::string*>(NULL)));
1481 EXPECT_FALSE(main_list.GetString(5, static_cast<std::string*>(NULL)));
1482 EXPECT_FALSE(main_list.GetString(6, static_cast<std::string*>(NULL)));
1483 EXPECT_FALSE(main_list.GetString(7, static_cast<std::string*>(NULL)));
1484
1485 EXPECT_FALSE(main_list.GetString(0, static_cast<string16*>(NULL)));
1486 EXPECT_FALSE(main_list.GetString(1, static_cast<string16*>(NULL)));
1487 EXPECT_FALSE(main_list.GetString(2, static_cast<string16*>(NULL)));
1488 EXPECT_TRUE(main_list.GetString(3, static_cast<string16*>(NULL)));
1489 EXPECT_FALSE(main_list.GetString(4, static_cast<string16*>(NULL)));
1490 EXPECT_FALSE(main_list.GetString(5, static_cast<string16*>(NULL)));
1491 EXPECT_FALSE(main_list.GetString(6, static_cast<string16*>(NULL)));
1492 EXPECT_FALSE(main_list.GetString(7, static_cast<string16*>(NULL)));
1493
1494 EXPECT_FALSE(main_list.GetBinary(0, NULL));
1495 EXPECT_FALSE(main_list.GetBinary(1, NULL));
1496 EXPECT_FALSE(main_list.GetBinary(2, NULL));
1497 EXPECT_FALSE(main_list.GetBinary(3, NULL));
1498 EXPECT_TRUE(main_list.GetBinary(4, NULL));
1499 EXPECT_FALSE(main_list.GetBinary(5, NULL));
1500 EXPECT_FALSE(main_list.GetBinary(6, NULL));
1501 EXPECT_FALSE(main_list.GetBinary(7, NULL));
1502
1503 EXPECT_FALSE(main_list.GetDictionary(0, NULL));
1504 EXPECT_FALSE(main_list.GetDictionary(1, NULL));
1505 EXPECT_FALSE(main_list.GetDictionary(2, NULL));
1506 EXPECT_FALSE(main_list.GetDictionary(3, NULL));
1507 EXPECT_FALSE(main_list.GetDictionary(4, NULL));
1508 EXPECT_TRUE(main_list.GetDictionary(5, NULL));
1509 EXPECT_FALSE(main_list.GetDictionary(6, NULL));
1510 EXPECT_FALSE(main_list.GetDictionary(7, NULL));
1511
1512 EXPECT_FALSE(main_list.GetList(0, NULL));
1513 EXPECT_FALSE(main_list.GetList(1, NULL));
1514 EXPECT_FALSE(main_list.GetList(2, NULL));
1515 EXPECT_FALSE(main_list.GetList(3, NULL));
1516 EXPECT_FALSE(main_list.GetList(4, NULL));
1517 EXPECT_FALSE(main_list.GetList(5, NULL));
1518 EXPECT_TRUE(main_list.GetList(6, NULL));
1519 EXPECT_FALSE(main_list.GetList(7, NULL));
1520 }
1521
1522 } // namespace base
1523