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.
7 #include "base/memory/scoped_ptr.h"
8 #include "base/strings/string16.h"
9 #include "base/strings/utf_string_conversions.h"
10 #include "base/values.h"
11 #include "testing/gtest/include/gtest/gtest.h"
15 TEST(ValuesTest
, Basic
) {
16 // Test basic dictionary getting/setting
17 DictionaryValue settings
;
18 std::string homepage
= "http://google.com";
19 ASSERT_FALSE(settings
.GetString("global.homepage", &homepage
));
20 ASSERT_EQ(std::string("http://google.com"), homepage
);
22 ASSERT_FALSE(settings
.Get("global", NULL
));
23 settings
.Set("global", new FundamentalValue(true));
24 ASSERT_TRUE(settings
.Get("global", NULL
));
25 settings
.SetString("global.homepage", "http://scurvy.com");
26 ASSERT_TRUE(settings
.Get("global", NULL
));
27 homepage
= "http://google.com";
28 ASSERT_TRUE(settings
.GetString("global.homepage", &homepage
));
29 ASSERT_EQ(std::string("http://scurvy.com"), homepage
);
31 // Test storing a dictionary in a list.
32 ListValue
* toolbar_bookmarks
;
34 settings
.GetList("global.toolbar.bookmarks", &toolbar_bookmarks
));
36 toolbar_bookmarks
= new ListValue
;
37 settings
.Set("global.toolbar.bookmarks", toolbar_bookmarks
);
38 ASSERT_TRUE(settings
.GetList("global.toolbar.bookmarks", &toolbar_bookmarks
));
40 DictionaryValue
* new_bookmark
= new DictionaryValue
;
41 new_bookmark
->SetString("name", "Froogle");
42 new_bookmark
->SetString("url", "http://froogle.com");
43 toolbar_bookmarks
->Append(new_bookmark
);
45 ListValue
* bookmark_list
;
46 ASSERT_TRUE(settings
.GetList("global.toolbar.bookmarks", &bookmark_list
));
47 DictionaryValue
* bookmark
;
48 ASSERT_EQ(1U, bookmark_list
->GetSize());
49 ASSERT_TRUE(bookmark_list
->GetDictionary(0, &bookmark
));
50 std::string bookmark_name
= "Unnamed";
51 ASSERT_TRUE(bookmark
->GetString("name", &bookmark_name
));
52 ASSERT_EQ(std::string("Froogle"), bookmark_name
);
53 std::string bookmark_url
;
54 ASSERT_TRUE(bookmark
->GetString("url", &bookmark_url
));
55 ASSERT_EQ(std::string("http://froogle.com"), bookmark_url
);
58 TEST(ValuesTest
, List
) {
59 scoped_ptr
<ListValue
> mixed_list(new ListValue());
60 mixed_list
->Set(0, new FundamentalValue(true));
61 mixed_list
->Set(1, new FundamentalValue(42));
62 mixed_list
->Set(2, new FundamentalValue(88.8));
63 mixed_list
->Set(3, new StringValue("foo"));
64 ASSERT_EQ(4u, mixed_list
->GetSize());
67 bool bool_value
= false;
69 double double_value
= 0.0;
70 std::string string_value
;
72 ASSERT_FALSE(mixed_list
->Get(4, &value
));
74 ASSERT_FALSE(mixed_list
->GetInteger(0, &int_value
));
75 ASSERT_EQ(0, int_value
);
76 ASSERT_FALSE(mixed_list
->GetBoolean(1, &bool_value
));
77 ASSERT_FALSE(bool_value
);
78 ASSERT_FALSE(mixed_list
->GetString(2, &string_value
));
79 ASSERT_EQ("", string_value
);
80 ASSERT_FALSE(mixed_list
->GetInteger(2, &int_value
));
81 ASSERT_EQ(0, int_value
);
82 ASSERT_FALSE(mixed_list
->GetBoolean(3, &bool_value
));
83 ASSERT_FALSE(bool_value
);
85 ASSERT_TRUE(mixed_list
->GetBoolean(0, &bool_value
));
86 ASSERT_TRUE(bool_value
);
87 ASSERT_TRUE(mixed_list
->GetInteger(1, &int_value
));
88 ASSERT_EQ(42, int_value
);
89 // implicit conversion from Integer to Double should be possible.
90 ASSERT_TRUE(mixed_list
->GetDouble(1, &double_value
));
91 ASSERT_EQ(42, double_value
);
92 ASSERT_TRUE(mixed_list
->GetDouble(2, &double_value
));
93 ASSERT_EQ(88.8, double_value
);
94 ASSERT_TRUE(mixed_list
->GetString(3, &string_value
));
95 ASSERT_EQ("foo", string_value
);
97 // Try searching in the mixed list.
98 base::FundamentalValue
sought_value(42);
99 base::FundamentalValue
not_found_value(false);
101 ASSERT_NE(mixed_list
->end(), mixed_list
->Find(sought_value
));
102 ASSERT_TRUE((*mixed_list
->Find(sought_value
))->GetAsInteger(&int_value
));
103 ASSERT_EQ(42, int_value
);
104 ASSERT_EQ(mixed_list
->end(), mixed_list
->Find(not_found_value
));
107 TEST(ValuesTest
, BinaryValue
) {
108 // Default constructor creates a BinaryValue with a null buffer and size 0.
109 scoped_ptr
<BinaryValue
> binary(new BinaryValue());
110 ASSERT_TRUE(binary
.get());
111 ASSERT_EQ(NULL
, binary
->GetBuffer());
112 ASSERT_EQ(0U, binary
->GetSize());
114 // Test the common case of a non-empty buffer
115 char* buffer
= new char[15];
116 binary
.reset(new BinaryValue(scoped_ptr
<char[]>(buffer
), 15));
117 ASSERT_TRUE(binary
.get());
118 ASSERT_TRUE(binary
->GetBuffer());
119 ASSERT_EQ(buffer
, binary
->GetBuffer());
120 ASSERT_EQ(15U, binary
->GetSize());
122 char stack_buffer
[42];
123 memset(stack_buffer
, '!', 42);
124 binary
.reset(BinaryValue::CreateWithCopiedBuffer(stack_buffer
, 42));
125 ASSERT_TRUE(binary
.get());
126 ASSERT_TRUE(binary
->GetBuffer());
127 ASSERT_NE(stack_buffer
, binary
->GetBuffer());
128 ASSERT_EQ(42U, binary
->GetSize());
129 ASSERT_EQ(0, memcmp(stack_buffer
, binary
->GetBuffer(), binary
->GetSize()));
131 // Test overloaded GetAsBinary.
132 Value
* narrow_value
= binary
.get();
133 const BinaryValue
* narrow_binary
= NULL
;
134 ASSERT_TRUE(narrow_value
->GetAsBinary(&narrow_binary
));
135 EXPECT_EQ(binary
.get(), narrow_binary
);
138 TEST(ValuesTest
, StringValue
) {
139 // Test overloaded StringValue constructor.
140 scoped_ptr
<Value
> narrow_value(new StringValue("narrow"));
141 ASSERT_TRUE(narrow_value
.get());
142 ASSERT_TRUE(narrow_value
->IsType(Value::TYPE_STRING
));
143 scoped_ptr
<Value
> utf16_value(new StringValue(ASCIIToUTF16("utf16")));
144 ASSERT_TRUE(utf16_value
.get());
145 ASSERT_TRUE(utf16_value
->IsType(Value::TYPE_STRING
));
147 // Test overloaded GetAsString.
148 std::string narrow
= "http://google.com";
149 string16 utf16
= ASCIIToUTF16("http://google.com");
150 const StringValue
* string_value
= NULL
;
151 ASSERT_TRUE(narrow_value
->GetAsString(&narrow
));
152 ASSERT_TRUE(narrow_value
->GetAsString(&utf16
));
153 ASSERT_TRUE(narrow_value
->GetAsString(&string_value
));
154 ASSERT_EQ(std::string("narrow"), narrow
);
155 ASSERT_EQ(ASCIIToUTF16("narrow"), utf16
);
156 ASSERT_EQ(string_value
->GetString(), narrow
);
158 ASSERT_TRUE(utf16_value
->GetAsString(&narrow
));
159 ASSERT_TRUE(utf16_value
->GetAsString(&utf16
));
160 ASSERT_TRUE(utf16_value
->GetAsString(&string_value
));
161 ASSERT_EQ(std::string("utf16"), narrow
);
162 ASSERT_EQ(ASCIIToUTF16("utf16"), utf16
);
163 ASSERT_EQ(string_value
->GetString(), narrow
);
165 // Don't choke on NULL values.
166 ASSERT_TRUE(narrow_value
->GetAsString(static_cast<string16
*>(NULL
)));
167 ASSERT_TRUE(narrow_value
->GetAsString(static_cast<std::string
*>(NULL
)));
168 ASSERT_TRUE(narrow_value
->GetAsString(
169 static_cast<const StringValue
**>(NULL
)));
172 // This is a Value object that allows us to tell if it's been
173 // properly deleted by modifying the value of external flag on destruction.
174 class DeletionTestValue
: public Value
{
176 explicit DeletionTestValue(bool* deletion_flag
) : Value(TYPE_NULL
) {
177 Init(deletion_flag
); // Separate function so that we can use ASSERT_*
180 void Init(bool* deletion_flag
) {
181 ASSERT_TRUE(deletion_flag
);
182 deletion_flag_
= deletion_flag
;
183 *deletion_flag_
= false;
186 ~DeletionTestValue() override
{ *deletion_flag_
= true; }
189 bool* deletion_flag_
;
192 TEST(ValuesTest
, ListDeletion
) {
193 bool deletion_flag
= true;
197 list
.Append(new DeletionTestValue(&deletion_flag
));
198 EXPECT_FALSE(deletion_flag
);
200 EXPECT_TRUE(deletion_flag
);
204 list
.Append(new DeletionTestValue(&deletion_flag
));
205 EXPECT_FALSE(deletion_flag
);
207 EXPECT_TRUE(deletion_flag
);
212 list
.Append(new DeletionTestValue(&deletion_flag
));
213 EXPECT_FALSE(deletion_flag
);
214 EXPECT_TRUE(list
.Set(0, Value::CreateNullValue()));
215 EXPECT_TRUE(deletion_flag
);
219 TEST(ValuesTest
, ListRemoval
) {
220 bool deletion_flag
= true;
221 scoped_ptr
<Value
> removed_item
;
225 list
.Append(new DeletionTestValue(&deletion_flag
));
226 EXPECT_FALSE(deletion_flag
);
227 EXPECT_EQ(1U, list
.GetSize());
228 EXPECT_FALSE(list
.Remove(std::numeric_limits
<size_t>::max(),
230 EXPECT_FALSE(list
.Remove(1, &removed_item
));
231 EXPECT_TRUE(list
.Remove(0, &removed_item
));
232 ASSERT_TRUE(removed_item
);
233 EXPECT_EQ(0U, list
.GetSize());
235 EXPECT_FALSE(deletion_flag
);
236 removed_item
.reset();
237 EXPECT_TRUE(deletion_flag
);
241 list
.Append(new DeletionTestValue(&deletion_flag
));
242 EXPECT_FALSE(deletion_flag
);
243 EXPECT_TRUE(list
.Remove(0, NULL
));
244 EXPECT_TRUE(deletion_flag
);
245 EXPECT_EQ(0U, list
.GetSize());
250 DeletionTestValue
* value
= new DeletionTestValue(&deletion_flag
);
252 EXPECT_FALSE(deletion_flag
);
254 list
.Remove(*value
, &index
);
255 EXPECT_EQ(0U, index
);
256 EXPECT_TRUE(deletion_flag
);
257 EXPECT_EQ(0U, list
.GetSize());
261 TEST(ValuesTest
, DictionaryDeletion
) {
262 std::string key
= "test";
263 bool deletion_flag
= true;
266 DictionaryValue dict
;
267 dict
.Set(key
, new DeletionTestValue(&deletion_flag
));
268 EXPECT_FALSE(deletion_flag
);
270 EXPECT_TRUE(deletion_flag
);
273 DictionaryValue dict
;
274 dict
.Set(key
, new DeletionTestValue(&deletion_flag
));
275 EXPECT_FALSE(deletion_flag
);
277 EXPECT_TRUE(deletion_flag
);
281 DictionaryValue dict
;
282 dict
.Set(key
, new DeletionTestValue(&deletion_flag
));
283 EXPECT_FALSE(deletion_flag
);
284 dict
.Set(key
, Value::CreateNullValue());
285 EXPECT_TRUE(deletion_flag
);
289 TEST(ValuesTest
, DictionaryRemoval
) {
290 std::string key
= "test";
291 bool deletion_flag
= true;
292 scoped_ptr
<Value
> removed_item
;
295 DictionaryValue dict
;
296 dict
.Set(key
, new DeletionTestValue(&deletion_flag
));
297 EXPECT_FALSE(deletion_flag
);
298 EXPECT_TRUE(dict
.HasKey(key
));
299 EXPECT_FALSE(dict
.Remove("absent key", &removed_item
));
300 EXPECT_TRUE(dict
.Remove(key
, &removed_item
));
301 EXPECT_FALSE(dict
.HasKey(key
));
302 ASSERT_TRUE(removed_item
);
304 EXPECT_FALSE(deletion_flag
);
305 removed_item
.reset();
306 EXPECT_TRUE(deletion_flag
);
309 DictionaryValue dict
;
310 dict
.Set(key
, new DeletionTestValue(&deletion_flag
));
311 EXPECT_FALSE(deletion_flag
);
312 EXPECT_TRUE(dict
.HasKey(key
));
313 EXPECT_TRUE(dict
.Remove(key
, NULL
));
314 EXPECT_TRUE(deletion_flag
);
315 EXPECT_FALSE(dict
.HasKey(key
));
319 TEST(ValuesTest
, DictionaryWithoutPathExpansion
) {
320 DictionaryValue dict
;
321 dict
.Set("this.is.expanded", make_scoped_ptr(Value::CreateNullValue()));
322 dict
.SetWithoutPathExpansion("this.isnt.expanded",
323 make_scoped_ptr(Value::CreateNullValue()));
325 EXPECT_FALSE(dict
.HasKey("this.is.expanded"));
326 EXPECT_TRUE(dict
.HasKey("this"));
328 EXPECT_TRUE(dict
.Get("this", &value1
));
329 DictionaryValue
* value2
;
330 ASSERT_TRUE(dict
.GetDictionaryWithoutPathExpansion("this", &value2
));
331 EXPECT_EQ(value1
, value2
);
332 EXPECT_EQ(1U, value2
->size());
334 EXPECT_TRUE(dict
.HasKey("this.isnt.expanded"));
336 EXPECT_FALSE(dict
.Get("this.isnt.expanded", &value3
));
338 ASSERT_TRUE(dict
.GetWithoutPathExpansion("this.isnt.expanded", &value4
));
339 EXPECT_EQ(Value::TYPE_NULL
, value4
->GetType());
342 // Tests the deprecated version of SetWithoutPathExpansion.
343 // TODO(estade): remove.
344 TEST(ValuesTest
, DictionaryWithoutPathExpansionDeprecated
) {
345 DictionaryValue dict
;
346 dict
.Set("this.is.expanded", Value::CreateNullValue());
347 dict
.SetWithoutPathExpansion("this.isnt.expanded", Value::CreateNullValue());
349 EXPECT_FALSE(dict
.HasKey("this.is.expanded"));
350 EXPECT_TRUE(dict
.HasKey("this"));
352 EXPECT_TRUE(dict
.Get("this", &value1
));
353 DictionaryValue
* value2
;
354 ASSERT_TRUE(dict
.GetDictionaryWithoutPathExpansion("this", &value2
));
355 EXPECT_EQ(value1
, value2
);
356 EXPECT_EQ(1U, value2
->size());
358 EXPECT_TRUE(dict
.HasKey("this.isnt.expanded"));
360 EXPECT_FALSE(dict
.Get("this.isnt.expanded", &value3
));
362 ASSERT_TRUE(dict
.GetWithoutPathExpansion("this.isnt.expanded", &value4
));
363 EXPECT_EQ(Value::TYPE_NULL
, value4
->GetType());
366 TEST(ValuesTest
, DictionaryRemovePath
) {
367 DictionaryValue dict
;
368 dict
.SetInteger("a.long.way.down", 1);
369 dict
.SetBoolean("a.long.key.path", true);
371 scoped_ptr
<Value
> removed_item
;
372 EXPECT_TRUE(dict
.RemovePath("a.long.way.down", &removed_item
));
373 ASSERT_TRUE(removed_item
);
374 EXPECT_TRUE(removed_item
->IsType(base::Value::TYPE_INTEGER
));
375 EXPECT_FALSE(dict
.HasKey("a.long.way.down"));
376 EXPECT_FALSE(dict
.HasKey("a.long.way"));
377 EXPECT_TRUE(dict
.Get("a.long.key.path", NULL
));
379 removed_item
.reset();
380 EXPECT_FALSE(dict
.RemovePath("a.long.way.down", &removed_item
));
381 EXPECT_FALSE(removed_item
);
382 EXPECT_TRUE(dict
.Get("a.long.key.path", NULL
));
384 removed_item
.reset();
385 EXPECT_TRUE(dict
.RemovePath("a.long.key.path", &removed_item
));
386 ASSERT_TRUE(removed_item
);
387 EXPECT_TRUE(removed_item
->IsType(base::Value::TYPE_BOOLEAN
));
388 EXPECT_TRUE(dict
.empty());
391 TEST(ValuesTest
, DeepCopy
) {
392 DictionaryValue original_dict
;
393 Value
* original_null
= Value::CreateNullValue();
394 original_dict
.Set("null", make_scoped_ptr(original_null
));
395 FundamentalValue
* original_bool
= new FundamentalValue(true);
396 original_dict
.Set("bool", make_scoped_ptr(original_bool
));
397 FundamentalValue
* original_int
= new FundamentalValue(42);
398 original_dict
.Set("int", make_scoped_ptr(original_int
));
399 FundamentalValue
* original_double
= new FundamentalValue(3.14);
400 original_dict
.Set("double", make_scoped_ptr(original_double
));
401 StringValue
* original_string
= new StringValue("hello");
402 original_dict
.Set("string", make_scoped_ptr(original_string
));
403 StringValue
* original_string16
= new StringValue(ASCIIToUTF16("hello16"));
404 original_dict
.Set("string16", make_scoped_ptr(original_string16
));
406 scoped_ptr
<char[]> original_buffer(new char[42]);
407 memset(original_buffer
.get(), '!', 42);
408 BinaryValue
* original_binary
= new BinaryValue(original_buffer
.Pass(), 42);
409 original_dict
.Set("binary", original_binary
);
411 ListValue
* original_list
= new ListValue();
412 FundamentalValue
* original_list_element_0
= new FundamentalValue(0);
413 original_list
->Append(original_list_element_0
);
414 FundamentalValue
* original_list_element_1
= new FundamentalValue(1);
415 original_list
->Append(original_list_element_1
);
416 original_dict
.Set("list", make_scoped_ptr(original_list
));
418 DictionaryValue
* original_nested_dictionary
= new DictionaryValue();
419 original_nested_dictionary
->SetString("key", "value");
420 original_dict
.Set("dictionary", make_scoped_ptr(original_nested_dictionary
));
422 scoped_ptr
<DictionaryValue
> copy_dict(original_dict
.DeepCopy());
423 ASSERT_TRUE(copy_dict
.get());
424 ASSERT_NE(copy_dict
.get(), &original_dict
);
426 Value
* copy_null
= NULL
;
427 ASSERT_TRUE(copy_dict
->Get("null", ©_null
));
428 ASSERT_TRUE(copy_null
);
429 ASSERT_NE(copy_null
, original_null
);
430 ASSERT_TRUE(copy_null
->IsType(Value::TYPE_NULL
));
432 Value
* copy_bool
= NULL
;
433 ASSERT_TRUE(copy_dict
->Get("bool", ©_bool
));
434 ASSERT_TRUE(copy_bool
);
435 ASSERT_NE(copy_bool
, original_bool
);
436 ASSERT_TRUE(copy_bool
->IsType(Value::TYPE_BOOLEAN
));
437 bool copy_bool_value
= false;
438 ASSERT_TRUE(copy_bool
->GetAsBoolean(©_bool_value
));
439 ASSERT_TRUE(copy_bool_value
);
441 Value
* copy_int
= NULL
;
442 ASSERT_TRUE(copy_dict
->Get("int", ©_int
));
443 ASSERT_TRUE(copy_int
);
444 ASSERT_NE(copy_int
, original_int
);
445 ASSERT_TRUE(copy_int
->IsType(Value::TYPE_INTEGER
));
446 int copy_int_value
= 0;
447 ASSERT_TRUE(copy_int
->GetAsInteger(©_int_value
));
448 ASSERT_EQ(42, copy_int_value
);
450 Value
* copy_double
= NULL
;
451 ASSERT_TRUE(copy_dict
->Get("double", ©_double
));
452 ASSERT_TRUE(copy_double
);
453 ASSERT_NE(copy_double
, original_double
);
454 ASSERT_TRUE(copy_double
->IsType(Value::TYPE_DOUBLE
));
455 double copy_double_value
= 0;
456 ASSERT_TRUE(copy_double
->GetAsDouble(©_double_value
));
457 ASSERT_EQ(3.14, copy_double_value
);
459 Value
* copy_string
= NULL
;
460 ASSERT_TRUE(copy_dict
->Get("string", ©_string
));
461 ASSERT_TRUE(copy_string
);
462 ASSERT_NE(copy_string
, original_string
);
463 ASSERT_TRUE(copy_string
->IsType(Value::TYPE_STRING
));
464 std::string copy_string_value
;
465 string16 copy_string16_value
;
466 ASSERT_TRUE(copy_string
->GetAsString(©_string_value
));
467 ASSERT_TRUE(copy_string
->GetAsString(©_string16_value
));
468 ASSERT_EQ(std::string("hello"), copy_string_value
);
469 ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value
);
471 Value
* copy_string16
= NULL
;
472 ASSERT_TRUE(copy_dict
->Get("string16", ©_string16
));
473 ASSERT_TRUE(copy_string16
);
474 ASSERT_NE(copy_string16
, original_string16
);
475 ASSERT_TRUE(copy_string16
->IsType(Value::TYPE_STRING
));
476 ASSERT_TRUE(copy_string16
->GetAsString(©_string_value
));
477 ASSERT_TRUE(copy_string16
->GetAsString(©_string16_value
));
478 ASSERT_EQ(std::string("hello16"), copy_string_value
);
479 ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value
);
481 Value
* copy_binary
= NULL
;
482 ASSERT_TRUE(copy_dict
->Get("binary", ©_binary
));
483 ASSERT_TRUE(copy_binary
);
484 ASSERT_NE(copy_binary
, original_binary
);
485 ASSERT_TRUE(copy_binary
->IsType(Value::TYPE_BINARY
));
486 ASSERT_NE(original_binary
->GetBuffer(),
487 static_cast<BinaryValue
*>(copy_binary
)->GetBuffer());
488 ASSERT_EQ(original_binary
->GetSize(),
489 static_cast<BinaryValue
*>(copy_binary
)->GetSize());
490 ASSERT_EQ(0, memcmp(original_binary
->GetBuffer(),
491 static_cast<BinaryValue
*>(copy_binary
)->GetBuffer(),
492 original_binary
->GetSize()));
494 Value
* copy_value
= NULL
;
495 ASSERT_TRUE(copy_dict
->Get("list", ©_value
));
496 ASSERT_TRUE(copy_value
);
497 ASSERT_NE(copy_value
, original_list
);
498 ASSERT_TRUE(copy_value
->IsType(Value::TYPE_LIST
));
499 ListValue
* copy_list
= NULL
;
500 ASSERT_TRUE(copy_value
->GetAsList(©_list
));
501 ASSERT_TRUE(copy_list
);
502 ASSERT_EQ(2U, copy_list
->GetSize());
504 Value
* copy_list_element_0
;
505 ASSERT_TRUE(copy_list
->Get(0, ©_list_element_0
));
506 ASSERT_TRUE(copy_list_element_0
);
507 ASSERT_NE(copy_list_element_0
, original_list_element_0
);
508 int copy_list_element_0_value
;
509 ASSERT_TRUE(copy_list_element_0
->GetAsInteger(©_list_element_0_value
));
510 ASSERT_EQ(0, copy_list_element_0_value
);
512 Value
* copy_list_element_1
;
513 ASSERT_TRUE(copy_list
->Get(1, ©_list_element_1
));
514 ASSERT_TRUE(copy_list_element_1
);
515 ASSERT_NE(copy_list_element_1
, original_list_element_1
);
516 int copy_list_element_1_value
;
517 ASSERT_TRUE(copy_list_element_1
->GetAsInteger(©_list_element_1_value
));
518 ASSERT_EQ(1, copy_list_element_1_value
);
521 ASSERT_TRUE(copy_dict
->Get("dictionary", ©_value
));
522 ASSERT_TRUE(copy_value
);
523 ASSERT_NE(copy_value
, original_nested_dictionary
);
524 ASSERT_TRUE(copy_value
->IsType(Value::TYPE_DICTIONARY
));
525 DictionaryValue
* copy_nested_dictionary
= NULL
;
526 ASSERT_TRUE(copy_value
->GetAsDictionary(©_nested_dictionary
));
527 ASSERT_TRUE(copy_nested_dictionary
);
528 EXPECT_TRUE(copy_nested_dictionary
->HasKey("key"));
531 TEST(ValuesTest
, Equals
) {
532 Value
* null1
= Value::CreateNullValue();
533 Value
* null2
= Value::CreateNullValue();
534 EXPECT_NE(null1
, null2
);
535 EXPECT_TRUE(null1
->Equals(null2
));
537 Value
* boolean
= new FundamentalValue(false);
538 EXPECT_FALSE(null1
->Equals(boolean
));
544 dv
.SetBoolean("a", false);
545 dv
.SetInteger("b", 2);
546 dv
.SetDouble("c", 2.5);
547 dv
.SetString("d1", "string");
548 dv
.SetString("d2", ASCIIToUTF16("http://google.com"));
549 dv
.Set("e", make_scoped_ptr(Value::CreateNullValue()));
551 scoped_ptr
<DictionaryValue
> copy
;
552 copy
.reset(dv
.DeepCopy());
553 EXPECT_TRUE(dv
.Equals(copy
.get()));
555 ListValue
* list
= new ListValue
;
556 list
->Append(Value::CreateNullValue());
557 list
->Append(new DictionaryValue
);
558 dv
.Set("f", make_scoped_ptr(list
));
560 EXPECT_FALSE(dv
.Equals(copy
.get()));
561 copy
->Set("f", list
->DeepCopy());
562 EXPECT_TRUE(dv
.Equals(copy
.get()));
564 list
->Append(new FundamentalValue(true));
565 EXPECT_FALSE(dv
.Equals(copy
.get()));
567 // Check if Equals detects differences in only the keys.
568 copy
.reset(dv
.DeepCopy());
569 EXPECT_TRUE(dv
.Equals(copy
.get()));
570 copy
->Remove("a", NULL
);
571 copy
->SetBoolean("aa", false);
572 EXPECT_FALSE(dv
.Equals(copy
.get()));
575 TEST(ValuesTest
, StaticEquals
) {
576 scoped_ptr
<Value
> null1(Value::CreateNullValue());
577 scoped_ptr
<Value
> null2(Value::CreateNullValue());
578 EXPECT_TRUE(Value::Equals(null1
.get(), null2
.get()));
579 EXPECT_TRUE(Value::Equals(NULL
, NULL
));
581 scoped_ptr
<Value
> i42(new FundamentalValue(42));
582 scoped_ptr
<Value
> j42(new FundamentalValue(42));
583 scoped_ptr
<Value
> i17(new FundamentalValue(17));
584 EXPECT_TRUE(Value::Equals(i42
.get(), i42
.get()));
585 EXPECT_TRUE(Value::Equals(j42
.get(), i42
.get()));
586 EXPECT_TRUE(Value::Equals(i42
.get(), j42
.get()));
587 EXPECT_FALSE(Value::Equals(i42
.get(), i17
.get()));
588 EXPECT_FALSE(Value::Equals(i42
.get(), NULL
));
589 EXPECT_FALSE(Value::Equals(NULL
, i42
.get()));
591 // NULL and Value::CreateNullValue() are intentionally different: We need
592 // support for NULL as a return value for "undefined" without caring for
593 // ownership of the pointer.
594 EXPECT_FALSE(Value::Equals(null1
.get(), NULL
));
595 EXPECT_FALSE(Value::Equals(NULL
, null1
.get()));
598 TEST(ValuesTest
, DeepCopyCovariantReturnTypes
) {
599 DictionaryValue original_dict
;
600 Value
* original_null
= Value::CreateNullValue();
601 original_dict
.Set("null", original_null
);
602 FundamentalValue
* original_bool
= new FundamentalValue(true);
603 original_dict
.Set("bool", original_bool
);
604 FundamentalValue
* original_int
= new FundamentalValue(42);
605 original_dict
.Set("int", original_int
);
606 FundamentalValue
* original_double
= new FundamentalValue(3.14);
607 original_dict
.Set("double", original_double
);
608 StringValue
* original_string
= new StringValue("hello");
609 original_dict
.Set("string", original_string
);
610 StringValue
* original_string16
= new StringValue(ASCIIToUTF16("hello16"));
611 original_dict
.Set("string16", original_string16
);
613 scoped_ptr
<char[]> original_buffer(new char[42]);
614 memset(original_buffer
.get(), '!', 42);
615 BinaryValue
* original_binary
= new BinaryValue(original_buffer
.Pass(), 42);
616 original_dict
.Set("binary", original_binary
);
618 ListValue
* original_list
= new ListValue();
619 FundamentalValue
* original_list_element_0
= new FundamentalValue(0);
620 original_list
->Append(original_list_element_0
);
621 FundamentalValue
* original_list_element_1
= new FundamentalValue(1);
622 original_list
->Append(original_list_element_1
);
623 original_dict
.Set("list", original_list
);
625 Value
* original_dict_value
= &original_dict
;
626 Value
* original_bool_value
= original_bool
;
627 Value
* original_int_value
= original_int
;
628 Value
* original_double_value
= original_double
;
629 Value
* original_string_value
= original_string
;
630 Value
* original_string16_value
= original_string16
;
631 Value
* original_binary_value
= original_binary
;
632 Value
* original_list_value
= original_list
;
634 scoped_ptr
<Value
> copy_dict_value(original_dict_value
->DeepCopy());
635 scoped_ptr
<Value
> copy_bool_value(original_bool_value
->DeepCopy());
636 scoped_ptr
<Value
> copy_int_value(original_int_value
->DeepCopy());
637 scoped_ptr
<Value
> copy_double_value(original_double_value
->DeepCopy());
638 scoped_ptr
<Value
> copy_string_value(original_string_value
->DeepCopy());
639 scoped_ptr
<Value
> copy_string16_value(original_string16_value
->DeepCopy());
640 scoped_ptr
<Value
> copy_binary_value(original_binary_value
->DeepCopy());
641 scoped_ptr
<Value
> copy_list_value(original_list_value
->DeepCopy());
643 EXPECT_TRUE(original_dict_value
->Equals(copy_dict_value
.get()));
644 EXPECT_TRUE(original_bool_value
->Equals(copy_bool_value
.get()));
645 EXPECT_TRUE(original_int_value
->Equals(copy_int_value
.get()));
646 EXPECT_TRUE(original_double_value
->Equals(copy_double_value
.get()));
647 EXPECT_TRUE(original_string_value
->Equals(copy_string_value
.get()));
648 EXPECT_TRUE(original_string16_value
->Equals(copy_string16_value
.get()));
649 EXPECT_TRUE(original_binary_value
->Equals(copy_binary_value
.get()));
650 EXPECT_TRUE(original_list_value
->Equals(copy_list_value
.get()));
653 TEST(ValuesTest
, RemoveEmptyChildren
) {
654 scoped_ptr
<DictionaryValue
> root(new DictionaryValue
);
655 // Remove empty lists and dictionaries.
656 root
->Set("empty_dict", make_scoped_ptr(new DictionaryValue
));
657 root
->Set("empty_list", make_scoped_ptr(new ListValue
));
658 root
->SetWithoutPathExpansion("a.b.c.d.e",
659 make_scoped_ptr(new DictionaryValue
));
660 root
.reset(root
->DeepCopyWithoutEmptyChildren());
661 EXPECT_TRUE(root
->empty());
663 // Make sure we don't prune too much.
664 root
->SetBoolean("bool", true);
665 root
->Set("empty_dict", new DictionaryValue
);
666 root
->SetString("empty_string", std::string());
667 root
.reset(root
->DeepCopyWithoutEmptyChildren());
668 EXPECT_EQ(2U, root
->size());
670 // Should do nothing.
671 root
.reset(root
->DeepCopyWithoutEmptyChildren());
672 EXPECT_EQ(2U, root
->size());
674 // Nested test cases. These should all reduce back to the bool and string
677 root
->Set("a.b.c.d.e", new DictionaryValue
);
678 root
.reset(root
->DeepCopyWithoutEmptyChildren());
679 EXPECT_EQ(2U, root
->size());
682 DictionaryValue
* inner
= new DictionaryValue
;
683 root
->Set("dict_with_emtpy_children", inner
);
684 inner
->Set("empty_dict", new DictionaryValue
);
685 inner
->Set("empty_list", new ListValue
);
686 root
.reset(root
->DeepCopyWithoutEmptyChildren());
687 EXPECT_EQ(2U, root
->size());
690 ListValue
* inner
= new ListValue
;
691 root
->Set("list_with_empty_children", inner
);
692 inner
->Append(new DictionaryValue
);
693 inner
->Append(new ListValue
);
694 root
.reset(root
->DeepCopyWithoutEmptyChildren());
695 EXPECT_EQ(2U, root
->size());
698 // Nested with siblings.
700 ListValue
* inner
= new ListValue
;
701 root
->Set("list_with_empty_children", inner
);
702 inner
->Append(new DictionaryValue
);
703 inner
->Append(new ListValue
);
704 DictionaryValue
* inner2
= new DictionaryValue
;
705 root
->Set("dict_with_empty_children", inner2
);
706 inner2
->Set("empty_dict", new DictionaryValue
);
707 inner2
->Set("empty_list", new ListValue
);
708 root
.reset(root
->DeepCopyWithoutEmptyChildren());
709 EXPECT_EQ(2U, root
->size());
712 // Make sure nested values don't get pruned.
714 ListValue
* inner
= new ListValue
;
715 root
->Set("list_with_empty_children", inner
);
716 ListValue
* inner2
= new ListValue
;
717 inner
->Append(new DictionaryValue
);
718 inner
->Append(inner2
);
719 inner2
->Append(new StringValue("hello"));
720 root
.reset(root
->DeepCopyWithoutEmptyChildren());
721 EXPECT_EQ(3U, root
->size());
722 EXPECT_TRUE(root
->GetList("list_with_empty_children", &inner
));
723 EXPECT_EQ(1U, inner
->GetSize()); // Dictionary was pruned.
724 EXPECT_TRUE(inner
->GetList(0, &inner2
));
725 EXPECT_EQ(1U, inner2
->GetSize());
729 TEST(ValuesTest
, MergeDictionary
) {
730 scoped_ptr
<DictionaryValue
> base(new DictionaryValue
);
731 base
->SetString("base_key", "base_key_value_base");
732 base
->SetString("collide_key", "collide_key_value_base");
733 DictionaryValue
* base_sub_dict
= new DictionaryValue
;
734 base_sub_dict
->SetString("sub_base_key", "sub_base_key_value_base");
735 base_sub_dict
->SetString("sub_collide_key", "sub_collide_key_value_base");
736 base
->Set("sub_dict_key", base_sub_dict
);
738 scoped_ptr
<DictionaryValue
> merge(new DictionaryValue
);
739 merge
->SetString("merge_key", "merge_key_value_merge");
740 merge
->SetString("collide_key", "collide_key_value_merge");
741 DictionaryValue
* merge_sub_dict
= new DictionaryValue
;
742 merge_sub_dict
->SetString("sub_merge_key", "sub_merge_key_value_merge");
743 merge_sub_dict
->SetString("sub_collide_key", "sub_collide_key_value_merge");
744 merge
->Set("sub_dict_key", merge_sub_dict
);
746 base
->MergeDictionary(merge
.get());
748 EXPECT_EQ(4U, base
->size());
749 std::string base_key_value
;
750 EXPECT_TRUE(base
->GetString("base_key", &base_key_value
));
751 EXPECT_EQ("base_key_value_base", base_key_value
); // Base value preserved.
752 std::string collide_key_value
;
753 EXPECT_TRUE(base
->GetString("collide_key", &collide_key_value
));
754 EXPECT_EQ("collide_key_value_merge", collide_key_value
); // Replaced.
755 std::string merge_key_value
;
756 EXPECT_TRUE(base
->GetString("merge_key", &merge_key_value
));
757 EXPECT_EQ("merge_key_value_merge", merge_key_value
); // Merged in.
759 DictionaryValue
* res_sub_dict
;
760 EXPECT_TRUE(base
->GetDictionary("sub_dict_key", &res_sub_dict
));
761 EXPECT_EQ(3U, res_sub_dict
->size());
762 std::string sub_base_key_value
;
763 EXPECT_TRUE(res_sub_dict
->GetString("sub_base_key", &sub_base_key_value
));
764 EXPECT_EQ("sub_base_key_value_base", sub_base_key_value
); // Preserved.
765 std::string sub_collide_key_value
;
766 EXPECT_TRUE(res_sub_dict
->GetString("sub_collide_key",
767 &sub_collide_key_value
));
768 EXPECT_EQ("sub_collide_key_value_merge", sub_collide_key_value
); // Replaced.
769 std::string sub_merge_key_value
;
770 EXPECT_TRUE(res_sub_dict
->GetString("sub_merge_key", &sub_merge_key_value
));
771 EXPECT_EQ("sub_merge_key_value_merge", sub_merge_key_value
); // Merged in.
774 TEST(ValuesTest
, MergeDictionaryDeepCopy
) {
775 DictionaryValue
* child
= new DictionaryValue
;
776 child
->SetString("test", "value");
777 EXPECT_EQ(1U, child
->size());
780 EXPECT_TRUE(child
->GetString("test", &value
));
781 EXPECT_EQ("value", value
);
783 scoped_ptr
<DictionaryValue
> base(new DictionaryValue
);
784 base
->Set("dict", child
);
785 EXPECT_EQ(1U, base
->size());
787 DictionaryValue
* ptr
;
788 EXPECT_TRUE(base
->GetDictionary("dict", &ptr
));
789 EXPECT_EQ(child
, ptr
);
791 scoped_ptr
<DictionaryValue
> merged(new DictionaryValue
);
792 merged
->MergeDictionary(base
.get());
793 EXPECT_EQ(1U, merged
->size());
794 EXPECT_TRUE(merged
->GetDictionary("dict", &ptr
));
795 EXPECT_NE(child
, ptr
);
796 EXPECT_TRUE(ptr
->GetString("test", &value
));
797 EXPECT_EQ("value", value
);
799 child
->SetString("test", "overwrite");
801 EXPECT_TRUE(ptr
->GetString("test", &value
));
802 EXPECT_EQ("value", value
);
805 TEST(ValuesTest
, DictionaryIterator
) {
806 DictionaryValue dict
;
807 for (DictionaryValue::Iterator
it(dict
); !it
.IsAtEnd(); it
.Advance()) {
811 StringValue
value1("value1");
812 dict
.Set("key1", value1
.DeepCopy());
814 for (DictionaryValue::Iterator
it(dict
); !it
.IsAtEnd(); it
.Advance()) {
816 EXPECT_EQ("key1", it
.key());
817 EXPECT_TRUE(value1
.Equals(&it
.value()));
822 StringValue
value2("value2");
823 dict
.Set("key2", value2
.DeepCopy());
824 bool seen2
= seen1
= false;
825 for (DictionaryValue::Iterator
it(dict
); !it
.IsAtEnd(); it
.Advance()) {
826 if (it
.key() == "key1") {
828 EXPECT_TRUE(value1
.Equals(&it
.value()));
830 } else if (it
.key() == "key2") {
832 EXPECT_TRUE(value2
.Equals(&it
.value()));
842 // DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value
843 // and still return true/false based on success.
844 TEST(ValuesTest
, GetWithNullOutValue
) {
845 DictionaryValue main_dict
;
848 FundamentalValue
bool_value(false);
849 FundamentalValue
int_value(1234);
850 FundamentalValue
double_value(12.34567);
851 StringValue
string_value("foo");
852 BinaryValue binary_value
;
853 DictionaryValue dict_value
;
854 ListValue list_value
;
856 main_dict
.Set("bool", bool_value
.DeepCopy());
857 main_dict
.Set("int", int_value
.DeepCopy());
858 main_dict
.Set("double", double_value
.DeepCopy());
859 main_dict
.Set("string", string_value
.DeepCopy());
860 main_dict
.Set("binary", binary_value
.DeepCopy());
861 main_dict
.Set("dict", dict_value
.DeepCopy());
862 main_dict
.Set("list", list_value
.DeepCopy());
864 main_list
.Append(bool_value
.DeepCopy());
865 main_list
.Append(int_value
.DeepCopy());
866 main_list
.Append(double_value
.DeepCopy());
867 main_list
.Append(string_value
.DeepCopy());
868 main_list
.Append(binary_value
.DeepCopy());
869 main_list
.Append(dict_value
.DeepCopy());
870 main_list
.Append(list_value
.DeepCopy());
872 EXPECT_TRUE(main_dict
.Get("bool", NULL
));
873 EXPECT_TRUE(main_dict
.Get("int", NULL
));
874 EXPECT_TRUE(main_dict
.Get("double", NULL
));
875 EXPECT_TRUE(main_dict
.Get("string", NULL
));
876 EXPECT_TRUE(main_dict
.Get("binary", NULL
));
877 EXPECT_TRUE(main_dict
.Get("dict", NULL
));
878 EXPECT_TRUE(main_dict
.Get("list", NULL
));
879 EXPECT_FALSE(main_dict
.Get("DNE", NULL
));
881 EXPECT_TRUE(main_dict
.GetBoolean("bool", NULL
));
882 EXPECT_FALSE(main_dict
.GetBoolean("int", NULL
));
883 EXPECT_FALSE(main_dict
.GetBoolean("double", NULL
));
884 EXPECT_FALSE(main_dict
.GetBoolean("string", NULL
));
885 EXPECT_FALSE(main_dict
.GetBoolean("binary", NULL
));
886 EXPECT_FALSE(main_dict
.GetBoolean("dict", NULL
));
887 EXPECT_FALSE(main_dict
.GetBoolean("list", NULL
));
888 EXPECT_FALSE(main_dict
.GetBoolean("DNE", NULL
));
890 EXPECT_FALSE(main_dict
.GetInteger("bool", NULL
));
891 EXPECT_TRUE(main_dict
.GetInteger("int", NULL
));
892 EXPECT_FALSE(main_dict
.GetInteger("double", NULL
));
893 EXPECT_FALSE(main_dict
.GetInteger("string", NULL
));
894 EXPECT_FALSE(main_dict
.GetInteger("binary", NULL
));
895 EXPECT_FALSE(main_dict
.GetInteger("dict", NULL
));
896 EXPECT_FALSE(main_dict
.GetInteger("list", NULL
));
897 EXPECT_FALSE(main_dict
.GetInteger("DNE", NULL
));
899 // Both int and double values can be obtained from GetDouble.
900 EXPECT_FALSE(main_dict
.GetDouble("bool", NULL
));
901 EXPECT_TRUE(main_dict
.GetDouble("int", NULL
));
902 EXPECT_TRUE(main_dict
.GetDouble("double", NULL
));
903 EXPECT_FALSE(main_dict
.GetDouble("string", NULL
));
904 EXPECT_FALSE(main_dict
.GetDouble("binary", NULL
));
905 EXPECT_FALSE(main_dict
.GetDouble("dict", NULL
));
906 EXPECT_FALSE(main_dict
.GetDouble("list", NULL
));
907 EXPECT_FALSE(main_dict
.GetDouble("DNE", NULL
));
909 EXPECT_FALSE(main_dict
.GetString("bool", static_cast<std::string
*>(NULL
)));
910 EXPECT_FALSE(main_dict
.GetString("int", static_cast<std::string
*>(NULL
)));
911 EXPECT_FALSE(main_dict
.GetString("double", static_cast<std::string
*>(NULL
)));
912 EXPECT_TRUE(main_dict
.GetString("string", static_cast<std::string
*>(NULL
)));
913 EXPECT_FALSE(main_dict
.GetString("binary", static_cast<std::string
*>(NULL
)));
914 EXPECT_FALSE(main_dict
.GetString("dict", static_cast<std::string
*>(NULL
)));
915 EXPECT_FALSE(main_dict
.GetString("list", static_cast<std::string
*>(NULL
)));
916 EXPECT_FALSE(main_dict
.GetString("DNE", static_cast<std::string
*>(NULL
)));
918 EXPECT_FALSE(main_dict
.GetString("bool", static_cast<string16
*>(NULL
)));
919 EXPECT_FALSE(main_dict
.GetString("int", static_cast<string16
*>(NULL
)));
920 EXPECT_FALSE(main_dict
.GetString("double", static_cast<string16
*>(NULL
)));
921 EXPECT_TRUE(main_dict
.GetString("string", static_cast<string16
*>(NULL
)));
922 EXPECT_FALSE(main_dict
.GetString("binary", static_cast<string16
*>(NULL
)));
923 EXPECT_FALSE(main_dict
.GetString("dict", static_cast<string16
*>(NULL
)));
924 EXPECT_FALSE(main_dict
.GetString("list", static_cast<string16
*>(NULL
)));
925 EXPECT_FALSE(main_dict
.GetString("DNE", static_cast<string16
*>(NULL
)));
927 EXPECT_FALSE(main_dict
.GetBinary("bool", NULL
));
928 EXPECT_FALSE(main_dict
.GetBinary("int", NULL
));
929 EXPECT_FALSE(main_dict
.GetBinary("double", NULL
));
930 EXPECT_FALSE(main_dict
.GetBinary("string", NULL
));
931 EXPECT_TRUE(main_dict
.GetBinary("binary", NULL
));
932 EXPECT_FALSE(main_dict
.GetBinary("dict", NULL
));
933 EXPECT_FALSE(main_dict
.GetBinary("list", NULL
));
934 EXPECT_FALSE(main_dict
.GetBinary("DNE", NULL
));
936 EXPECT_FALSE(main_dict
.GetDictionary("bool", NULL
));
937 EXPECT_FALSE(main_dict
.GetDictionary("int", NULL
));
938 EXPECT_FALSE(main_dict
.GetDictionary("double", NULL
));
939 EXPECT_FALSE(main_dict
.GetDictionary("string", NULL
));
940 EXPECT_FALSE(main_dict
.GetDictionary("binary", NULL
));
941 EXPECT_TRUE(main_dict
.GetDictionary("dict", NULL
));
942 EXPECT_FALSE(main_dict
.GetDictionary("list", NULL
));
943 EXPECT_FALSE(main_dict
.GetDictionary("DNE", NULL
));
945 EXPECT_FALSE(main_dict
.GetList("bool", NULL
));
946 EXPECT_FALSE(main_dict
.GetList("int", NULL
));
947 EXPECT_FALSE(main_dict
.GetList("double", NULL
));
948 EXPECT_FALSE(main_dict
.GetList("string", NULL
));
949 EXPECT_FALSE(main_dict
.GetList("binary", NULL
));
950 EXPECT_FALSE(main_dict
.GetList("dict", NULL
));
951 EXPECT_TRUE(main_dict
.GetList("list", NULL
));
952 EXPECT_FALSE(main_dict
.GetList("DNE", NULL
));
954 EXPECT_TRUE(main_dict
.GetWithoutPathExpansion("bool", NULL
));
955 EXPECT_TRUE(main_dict
.GetWithoutPathExpansion("int", NULL
));
956 EXPECT_TRUE(main_dict
.GetWithoutPathExpansion("double", NULL
));
957 EXPECT_TRUE(main_dict
.GetWithoutPathExpansion("string", NULL
));
958 EXPECT_TRUE(main_dict
.GetWithoutPathExpansion("binary", NULL
));
959 EXPECT_TRUE(main_dict
.GetWithoutPathExpansion("dict", NULL
));
960 EXPECT_TRUE(main_dict
.GetWithoutPathExpansion("list", NULL
));
961 EXPECT_FALSE(main_dict
.GetWithoutPathExpansion("DNE", NULL
));
963 EXPECT_TRUE(main_dict
.GetBooleanWithoutPathExpansion("bool", NULL
));
964 EXPECT_FALSE(main_dict
.GetBooleanWithoutPathExpansion("int", NULL
));
965 EXPECT_FALSE(main_dict
.GetBooleanWithoutPathExpansion("double", NULL
));
966 EXPECT_FALSE(main_dict
.GetBooleanWithoutPathExpansion("string", NULL
));
967 EXPECT_FALSE(main_dict
.GetBooleanWithoutPathExpansion("binary", NULL
));
968 EXPECT_FALSE(main_dict
.GetBooleanWithoutPathExpansion("dict", NULL
));
969 EXPECT_FALSE(main_dict
.GetBooleanWithoutPathExpansion("list", NULL
));
970 EXPECT_FALSE(main_dict
.GetBooleanWithoutPathExpansion("DNE", NULL
));
972 EXPECT_FALSE(main_dict
.GetIntegerWithoutPathExpansion("bool", NULL
));
973 EXPECT_TRUE(main_dict
.GetIntegerWithoutPathExpansion("int", NULL
));
974 EXPECT_FALSE(main_dict
.GetIntegerWithoutPathExpansion("double", NULL
));
975 EXPECT_FALSE(main_dict
.GetIntegerWithoutPathExpansion("string", NULL
));
976 EXPECT_FALSE(main_dict
.GetIntegerWithoutPathExpansion("binary", NULL
));
977 EXPECT_FALSE(main_dict
.GetIntegerWithoutPathExpansion("dict", NULL
));
978 EXPECT_FALSE(main_dict
.GetIntegerWithoutPathExpansion("list", NULL
));
979 EXPECT_FALSE(main_dict
.GetIntegerWithoutPathExpansion("DNE", NULL
));
981 EXPECT_FALSE(main_dict
.GetDoubleWithoutPathExpansion("bool", NULL
));
982 EXPECT_TRUE(main_dict
.GetDoubleWithoutPathExpansion("int", NULL
));
983 EXPECT_TRUE(main_dict
.GetDoubleWithoutPathExpansion("double", NULL
));
984 EXPECT_FALSE(main_dict
.GetDoubleWithoutPathExpansion("string", NULL
));
985 EXPECT_FALSE(main_dict
.GetDoubleWithoutPathExpansion("binary", NULL
));
986 EXPECT_FALSE(main_dict
.GetDoubleWithoutPathExpansion("dict", NULL
));
987 EXPECT_FALSE(main_dict
.GetDoubleWithoutPathExpansion("list", NULL
));
988 EXPECT_FALSE(main_dict
.GetDoubleWithoutPathExpansion("DNE", NULL
));
990 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
991 "bool", static_cast<std::string
*>(NULL
)));
992 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
993 "int", static_cast<std::string
*>(NULL
)));
994 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
995 "double", static_cast<std::string
*>(NULL
)));
996 EXPECT_TRUE(main_dict
.GetStringWithoutPathExpansion(
997 "string", static_cast<std::string
*>(NULL
)));
998 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
999 "binary", static_cast<std::string
*>(NULL
)));
1000 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
1001 "dict", static_cast<std::string
*>(NULL
)));
1002 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
1003 "list", static_cast<std::string
*>(NULL
)));
1004 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
1005 "DNE", static_cast<std::string
*>(NULL
)));
1007 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
1008 "bool", static_cast<string16
*>(NULL
)));
1009 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
1010 "int", static_cast<string16
*>(NULL
)));
1011 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
1012 "double", static_cast<string16
*>(NULL
)));
1013 EXPECT_TRUE(main_dict
.GetStringWithoutPathExpansion(
1014 "string", static_cast<string16
*>(NULL
)));
1015 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
1016 "binary", static_cast<string16
*>(NULL
)));
1017 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
1018 "dict", static_cast<string16
*>(NULL
)));
1019 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
1020 "list", static_cast<string16
*>(NULL
)));
1021 EXPECT_FALSE(main_dict
.GetStringWithoutPathExpansion(
1022 "DNE", static_cast<string16
*>(NULL
)));
1024 // There is no GetBinaryWithoutPathExpansion for some reason, but if there
1025 // were it should be tested here...
1027 EXPECT_FALSE(main_dict
.GetDictionaryWithoutPathExpansion("bool", NULL
));
1028 EXPECT_FALSE(main_dict
.GetDictionaryWithoutPathExpansion("int", NULL
));
1029 EXPECT_FALSE(main_dict
.GetDictionaryWithoutPathExpansion("double", NULL
));
1030 EXPECT_FALSE(main_dict
.GetDictionaryWithoutPathExpansion("string", NULL
));
1031 EXPECT_FALSE(main_dict
.GetDictionaryWithoutPathExpansion("binary", NULL
));
1032 EXPECT_TRUE(main_dict
.GetDictionaryWithoutPathExpansion("dict", NULL
));
1033 EXPECT_FALSE(main_dict
.GetDictionaryWithoutPathExpansion("list", NULL
));
1034 EXPECT_FALSE(main_dict
.GetDictionaryWithoutPathExpansion("DNE", NULL
));
1036 EXPECT_FALSE(main_dict
.GetListWithoutPathExpansion("bool", NULL
));
1037 EXPECT_FALSE(main_dict
.GetListWithoutPathExpansion("int", NULL
));
1038 EXPECT_FALSE(main_dict
.GetListWithoutPathExpansion("double", NULL
));
1039 EXPECT_FALSE(main_dict
.GetListWithoutPathExpansion("string", NULL
));
1040 EXPECT_FALSE(main_dict
.GetListWithoutPathExpansion("binary", NULL
));
1041 EXPECT_FALSE(main_dict
.GetListWithoutPathExpansion("dict", NULL
));
1042 EXPECT_TRUE(main_dict
.GetListWithoutPathExpansion("list", NULL
));
1043 EXPECT_FALSE(main_dict
.GetListWithoutPathExpansion("DNE", NULL
));
1045 EXPECT_TRUE(main_list
.Get(0, NULL
));
1046 EXPECT_TRUE(main_list
.Get(1, NULL
));
1047 EXPECT_TRUE(main_list
.Get(2, NULL
));
1048 EXPECT_TRUE(main_list
.Get(3, NULL
));
1049 EXPECT_TRUE(main_list
.Get(4, NULL
));
1050 EXPECT_TRUE(main_list
.Get(5, NULL
));
1051 EXPECT_TRUE(main_list
.Get(6, NULL
));
1052 EXPECT_FALSE(main_list
.Get(7, NULL
));
1054 EXPECT_TRUE(main_list
.GetBoolean(0, NULL
));
1055 EXPECT_FALSE(main_list
.GetBoolean(1, NULL
));
1056 EXPECT_FALSE(main_list
.GetBoolean(2, NULL
));
1057 EXPECT_FALSE(main_list
.GetBoolean(3, NULL
));
1058 EXPECT_FALSE(main_list
.GetBoolean(4, NULL
));
1059 EXPECT_FALSE(main_list
.GetBoolean(5, NULL
));
1060 EXPECT_FALSE(main_list
.GetBoolean(6, NULL
));
1061 EXPECT_FALSE(main_list
.GetBoolean(7, NULL
));
1063 EXPECT_FALSE(main_list
.GetInteger(0, NULL
));
1064 EXPECT_TRUE(main_list
.GetInteger(1, NULL
));
1065 EXPECT_FALSE(main_list
.GetInteger(2, NULL
));
1066 EXPECT_FALSE(main_list
.GetInteger(3, NULL
));
1067 EXPECT_FALSE(main_list
.GetInteger(4, NULL
));
1068 EXPECT_FALSE(main_list
.GetInteger(5, NULL
));
1069 EXPECT_FALSE(main_list
.GetInteger(6, NULL
));
1070 EXPECT_FALSE(main_list
.GetInteger(7, NULL
));
1072 EXPECT_FALSE(main_list
.GetDouble(0, NULL
));
1073 EXPECT_TRUE(main_list
.GetDouble(1, NULL
));
1074 EXPECT_TRUE(main_list
.GetDouble(2, NULL
));
1075 EXPECT_FALSE(main_list
.GetDouble(3, NULL
));
1076 EXPECT_FALSE(main_list
.GetDouble(4, NULL
));
1077 EXPECT_FALSE(main_list
.GetDouble(5, NULL
));
1078 EXPECT_FALSE(main_list
.GetDouble(6, NULL
));
1079 EXPECT_FALSE(main_list
.GetDouble(7, NULL
));
1081 EXPECT_FALSE(main_list
.GetString(0, static_cast<std::string
*>(NULL
)));
1082 EXPECT_FALSE(main_list
.GetString(1, static_cast<std::string
*>(NULL
)));
1083 EXPECT_FALSE(main_list
.GetString(2, static_cast<std::string
*>(NULL
)));
1084 EXPECT_TRUE(main_list
.GetString(3, static_cast<std::string
*>(NULL
)));
1085 EXPECT_FALSE(main_list
.GetString(4, static_cast<std::string
*>(NULL
)));
1086 EXPECT_FALSE(main_list
.GetString(5, static_cast<std::string
*>(NULL
)));
1087 EXPECT_FALSE(main_list
.GetString(6, static_cast<std::string
*>(NULL
)));
1088 EXPECT_FALSE(main_list
.GetString(7, static_cast<std::string
*>(NULL
)));
1090 EXPECT_FALSE(main_list
.GetString(0, static_cast<string16
*>(NULL
)));
1091 EXPECT_FALSE(main_list
.GetString(1, static_cast<string16
*>(NULL
)));
1092 EXPECT_FALSE(main_list
.GetString(2, static_cast<string16
*>(NULL
)));
1093 EXPECT_TRUE(main_list
.GetString(3, static_cast<string16
*>(NULL
)));
1094 EXPECT_FALSE(main_list
.GetString(4, static_cast<string16
*>(NULL
)));
1095 EXPECT_FALSE(main_list
.GetString(5, static_cast<string16
*>(NULL
)));
1096 EXPECT_FALSE(main_list
.GetString(6, static_cast<string16
*>(NULL
)));
1097 EXPECT_FALSE(main_list
.GetString(7, static_cast<string16
*>(NULL
)));
1099 EXPECT_FALSE(main_list
.GetBinary(0, NULL
));
1100 EXPECT_FALSE(main_list
.GetBinary(1, NULL
));
1101 EXPECT_FALSE(main_list
.GetBinary(2, NULL
));
1102 EXPECT_FALSE(main_list
.GetBinary(3, NULL
));
1103 EXPECT_TRUE(main_list
.GetBinary(4, NULL
));
1104 EXPECT_FALSE(main_list
.GetBinary(5, NULL
));
1105 EXPECT_FALSE(main_list
.GetBinary(6, NULL
));
1106 EXPECT_FALSE(main_list
.GetBinary(7, NULL
));
1108 EXPECT_FALSE(main_list
.GetDictionary(0, NULL
));
1109 EXPECT_FALSE(main_list
.GetDictionary(1, NULL
));
1110 EXPECT_FALSE(main_list
.GetDictionary(2, NULL
));
1111 EXPECT_FALSE(main_list
.GetDictionary(3, NULL
));
1112 EXPECT_FALSE(main_list
.GetDictionary(4, NULL
));
1113 EXPECT_TRUE(main_list
.GetDictionary(5, NULL
));
1114 EXPECT_FALSE(main_list
.GetDictionary(6, NULL
));
1115 EXPECT_FALSE(main_list
.GetDictionary(7, NULL
));
1117 EXPECT_FALSE(main_list
.GetList(0, NULL
));
1118 EXPECT_FALSE(main_list
.GetList(1, NULL
));
1119 EXPECT_FALSE(main_list
.GetList(2, NULL
));
1120 EXPECT_FALSE(main_list
.GetList(3, NULL
));
1121 EXPECT_FALSE(main_list
.GetList(4, NULL
));
1122 EXPECT_FALSE(main_list
.GetList(5, NULL
));
1123 EXPECT_TRUE(main_list
.GetList(6, NULL
));
1124 EXPECT_FALSE(main_list
.GetList(7, NULL
));