1 // Copyright (c) 2011 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/string16.h"
9 #include "base/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", Value::CreateBooleanValue(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, Value::CreateBooleanValue(true));
61 mixed_list
->Set(1, Value::CreateIntegerValue(42));
62 mixed_list
->Set(2, Value::CreateDoubleValue(88.8));
63 mixed_list
->Set(3, Value::CreateStringValue("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 scoped_ptr
<Value
> sought_value(Value::CreateIntegerValue(42));
99 scoped_ptr
<Value
> not_found_value(Value::CreateBooleanValue(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
) {
109 // Passing a null buffer pointer doesn't yield a BinaryValue
110 scoped_ptr
<BinaryValue
> binary(BinaryValue::Create(buffer
, 0));
111 ASSERT_FALSE(binary
.get());
113 // If you want to represent an empty binary value, use a zero-length buffer.
114 buffer
= new char[1];
116 binary
.reset(BinaryValue::Create(buffer
, 0));
117 ASSERT_TRUE(binary
.get());
118 ASSERT_TRUE(binary
->GetBuffer());
119 ASSERT_EQ(buffer
, binary
->GetBuffer());
120 ASSERT_EQ(0U, binary
->GetSize());
122 // Test the common case of a non-empty buffer
123 buffer
= new char[15];
124 binary
.reset(BinaryValue::Create(buffer
, 15));
125 ASSERT_TRUE(binary
.get());
126 ASSERT_TRUE(binary
->GetBuffer());
127 ASSERT_EQ(buffer
, binary
->GetBuffer());
128 ASSERT_EQ(15U, binary
->GetSize());
130 char stack_buffer
[42];
131 memset(stack_buffer
, '!', 42);
132 binary
.reset(BinaryValue::CreateWithCopiedBuffer(stack_buffer
, 42));
133 ASSERT_TRUE(binary
.get());
134 ASSERT_TRUE(binary
->GetBuffer());
135 ASSERT_NE(stack_buffer
, binary
->GetBuffer());
136 ASSERT_EQ(42U, binary
->GetSize());
137 ASSERT_EQ(0, memcmp(stack_buffer
, binary
->GetBuffer(), binary
->GetSize()));
140 TEST(ValuesTest
, StringValue
) {
141 // Test overloaded CreateStringValue.
142 scoped_ptr
<Value
> narrow_value(Value::CreateStringValue("narrow"));
143 ASSERT_TRUE(narrow_value
.get());
144 ASSERT_TRUE(narrow_value
->IsType(Value::TYPE_STRING
));
145 scoped_ptr
<Value
> utf16_value(
146 Value::CreateStringValue(ASCIIToUTF16("utf16")));
147 ASSERT_TRUE(utf16_value
.get());
148 ASSERT_TRUE(utf16_value
->IsType(Value::TYPE_STRING
));
150 // Test overloaded GetString.
151 std::string narrow
= "http://google.com";
152 string16 utf16
= ASCIIToUTF16("http://google.com");
153 ASSERT_TRUE(narrow_value
->GetAsString(&narrow
));
154 ASSERT_TRUE(narrow_value
->GetAsString(&utf16
));
155 ASSERT_EQ(std::string("narrow"), narrow
);
156 ASSERT_EQ(ASCIIToUTF16("narrow"), utf16
);
158 ASSERT_TRUE(utf16_value
->GetAsString(&narrow
));
159 ASSERT_TRUE(utf16_value
->GetAsString(&utf16
));
160 ASSERT_EQ(std::string("utf16"), narrow
);
161 ASSERT_EQ(ASCIIToUTF16("utf16"), utf16
);
164 // This is a Value object that allows us to tell if it's been
165 // properly deleted by modifying the value of external flag on destruction.
166 class DeletionTestValue
: public Value
{
168 explicit DeletionTestValue(bool* deletion_flag
) : Value(TYPE_NULL
) {
169 Init(deletion_flag
); // Separate function so that we can use ASSERT_*
172 void Init(bool* deletion_flag
) {
173 ASSERT_TRUE(deletion_flag
);
174 deletion_flag_
= deletion_flag
;
175 *deletion_flag_
= false;
178 ~DeletionTestValue() {
179 *deletion_flag_
= true;
183 bool* deletion_flag_
;
186 TEST(ValuesTest
, ListDeletion
) {
187 bool deletion_flag
= true;
191 list
.Append(new DeletionTestValue(&deletion_flag
));
192 EXPECT_FALSE(deletion_flag
);
194 EXPECT_TRUE(deletion_flag
);
198 list
.Append(new DeletionTestValue(&deletion_flag
));
199 EXPECT_FALSE(deletion_flag
);
201 EXPECT_TRUE(deletion_flag
);
206 list
.Append(new DeletionTestValue(&deletion_flag
));
207 EXPECT_FALSE(deletion_flag
);
208 EXPECT_TRUE(list
.Set(0, Value::CreateNullValue()));
209 EXPECT_TRUE(deletion_flag
);
213 TEST(ValuesTest
, ListRemoval
) {
214 bool deletion_flag
= true;
215 Value
* removed_item
= NULL
;
219 list
.Append(new DeletionTestValue(&deletion_flag
));
220 EXPECT_FALSE(deletion_flag
);
221 EXPECT_EQ(1U, list
.GetSize());
222 EXPECT_FALSE(list
.Remove(std::numeric_limits
<size_t>::max(),
224 EXPECT_FALSE(list
.Remove(1, &removed_item
));
225 EXPECT_TRUE(list
.Remove(0, &removed_item
));
226 ASSERT_TRUE(removed_item
);
227 EXPECT_EQ(0U, list
.GetSize());
229 EXPECT_FALSE(deletion_flag
);
232 EXPECT_TRUE(deletion_flag
);
236 list
.Append(new DeletionTestValue(&deletion_flag
));
237 EXPECT_FALSE(deletion_flag
);
238 EXPECT_TRUE(list
.Remove(0, NULL
));
239 EXPECT_TRUE(deletion_flag
);
240 EXPECT_EQ(0U, list
.GetSize());
245 DeletionTestValue
* value
= new DeletionTestValue(&deletion_flag
);
247 EXPECT_FALSE(deletion_flag
);
249 list
.Remove(*value
, &index
);
250 EXPECT_EQ(0U, index
);
251 EXPECT_TRUE(deletion_flag
);
252 EXPECT_EQ(0U, list
.GetSize());
256 TEST(ValuesTest
, DictionaryDeletion
) {
257 std::string key
= "test";
258 bool deletion_flag
= true;
261 DictionaryValue dict
;
262 dict
.Set(key
, new DeletionTestValue(&deletion_flag
));
263 EXPECT_FALSE(deletion_flag
);
265 EXPECT_TRUE(deletion_flag
);
268 DictionaryValue dict
;
269 dict
.Set(key
, new DeletionTestValue(&deletion_flag
));
270 EXPECT_FALSE(deletion_flag
);
272 EXPECT_TRUE(deletion_flag
);
276 DictionaryValue dict
;
277 dict
.Set(key
, new DeletionTestValue(&deletion_flag
));
278 EXPECT_FALSE(deletion_flag
);
279 dict
.Set(key
, Value::CreateNullValue());
280 EXPECT_TRUE(deletion_flag
);
284 TEST(ValuesTest
, DictionaryRemoval
) {
285 std::string key
= "test";
286 bool deletion_flag
= true;
287 Value
* removed_item
= NULL
;
290 DictionaryValue dict
;
291 dict
.Set(key
, new DeletionTestValue(&deletion_flag
));
292 EXPECT_FALSE(deletion_flag
);
293 EXPECT_TRUE(dict
.HasKey(key
));
294 EXPECT_FALSE(dict
.Remove("absent key", &removed_item
));
295 EXPECT_TRUE(dict
.Remove(key
, &removed_item
));
296 EXPECT_FALSE(dict
.HasKey(key
));
297 ASSERT_TRUE(removed_item
);
299 EXPECT_FALSE(deletion_flag
);
302 EXPECT_TRUE(deletion_flag
);
305 DictionaryValue dict
;
306 dict
.Set(key
, new DeletionTestValue(&deletion_flag
));
307 EXPECT_FALSE(deletion_flag
);
308 EXPECT_TRUE(dict
.HasKey(key
));
309 EXPECT_TRUE(dict
.Remove(key
, NULL
));
310 EXPECT_TRUE(deletion_flag
);
311 EXPECT_FALSE(dict
.HasKey(key
));
315 TEST(ValuesTest
, DictionaryWithoutPathExpansion
) {
316 DictionaryValue dict
;
317 dict
.Set("this.is.expanded", Value::CreateNullValue());
318 dict
.SetWithoutPathExpansion("this.isnt.expanded", Value::CreateNullValue());
320 EXPECT_FALSE(dict
.HasKey("this.is.expanded"));
321 EXPECT_TRUE(dict
.HasKey("this"));
323 EXPECT_TRUE(dict
.Get("this", &value1
));
324 DictionaryValue
* value2
;
325 ASSERT_TRUE(dict
.GetDictionaryWithoutPathExpansion("this", &value2
));
326 EXPECT_EQ(value1
, value2
);
327 EXPECT_EQ(1U, value2
->size());
329 EXPECT_TRUE(dict
.HasKey("this.isnt.expanded"));
331 EXPECT_FALSE(dict
.Get("this.isnt.expanded", &value3
));
333 ASSERT_TRUE(dict
.GetWithoutPathExpansion("this.isnt.expanded", &value4
));
334 EXPECT_EQ(Value::TYPE_NULL
, value4
->GetType());
337 TEST(ValuesTest
, DeepCopy
) {
338 DictionaryValue original_dict
;
339 Value
* original_null
= Value::CreateNullValue();
340 original_dict
.Set("null", original_null
);
341 FundamentalValue
* original_bool
= Value::CreateBooleanValue(true);
342 original_dict
.Set("bool", original_bool
);
343 FundamentalValue
* original_int
= Value::CreateIntegerValue(42);
344 original_dict
.Set("int", original_int
);
345 FundamentalValue
* original_double
= Value::CreateDoubleValue(3.14);
346 original_dict
.Set("double", original_double
);
347 StringValue
* original_string
= Value::CreateStringValue("hello");
348 original_dict
.Set("string", original_string
);
349 StringValue
* original_string16
=
350 Value::CreateStringValue(ASCIIToUTF16("hello16"));
351 original_dict
.Set("string16", original_string16
);
353 char* original_buffer
= new char[42];
354 memset(original_buffer
, '!', 42);
355 BinaryValue
* original_binary
= BinaryValue::Create(original_buffer
, 42);
356 original_dict
.Set("binary", original_binary
);
358 ListValue
* original_list
= new ListValue();
359 FundamentalValue
* original_list_element_0
= Value::CreateIntegerValue(0);
360 original_list
->Append(original_list_element_0
);
361 FundamentalValue
* original_list_element_1
= Value::CreateIntegerValue(1);
362 original_list
->Append(original_list_element_1
);
363 original_dict
.Set("list", original_list
);
365 scoped_ptr
<DictionaryValue
> copy_dict(original_dict
.DeepCopy());
366 ASSERT_TRUE(copy_dict
.get());
367 ASSERT_NE(copy_dict
.get(), &original_dict
);
369 Value
* copy_null
= NULL
;
370 ASSERT_TRUE(copy_dict
->Get("null", ©_null
));
371 ASSERT_TRUE(copy_null
);
372 ASSERT_NE(copy_null
, original_null
);
373 ASSERT_TRUE(copy_null
->IsType(Value::TYPE_NULL
));
375 Value
* copy_bool
= NULL
;
376 ASSERT_TRUE(copy_dict
->Get("bool", ©_bool
));
377 ASSERT_TRUE(copy_bool
);
378 ASSERT_NE(copy_bool
, original_bool
);
379 ASSERT_TRUE(copy_bool
->IsType(Value::TYPE_BOOLEAN
));
380 bool copy_bool_value
= false;
381 ASSERT_TRUE(copy_bool
->GetAsBoolean(©_bool_value
));
382 ASSERT_TRUE(copy_bool_value
);
384 Value
* copy_int
= NULL
;
385 ASSERT_TRUE(copy_dict
->Get("int", ©_int
));
386 ASSERT_TRUE(copy_int
);
387 ASSERT_NE(copy_int
, original_int
);
388 ASSERT_TRUE(copy_int
->IsType(Value::TYPE_INTEGER
));
389 int copy_int_value
= 0;
390 ASSERT_TRUE(copy_int
->GetAsInteger(©_int_value
));
391 ASSERT_EQ(42, copy_int_value
);
393 Value
* copy_double
= NULL
;
394 ASSERT_TRUE(copy_dict
->Get("double", ©_double
));
395 ASSERT_TRUE(copy_double
);
396 ASSERT_NE(copy_double
, original_double
);
397 ASSERT_TRUE(copy_double
->IsType(Value::TYPE_DOUBLE
));
398 double copy_double_value
= 0;
399 ASSERT_TRUE(copy_double
->GetAsDouble(©_double_value
));
400 ASSERT_EQ(3.14, copy_double_value
);
402 Value
* copy_string
= NULL
;
403 ASSERT_TRUE(copy_dict
->Get("string", ©_string
));
404 ASSERT_TRUE(copy_string
);
405 ASSERT_NE(copy_string
, original_string
);
406 ASSERT_TRUE(copy_string
->IsType(Value::TYPE_STRING
));
407 std::string copy_string_value
;
408 string16 copy_string16_value
;
409 ASSERT_TRUE(copy_string
->GetAsString(©_string_value
));
410 ASSERT_TRUE(copy_string
->GetAsString(©_string16_value
));
411 ASSERT_EQ(std::string("hello"), copy_string_value
);
412 ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value
);
414 Value
* copy_string16
= NULL
;
415 ASSERT_TRUE(copy_dict
->Get("string16", ©_string16
));
416 ASSERT_TRUE(copy_string16
);
417 ASSERT_NE(copy_string16
, original_string16
);
418 ASSERT_TRUE(copy_string16
->IsType(Value::TYPE_STRING
));
419 ASSERT_TRUE(copy_string16
->GetAsString(©_string_value
));
420 ASSERT_TRUE(copy_string16
->GetAsString(©_string16_value
));
421 ASSERT_EQ(std::string("hello16"), copy_string_value
);
422 ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value
);
424 Value
* copy_binary
= NULL
;
425 ASSERT_TRUE(copy_dict
->Get("binary", ©_binary
));
426 ASSERT_TRUE(copy_binary
);
427 ASSERT_NE(copy_binary
, original_binary
);
428 ASSERT_TRUE(copy_binary
->IsType(Value::TYPE_BINARY
));
429 ASSERT_NE(original_binary
->GetBuffer(),
430 static_cast<BinaryValue
*>(copy_binary
)->GetBuffer());
431 ASSERT_EQ(original_binary
->GetSize(),
432 static_cast<BinaryValue
*>(copy_binary
)->GetSize());
433 ASSERT_EQ(0, memcmp(original_binary
->GetBuffer(),
434 static_cast<BinaryValue
*>(copy_binary
)->GetBuffer(),
435 original_binary
->GetSize()));
437 Value
* copy_value
= NULL
;
438 ASSERT_TRUE(copy_dict
->Get("list", ©_value
));
439 ASSERT_TRUE(copy_value
);
440 ASSERT_NE(copy_value
, original_list
);
441 ASSERT_TRUE(copy_value
->IsType(Value::TYPE_LIST
));
442 ListValue
* copy_list
= static_cast<ListValue
*>(copy_value
);
443 ASSERT_EQ(2U, copy_list
->GetSize());
445 Value
* copy_list_element_0
;
446 ASSERT_TRUE(copy_list
->Get(0, ©_list_element_0
));
447 ASSERT_TRUE(copy_list_element_0
);
448 ASSERT_NE(copy_list_element_0
, original_list_element_0
);
449 int copy_list_element_0_value
;
450 ASSERT_TRUE(copy_list_element_0
->GetAsInteger(©_list_element_0_value
));
451 ASSERT_EQ(0, copy_list_element_0_value
);
453 Value
* copy_list_element_1
;
454 ASSERT_TRUE(copy_list
->Get(1, ©_list_element_1
));
455 ASSERT_TRUE(copy_list_element_1
);
456 ASSERT_NE(copy_list_element_1
, original_list_element_1
);
457 int copy_list_element_1_value
;
458 ASSERT_TRUE(copy_list_element_1
->GetAsInteger(©_list_element_1_value
));
459 ASSERT_EQ(1, copy_list_element_1_value
);
462 TEST(ValuesTest
, Equals
) {
463 Value
* null1
= Value::CreateNullValue();
464 Value
* null2
= Value::CreateNullValue();
465 EXPECT_NE(null1
, null2
);
466 EXPECT_TRUE(null1
->Equals(null2
));
468 Value
* boolean
= Value::CreateBooleanValue(false);
469 EXPECT_FALSE(null1
->Equals(boolean
));
475 dv
.SetBoolean("a", false);
476 dv
.SetInteger("b", 2);
477 dv
.SetDouble("c", 2.5);
478 dv
.SetString("d1", "string");
479 dv
.SetString("d2", ASCIIToUTF16("http://google.com"));
480 dv
.Set("e", Value::CreateNullValue());
482 scoped_ptr
<DictionaryValue
> copy
;
483 copy
.reset(dv
.DeepCopy());
484 EXPECT_TRUE(dv
.Equals(copy
.get()));
486 ListValue
* list
= new ListValue
;
487 list
->Append(Value::CreateNullValue());
488 list
->Append(new DictionaryValue
);
491 EXPECT_FALSE(dv
.Equals(copy
.get()));
492 copy
->Set("f", list
->DeepCopy());
493 EXPECT_TRUE(dv
.Equals(copy
.get()));
495 list
->Append(Value::CreateBooleanValue(true));
496 EXPECT_FALSE(dv
.Equals(copy
.get()));
498 // Check if Equals detects differences in only the keys.
499 copy
.reset(dv
.DeepCopy());
500 EXPECT_TRUE(dv
.Equals(copy
.get()));
501 copy
->Remove("a", NULL
);
502 copy
->SetBoolean("aa", false);
503 EXPECT_FALSE(dv
.Equals(copy
.get()));
506 TEST(ValuesTest
, StaticEquals
) {
507 scoped_ptr
<Value
> null1(Value::CreateNullValue());
508 scoped_ptr
<Value
> null2(Value::CreateNullValue());
509 EXPECT_TRUE(Value::Equals(null1
.get(), null2
.get()));
510 EXPECT_TRUE(Value::Equals(NULL
, NULL
));
512 scoped_ptr
<Value
> i42(Value::CreateIntegerValue(42));
513 scoped_ptr
<Value
> j42(Value::CreateIntegerValue(42));
514 scoped_ptr
<Value
> i17(Value::CreateIntegerValue(17));
515 EXPECT_TRUE(Value::Equals(i42
.get(), i42
.get()));
516 EXPECT_TRUE(Value::Equals(j42
.get(), i42
.get()));
517 EXPECT_TRUE(Value::Equals(i42
.get(), j42
.get()));
518 EXPECT_FALSE(Value::Equals(i42
.get(), i17
.get()));
519 EXPECT_FALSE(Value::Equals(i42
.get(), NULL
));
520 EXPECT_FALSE(Value::Equals(NULL
, i42
.get()));
522 // NULL and Value::CreateNullValue() are intentionally different: We need
523 // support for NULL as a return value for "undefined" without caring for
524 // ownership of the pointer.
525 EXPECT_FALSE(Value::Equals(null1
.get(), NULL
));
526 EXPECT_FALSE(Value::Equals(NULL
, null1
.get()));
529 TEST(ValuesTest
, DeepCopyCovariantReturnTypes
) {
530 DictionaryValue original_dict
;
531 Value
* original_null
= Value::CreateNullValue();
532 original_dict
.Set("null", original_null
);
533 FundamentalValue
* original_bool
= Value::CreateBooleanValue(true);
534 original_dict
.Set("bool", original_bool
);
535 FundamentalValue
* original_int
= Value::CreateIntegerValue(42);
536 original_dict
.Set("int", original_int
);
537 FundamentalValue
* original_double
= Value::CreateDoubleValue(3.14);
538 original_dict
.Set("double", original_double
);
539 StringValue
* original_string
= Value::CreateStringValue("hello");
540 original_dict
.Set("string", original_string
);
541 StringValue
* original_string16
=
542 Value::CreateStringValue(ASCIIToUTF16("hello16"));
543 original_dict
.Set("string16", original_string16
);
545 char* original_buffer
= new char[42];
546 memset(original_buffer
, '!', 42);
547 BinaryValue
* original_binary
= BinaryValue::Create(original_buffer
, 42);
548 original_dict
.Set("binary", original_binary
);
550 ListValue
* original_list
= new ListValue();
551 FundamentalValue
* original_list_element_0
= Value::CreateIntegerValue(0);
552 original_list
->Append(original_list_element_0
);
553 FundamentalValue
* original_list_element_1
= Value::CreateIntegerValue(1);
554 original_list
->Append(original_list_element_1
);
555 original_dict
.Set("list", original_list
);
557 Value
* original_dict_value
= &original_dict
;
558 Value
* original_bool_value
= original_bool
;
559 Value
* original_int_value
= original_int
;
560 Value
* original_double_value
= original_double
;
561 Value
* original_string_value
= original_string
;
562 Value
* original_string16_value
= original_string16
;
563 Value
* original_binary_value
= original_binary
;
564 Value
* original_list_value
= original_list
;
566 scoped_ptr
<Value
> copy_dict_value(original_dict_value
->DeepCopy());
567 scoped_ptr
<Value
> copy_bool_value(original_bool_value
->DeepCopy());
568 scoped_ptr
<Value
> copy_int_value(original_int_value
->DeepCopy());
569 scoped_ptr
<Value
> copy_double_value(original_double_value
->DeepCopy());
570 scoped_ptr
<Value
> copy_string_value(original_string_value
->DeepCopy());
571 scoped_ptr
<Value
> copy_string16_value(original_string16_value
->DeepCopy());
572 scoped_ptr
<Value
> copy_binary_value(original_binary_value
->DeepCopy());
573 scoped_ptr
<Value
> copy_list_value(original_list_value
->DeepCopy());
575 EXPECT_TRUE(original_dict_value
->Equals(copy_dict_value
.get()));
576 EXPECT_TRUE(original_bool_value
->Equals(copy_bool_value
.get()));
577 EXPECT_TRUE(original_int_value
->Equals(copy_int_value
.get()));
578 EXPECT_TRUE(original_double_value
->Equals(copy_double_value
.get()));
579 EXPECT_TRUE(original_string_value
->Equals(copy_string_value
.get()));
580 EXPECT_TRUE(original_string16_value
->Equals(copy_string16_value
.get()));
581 EXPECT_TRUE(original_binary_value
->Equals(copy_binary_value
.get()));
582 EXPECT_TRUE(original_list_value
->Equals(copy_list_value
.get()));
585 TEST(ValuesTest
, RemoveEmptyChildren
) {
586 scoped_ptr
<DictionaryValue
> root(new DictionaryValue
);
587 // Remove empty lists and dictionaries.
588 root
->Set("empty_dict", new DictionaryValue
);
589 root
->Set("empty_list", new ListValue
);
590 root
->SetWithoutPathExpansion("a.b.c.d.e", new DictionaryValue
);
591 root
.reset(root
->DeepCopyWithoutEmptyChildren());
592 EXPECT_TRUE(root
->empty());
594 // Make sure we don't prune too much.
595 root
->SetBoolean("bool", true);
596 root
->Set("empty_dict", new DictionaryValue
);
597 root
->SetString("empty_string", "");
598 root
.reset(root
->DeepCopyWithoutEmptyChildren());
599 EXPECT_EQ(2U, root
->size());
601 // Should do nothing.
602 root
.reset(root
->DeepCopyWithoutEmptyChildren());
603 EXPECT_EQ(2U, root
->size());
605 // Nested test cases. These should all reduce back to the bool and string
608 root
->Set("a.b.c.d.e", new DictionaryValue
);
609 root
.reset(root
->DeepCopyWithoutEmptyChildren());
610 EXPECT_EQ(2U, root
->size());
613 DictionaryValue
* inner
= new DictionaryValue
;
614 root
->Set("dict_with_emtpy_children", inner
);
615 inner
->Set("empty_dict", new DictionaryValue
);
616 inner
->Set("empty_list", new ListValue
);
617 root
.reset(root
->DeepCopyWithoutEmptyChildren());
618 EXPECT_EQ(2U, root
->size());
621 ListValue
* inner
= new ListValue
;
622 root
->Set("list_with_empty_children", inner
);
623 inner
->Append(new DictionaryValue
);
624 inner
->Append(new ListValue
);
625 root
.reset(root
->DeepCopyWithoutEmptyChildren());
626 EXPECT_EQ(2U, root
->size());
629 // Nested with siblings.
631 ListValue
* inner
= new ListValue
;
632 root
->Set("list_with_empty_children", inner
);
633 inner
->Append(new DictionaryValue
);
634 inner
->Append(new ListValue
);
635 DictionaryValue
* inner2
= new DictionaryValue
;
636 root
->Set("dict_with_empty_children", inner2
);
637 inner2
->Set("empty_dict", new DictionaryValue
);
638 inner2
->Set("empty_list", new ListValue
);
639 root
.reset(root
->DeepCopyWithoutEmptyChildren());
640 EXPECT_EQ(2U, root
->size());
643 // Make sure nested values don't get pruned.
645 ListValue
* inner
= new ListValue
;
646 root
->Set("list_with_empty_children", inner
);
647 ListValue
* inner2
= new ListValue
;
648 inner
->Append(new DictionaryValue
);
649 inner
->Append(inner2
);
650 inner2
->Append(Value::CreateStringValue("hello"));
651 root
.reset(root
->DeepCopyWithoutEmptyChildren());
652 EXPECT_EQ(3U, root
->size());
653 EXPECT_TRUE(root
->GetList("list_with_empty_children", &inner
));
654 EXPECT_EQ(1U, inner
->GetSize()); // Dictionary was pruned.
655 EXPECT_TRUE(inner
->GetList(0, &inner2
));
656 EXPECT_EQ(1U, inner2
->GetSize());
660 TEST(ValuesTest
, MergeDictionary
) {
661 scoped_ptr
<DictionaryValue
> base(new DictionaryValue
);
662 base
->SetString("base_key", "base_key_value_base");
663 base
->SetString("collide_key", "collide_key_value_base");
664 DictionaryValue
* base_sub_dict
= new DictionaryValue
;
665 base_sub_dict
->SetString("sub_base_key", "sub_base_key_value_base");
666 base_sub_dict
->SetString("sub_collide_key", "sub_collide_key_value_base");
667 base
->Set("sub_dict_key", base_sub_dict
);
669 scoped_ptr
<DictionaryValue
> merge(new DictionaryValue
);
670 merge
->SetString("merge_key", "merge_key_value_merge");
671 merge
->SetString("collide_key", "collide_key_value_merge");
672 DictionaryValue
* merge_sub_dict
= new DictionaryValue
;
673 merge_sub_dict
->SetString("sub_merge_key", "sub_merge_key_value_merge");
674 merge_sub_dict
->SetString("sub_collide_key", "sub_collide_key_value_merge");
675 merge
->Set("sub_dict_key", merge_sub_dict
);
677 base
->MergeDictionary(merge
.get());
679 EXPECT_EQ(4U, base
->size());
680 std::string base_key_value
;
681 EXPECT_TRUE(base
->GetString("base_key", &base_key_value
));
682 EXPECT_EQ("base_key_value_base", base_key_value
); // Base value preserved.
683 std::string collide_key_value
;
684 EXPECT_TRUE(base
->GetString("collide_key", &collide_key_value
));
685 EXPECT_EQ("collide_key_value_merge", collide_key_value
); // Replaced.
686 std::string merge_key_value
;
687 EXPECT_TRUE(base
->GetString("merge_key", &merge_key_value
));
688 EXPECT_EQ("merge_key_value_merge", merge_key_value
); // Merged in.
690 DictionaryValue
* res_sub_dict
;
691 EXPECT_TRUE(base
->GetDictionary("sub_dict_key", &res_sub_dict
));
692 EXPECT_EQ(3U, res_sub_dict
->size());
693 std::string sub_base_key_value
;
694 EXPECT_TRUE(res_sub_dict
->GetString("sub_base_key", &sub_base_key_value
));
695 EXPECT_EQ("sub_base_key_value_base", sub_base_key_value
); // Preserved.
696 std::string sub_collide_key_value
;
697 EXPECT_TRUE(res_sub_dict
->GetString("sub_collide_key",
698 &sub_collide_key_value
));
699 EXPECT_EQ("sub_collide_key_value_merge", sub_collide_key_value
); // Replaced.
700 std::string sub_merge_key_value
;
701 EXPECT_TRUE(res_sub_dict
->GetString("sub_merge_key", &sub_merge_key_value
));
702 EXPECT_EQ("sub_merge_key_value_merge", sub_merge_key_value
); // Merged in.