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 <limits>
6
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"
12
13 namespace base {
14
TEST(ValuesTest,Basic)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);
21
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);
30
31 // Test storing a dictionary in a list.
32 ListValue* toolbar_bookmarks;
33 ASSERT_FALSE(
34 settings.GetList("global.toolbar.bookmarks", &toolbar_bookmarks));
35
36 toolbar_bookmarks = new ListValue;
37 settings.Set("global.toolbar.bookmarks", toolbar_bookmarks);
38 ASSERT_TRUE(settings.GetList("global.toolbar.bookmarks", &toolbar_bookmarks));
39
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);
44
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);
56 }
57
TEST(ValuesTest,List)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());
65
66 Value *value = NULL;
67 bool bool_value = false;
68 int int_value = 0;
69 double double_value = 0.0;
70 std::string string_value;
71
72 ASSERT_FALSE(mixed_list->Get(4, &value));
73
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);
84
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);
96
97 // Try searching in the mixed list.
98 base::FundamentalValue sought_value(42);
99 base::FundamentalValue not_found_value(false);
100
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));
105 }
106
TEST(ValuesTest,BinaryValue)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());
113
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());
121
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()));
130 }
131
TEST(ValuesTest,StringValue)132 TEST(ValuesTest, StringValue) {
133 // Test overloaded StringValue constructor.
134 scoped_ptr<Value> narrow_value(new StringValue("narrow"));
135 ASSERT_TRUE(narrow_value.get());
136 ASSERT_TRUE(narrow_value->IsType(Value::TYPE_STRING));
137 scoped_ptr<Value> utf16_value(new StringValue(ASCIIToUTF16("utf16")));
138 ASSERT_TRUE(utf16_value.get());
139 ASSERT_TRUE(utf16_value->IsType(Value::TYPE_STRING));
140
141 // Test overloaded GetAsString.
142 std::string narrow = "http://google.com";
143 string16 utf16 = ASCIIToUTF16("http://google.com");
144 const StringValue* string_value = NULL;
145 ASSERT_TRUE(narrow_value->GetAsString(&narrow));
146 ASSERT_TRUE(narrow_value->GetAsString(&utf16));
147 ASSERT_TRUE(narrow_value->GetAsString(&string_value));
148 ASSERT_EQ(std::string("narrow"), narrow);
149 ASSERT_EQ(ASCIIToUTF16("narrow"), utf16);
150 ASSERT_EQ(string_value->GetString(), narrow);
151
152 ASSERT_TRUE(utf16_value->GetAsString(&narrow));
153 ASSERT_TRUE(utf16_value->GetAsString(&utf16));
154 ASSERT_TRUE(utf16_value->GetAsString(&string_value));
155 ASSERT_EQ(std::string("utf16"), narrow);
156 ASSERT_EQ(ASCIIToUTF16("utf16"), utf16);
157 ASSERT_EQ(string_value->GetString(), narrow);
158
159 // Don't choke on NULL values.
160 ASSERT_TRUE(narrow_value->GetAsString(static_cast<string16*>(NULL)));
161 ASSERT_TRUE(narrow_value->GetAsString(static_cast<std::string*>(NULL)));
162 ASSERT_TRUE(narrow_value->GetAsString(
163 static_cast<const StringValue**>(NULL)));
164 }
165
166 // This is a Value object that allows us to tell if it's been
167 // properly deleted by modifying the value of external flag on destruction.
168 class DeletionTestValue : public Value {
169 public:
DeletionTestValue(bool * deletion_flag)170 explicit DeletionTestValue(bool* deletion_flag) : Value(TYPE_NULL) {
171 Init(deletion_flag); // Separate function so that we can use ASSERT_*
172 }
173
Init(bool * deletion_flag)174 void Init(bool* deletion_flag) {
175 ASSERT_TRUE(deletion_flag);
176 deletion_flag_ = deletion_flag;
177 *deletion_flag_ = false;
178 }
179
~DeletionTestValue()180 virtual ~DeletionTestValue() {
181 *deletion_flag_ = true;
182 }
183
184 private:
185 bool* deletion_flag_;
186 };
187
TEST(ValuesTest,ListDeletion)188 TEST(ValuesTest, ListDeletion) {
189 bool deletion_flag = true;
190
191 {
192 ListValue list;
193 list.Append(new DeletionTestValue(&deletion_flag));
194 EXPECT_FALSE(deletion_flag);
195 }
196 EXPECT_TRUE(deletion_flag);
197
198 {
199 ListValue list;
200 list.Append(new DeletionTestValue(&deletion_flag));
201 EXPECT_FALSE(deletion_flag);
202 list.Clear();
203 EXPECT_TRUE(deletion_flag);
204 }
205
206 {
207 ListValue list;
208 list.Append(new DeletionTestValue(&deletion_flag));
209 EXPECT_FALSE(deletion_flag);
210 EXPECT_TRUE(list.Set(0, Value::CreateNullValue()));
211 EXPECT_TRUE(deletion_flag);
212 }
213 }
214
TEST(ValuesTest,ListRemoval)215 TEST(ValuesTest, ListRemoval) {
216 bool deletion_flag = true;
217 scoped_ptr<Value> removed_item;
218
219 {
220 ListValue list;
221 list.Append(new DeletionTestValue(&deletion_flag));
222 EXPECT_FALSE(deletion_flag);
223 EXPECT_EQ(1U, list.GetSize());
224 EXPECT_FALSE(list.Remove(std::numeric_limits<size_t>::max(),
225 &removed_item));
226 EXPECT_FALSE(list.Remove(1, &removed_item));
227 EXPECT_TRUE(list.Remove(0, &removed_item));
228 ASSERT_TRUE(removed_item);
229 EXPECT_EQ(0U, list.GetSize());
230 }
231 EXPECT_FALSE(deletion_flag);
232 removed_item.reset();
233 EXPECT_TRUE(deletion_flag);
234
235 {
236 ListValue list;
237 list.Append(new DeletionTestValue(&deletion_flag));
238 EXPECT_FALSE(deletion_flag);
239 EXPECT_TRUE(list.Remove(0, NULL));
240 EXPECT_TRUE(deletion_flag);
241 EXPECT_EQ(0U, list.GetSize());
242 }
243
244 {
245 ListValue list;
246 DeletionTestValue* value = new DeletionTestValue(&deletion_flag);
247 list.Append(value);
248 EXPECT_FALSE(deletion_flag);
249 size_t index = 0;
250 list.Remove(*value, &index);
251 EXPECT_EQ(0U, index);
252 EXPECT_TRUE(deletion_flag);
253 EXPECT_EQ(0U, list.GetSize());
254 }
255 }
256
TEST(ValuesTest,DictionaryDeletion)257 TEST(ValuesTest, DictionaryDeletion) {
258 std::string key = "test";
259 bool deletion_flag = true;
260
261 {
262 DictionaryValue dict;
263 dict.Set(key, new DeletionTestValue(&deletion_flag));
264 EXPECT_FALSE(deletion_flag);
265 }
266 EXPECT_TRUE(deletion_flag);
267
268 {
269 DictionaryValue dict;
270 dict.Set(key, new DeletionTestValue(&deletion_flag));
271 EXPECT_FALSE(deletion_flag);
272 dict.Clear();
273 EXPECT_TRUE(deletion_flag);
274 }
275
276 {
277 DictionaryValue dict;
278 dict.Set(key, new DeletionTestValue(&deletion_flag));
279 EXPECT_FALSE(deletion_flag);
280 dict.Set(key, Value::CreateNullValue());
281 EXPECT_TRUE(deletion_flag);
282 }
283 }
284
TEST(ValuesTest,DictionaryRemoval)285 TEST(ValuesTest, DictionaryRemoval) {
286 std::string key = "test";
287 bool deletion_flag = true;
288 scoped_ptr<Value> removed_item;
289
290 {
291 DictionaryValue dict;
292 dict.Set(key, new DeletionTestValue(&deletion_flag));
293 EXPECT_FALSE(deletion_flag);
294 EXPECT_TRUE(dict.HasKey(key));
295 EXPECT_FALSE(dict.Remove("absent key", &removed_item));
296 EXPECT_TRUE(dict.Remove(key, &removed_item));
297 EXPECT_FALSE(dict.HasKey(key));
298 ASSERT_TRUE(removed_item);
299 }
300 EXPECT_FALSE(deletion_flag);
301 removed_item.reset();
302 EXPECT_TRUE(deletion_flag);
303
304 {
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));
312 }
313 }
314
TEST(ValuesTest,DictionaryWithoutPathExpansion)315 TEST(ValuesTest, DictionaryWithoutPathExpansion) {
316 DictionaryValue dict;
317 dict.Set("this.is.expanded", Value::CreateNullValue());
318 dict.SetWithoutPathExpansion("this.isnt.expanded", Value::CreateNullValue());
319
320 EXPECT_FALSE(dict.HasKey("this.is.expanded"));
321 EXPECT_TRUE(dict.HasKey("this"));
322 Value* value1;
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());
328
329 EXPECT_TRUE(dict.HasKey("this.isnt.expanded"));
330 Value* value3;
331 EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3));
332 Value* value4;
333 ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4));
334 EXPECT_EQ(Value::TYPE_NULL, value4->GetType());
335 }
336
TEST(ValuesTest,DictionaryRemovePath)337 TEST(ValuesTest, DictionaryRemovePath) {
338 DictionaryValue dict;
339 dict.Set("a.long.way.down", new FundamentalValue(1));
340 dict.Set("a.long.key.path", new FundamentalValue(true));
341
342 scoped_ptr<Value> removed_item;
343 EXPECT_TRUE(dict.RemovePath("a.long.way.down", &removed_item));
344 ASSERT_TRUE(removed_item);
345 EXPECT_TRUE(removed_item->IsType(base::Value::TYPE_INTEGER));
346 EXPECT_FALSE(dict.HasKey("a.long.way.down"));
347 EXPECT_FALSE(dict.HasKey("a.long.way"));
348 EXPECT_TRUE(dict.Get("a.long.key.path", NULL));
349
350 removed_item.reset();
351 EXPECT_FALSE(dict.RemovePath("a.long.way.down", &removed_item));
352 EXPECT_FALSE(removed_item);
353 EXPECT_TRUE(dict.Get("a.long.key.path", NULL));
354
355 removed_item.reset();
356 EXPECT_TRUE(dict.RemovePath("a.long.key.path", &removed_item));
357 ASSERT_TRUE(removed_item);
358 EXPECT_TRUE(removed_item->IsType(base::Value::TYPE_BOOLEAN));
359 EXPECT_TRUE(dict.empty());
360 }
361
TEST(ValuesTest,DeepCopy)362 TEST(ValuesTest, DeepCopy) {
363 DictionaryValue original_dict;
364 Value* original_null = Value::CreateNullValue();
365 original_dict.Set("null", original_null);
366 FundamentalValue* original_bool = new FundamentalValue(true);
367 original_dict.Set("bool", original_bool);
368 FundamentalValue* original_int = new FundamentalValue(42);
369 original_dict.Set("int", original_int);
370 FundamentalValue* original_double = new FundamentalValue(3.14);
371 original_dict.Set("double", original_double);
372 StringValue* original_string = new StringValue("hello");
373 original_dict.Set("string", original_string);
374 StringValue* original_string16 = new StringValue(ASCIIToUTF16("hello16"));
375 original_dict.Set("string16", original_string16);
376
377 scoped_ptr<char[]> original_buffer(new char[42]);
378 memset(original_buffer.get(), '!', 42);
379 BinaryValue* original_binary = new BinaryValue(original_buffer.Pass(), 42);
380 original_dict.Set("binary", original_binary);
381
382 ListValue* original_list = new ListValue();
383 FundamentalValue* original_list_element_0 = new FundamentalValue(0);
384 original_list->Append(original_list_element_0);
385 FundamentalValue* original_list_element_1 = new FundamentalValue(1);
386 original_list->Append(original_list_element_1);
387 original_dict.Set("list", original_list);
388
389 DictionaryValue* original_nested_dictionary = new DictionaryValue();
390 original_nested_dictionary->Set("key", new StringValue("value"));
391 original_dict.Set("dictionary", original_nested_dictionary);
392
393 scoped_ptr<DictionaryValue> copy_dict(original_dict.DeepCopy());
394 ASSERT_TRUE(copy_dict.get());
395 ASSERT_NE(copy_dict.get(), &original_dict);
396
397 Value* copy_null = NULL;
398 ASSERT_TRUE(copy_dict->Get("null", ©_null));
399 ASSERT_TRUE(copy_null);
400 ASSERT_NE(copy_null, original_null);
401 ASSERT_TRUE(copy_null->IsType(Value::TYPE_NULL));
402
403 Value* copy_bool = NULL;
404 ASSERT_TRUE(copy_dict->Get("bool", ©_bool));
405 ASSERT_TRUE(copy_bool);
406 ASSERT_NE(copy_bool, original_bool);
407 ASSERT_TRUE(copy_bool->IsType(Value::TYPE_BOOLEAN));
408 bool copy_bool_value = false;
409 ASSERT_TRUE(copy_bool->GetAsBoolean(©_bool_value));
410 ASSERT_TRUE(copy_bool_value);
411
412 Value* copy_int = NULL;
413 ASSERT_TRUE(copy_dict->Get("int", ©_int));
414 ASSERT_TRUE(copy_int);
415 ASSERT_NE(copy_int, original_int);
416 ASSERT_TRUE(copy_int->IsType(Value::TYPE_INTEGER));
417 int copy_int_value = 0;
418 ASSERT_TRUE(copy_int->GetAsInteger(©_int_value));
419 ASSERT_EQ(42, copy_int_value);
420
421 Value* copy_double = NULL;
422 ASSERT_TRUE(copy_dict->Get("double", ©_double));
423 ASSERT_TRUE(copy_double);
424 ASSERT_NE(copy_double, original_double);
425 ASSERT_TRUE(copy_double->IsType(Value::TYPE_DOUBLE));
426 double copy_double_value = 0;
427 ASSERT_TRUE(copy_double->GetAsDouble(©_double_value));
428 ASSERT_EQ(3.14, copy_double_value);
429
430 Value* copy_string = NULL;
431 ASSERT_TRUE(copy_dict->Get("string", ©_string));
432 ASSERT_TRUE(copy_string);
433 ASSERT_NE(copy_string, original_string);
434 ASSERT_TRUE(copy_string->IsType(Value::TYPE_STRING));
435 std::string copy_string_value;
436 string16 copy_string16_value;
437 ASSERT_TRUE(copy_string->GetAsString(©_string_value));
438 ASSERT_TRUE(copy_string->GetAsString(©_string16_value));
439 ASSERT_EQ(std::string("hello"), copy_string_value);
440 ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value);
441
442 Value* copy_string16 = NULL;
443 ASSERT_TRUE(copy_dict->Get("string16", ©_string16));
444 ASSERT_TRUE(copy_string16);
445 ASSERT_NE(copy_string16, original_string16);
446 ASSERT_TRUE(copy_string16->IsType(Value::TYPE_STRING));
447 ASSERT_TRUE(copy_string16->GetAsString(©_string_value));
448 ASSERT_TRUE(copy_string16->GetAsString(©_string16_value));
449 ASSERT_EQ(std::string("hello16"), copy_string_value);
450 ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value);
451
452 Value* copy_binary = NULL;
453 ASSERT_TRUE(copy_dict->Get("binary", ©_binary));
454 ASSERT_TRUE(copy_binary);
455 ASSERT_NE(copy_binary, original_binary);
456 ASSERT_TRUE(copy_binary->IsType(Value::TYPE_BINARY));
457 ASSERT_NE(original_binary->GetBuffer(),
458 static_cast<BinaryValue*>(copy_binary)->GetBuffer());
459 ASSERT_EQ(original_binary->GetSize(),
460 static_cast<BinaryValue*>(copy_binary)->GetSize());
461 ASSERT_EQ(0, memcmp(original_binary->GetBuffer(),
462 static_cast<BinaryValue*>(copy_binary)->GetBuffer(),
463 original_binary->GetSize()));
464
465 Value* copy_value = NULL;
466 ASSERT_TRUE(copy_dict->Get("list", ©_value));
467 ASSERT_TRUE(copy_value);
468 ASSERT_NE(copy_value, original_list);
469 ASSERT_TRUE(copy_value->IsType(Value::TYPE_LIST));
470 ListValue* copy_list = NULL;
471 ASSERT_TRUE(copy_value->GetAsList(©_list));
472 ASSERT_TRUE(copy_list);
473 ASSERT_EQ(2U, copy_list->GetSize());
474
475 Value* copy_list_element_0;
476 ASSERT_TRUE(copy_list->Get(0, ©_list_element_0));
477 ASSERT_TRUE(copy_list_element_0);
478 ASSERT_NE(copy_list_element_0, original_list_element_0);
479 int copy_list_element_0_value;
480 ASSERT_TRUE(copy_list_element_0->GetAsInteger(©_list_element_0_value));
481 ASSERT_EQ(0, copy_list_element_0_value);
482
483 Value* copy_list_element_1;
484 ASSERT_TRUE(copy_list->Get(1, ©_list_element_1));
485 ASSERT_TRUE(copy_list_element_1);
486 ASSERT_NE(copy_list_element_1, original_list_element_1);
487 int copy_list_element_1_value;
488 ASSERT_TRUE(copy_list_element_1->GetAsInteger(©_list_element_1_value));
489 ASSERT_EQ(1, copy_list_element_1_value);
490
491 copy_value = NULL;
492 ASSERT_TRUE(copy_dict->Get("dictionary", ©_value));
493 ASSERT_TRUE(copy_value);
494 ASSERT_NE(copy_value, original_nested_dictionary);
495 ASSERT_TRUE(copy_value->IsType(Value::TYPE_DICTIONARY));
496 DictionaryValue* copy_nested_dictionary = NULL;
497 ASSERT_TRUE(copy_value->GetAsDictionary(©_nested_dictionary));
498 ASSERT_TRUE(copy_nested_dictionary);
499 EXPECT_TRUE(copy_nested_dictionary->HasKey("key"));
500 }
501
TEST(ValuesTest,Equals)502 TEST(ValuesTest, Equals) {
503 Value* null1 = Value::CreateNullValue();
504 Value* null2 = Value::CreateNullValue();
505 EXPECT_NE(null1, null2);
506 EXPECT_TRUE(null1->Equals(null2));
507
508 Value* boolean = new FundamentalValue(false);
509 EXPECT_FALSE(null1->Equals(boolean));
510 delete null1;
511 delete null2;
512 delete boolean;
513
514 DictionaryValue dv;
515 dv.SetBoolean("a", false);
516 dv.SetInteger("b", 2);
517 dv.SetDouble("c", 2.5);
518 dv.SetString("d1", "string");
519 dv.SetString("d2", ASCIIToUTF16("http://google.com"));
520 dv.Set("e", Value::CreateNullValue());
521
522 scoped_ptr<DictionaryValue> copy;
523 copy.reset(dv.DeepCopy());
524 EXPECT_TRUE(dv.Equals(copy.get()));
525
526 ListValue* list = new ListValue;
527 list->Append(Value::CreateNullValue());
528 list->Append(new DictionaryValue);
529 dv.Set("f", list);
530
531 EXPECT_FALSE(dv.Equals(copy.get()));
532 copy->Set("f", list->DeepCopy());
533 EXPECT_TRUE(dv.Equals(copy.get()));
534
535 list->Append(new FundamentalValue(true));
536 EXPECT_FALSE(dv.Equals(copy.get()));
537
538 // Check if Equals detects differences in only the keys.
539 copy.reset(dv.DeepCopy());
540 EXPECT_TRUE(dv.Equals(copy.get()));
541 copy->Remove("a", NULL);
542 copy->SetBoolean("aa", false);
543 EXPECT_FALSE(dv.Equals(copy.get()));
544 }
545
TEST(ValuesTest,StaticEquals)546 TEST(ValuesTest, StaticEquals) {
547 scoped_ptr<Value> null1(Value::CreateNullValue());
548 scoped_ptr<Value> null2(Value::CreateNullValue());
549 EXPECT_TRUE(Value::Equals(null1.get(), null2.get()));
550 EXPECT_TRUE(Value::Equals(NULL, NULL));
551
552 scoped_ptr<Value> i42(new FundamentalValue(42));
553 scoped_ptr<Value> j42(new FundamentalValue(42));
554 scoped_ptr<Value> i17(new FundamentalValue(17));
555 EXPECT_TRUE(Value::Equals(i42.get(), i42.get()));
556 EXPECT_TRUE(Value::Equals(j42.get(), i42.get()));
557 EXPECT_TRUE(Value::Equals(i42.get(), j42.get()));
558 EXPECT_FALSE(Value::Equals(i42.get(), i17.get()));
559 EXPECT_FALSE(Value::Equals(i42.get(), NULL));
560 EXPECT_FALSE(Value::Equals(NULL, i42.get()));
561
562 // NULL and Value::CreateNullValue() are intentionally different: We need
563 // support for NULL as a return value for "undefined" without caring for
564 // ownership of the pointer.
565 EXPECT_FALSE(Value::Equals(null1.get(), NULL));
566 EXPECT_FALSE(Value::Equals(NULL, null1.get()));
567 }
568
TEST(ValuesTest,DeepCopyCovariantReturnTypes)569 TEST(ValuesTest, DeepCopyCovariantReturnTypes) {
570 DictionaryValue original_dict;
571 Value* original_null = Value::CreateNullValue();
572 original_dict.Set("null", original_null);
573 FundamentalValue* original_bool = new FundamentalValue(true);
574 original_dict.Set("bool", original_bool);
575 FundamentalValue* original_int = new FundamentalValue(42);
576 original_dict.Set("int", original_int);
577 FundamentalValue* original_double = new FundamentalValue(3.14);
578 original_dict.Set("double", original_double);
579 StringValue* original_string = new StringValue("hello");
580 original_dict.Set("string", original_string);
581 StringValue* original_string16 = new StringValue(ASCIIToUTF16("hello16"));
582 original_dict.Set("string16", original_string16);
583
584 scoped_ptr<char[]> original_buffer(new char[42]);
585 memset(original_buffer.get(), '!', 42);
586 BinaryValue* original_binary = new BinaryValue(original_buffer.Pass(), 42);
587 original_dict.Set("binary", original_binary);
588
589 ListValue* original_list = new ListValue();
590 FundamentalValue* original_list_element_0 = new FundamentalValue(0);
591 original_list->Append(original_list_element_0);
592 FundamentalValue* original_list_element_1 = new FundamentalValue(1);
593 original_list->Append(original_list_element_1);
594 original_dict.Set("list", original_list);
595
596 Value* original_dict_value = &original_dict;
597 Value* original_bool_value = original_bool;
598 Value* original_int_value = original_int;
599 Value* original_double_value = original_double;
600 Value* original_string_value = original_string;
601 Value* original_string16_value = original_string16;
602 Value* original_binary_value = original_binary;
603 Value* original_list_value = original_list;
604
605 scoped_ptr<Value> copy_dict_value(original_dict_value->DeepCopy());
606 scoped_ptr<Value> copy_bool_value(original_bool_value->DeepCopy());
607 scoped_ptr<Value> copy_int_value(original_int_value->DeepCopy());
608 scoped_ptr<Value> copy_double_value(original_double_value->DeepCopy());
609 scoped_ptr<Value> copy_string_value(original_string_value->DeepCopy());
610 scoped_ptr<Value> copy_string16_value(original_string16_value->DeepCopy());
611 scoped_ptr<Value> copy_binary_value(original_binary_value->DeepCopy());
612 scoped_ptr<Value> copy_list_value(original_list_value->DeepCopy());
613
614 EXPECT_TRUE(original_dict_value->Equals(copy_dict_value.get()));
615 EXPECT_TRUE(original_bool_value->Equals(copy_bool_value.get()));
616 EXPECT_TRUE(original_int_value->Equals(copy_int_value.get()));
617 EXPECT_TRUE(original_double_value->Equals(copy_double_value.get()));
618 EXPECT_TRUE(original_string_value->Equals(copy_string_value.get()));
619 EXPECT_TRUE(original_string16_value->Equals(copy_string16_value.get()));
620 EXPECT_TRUE(original_binary_value->Equals(copy_binary_value.get()));
621 EXPECT_TRUE(original_list_value->Equals(copy_list_value.get()));
622 }
623
TEST(ValuesTest,RemoveEmptyChildren)624 TEST(ValuesTest, RemoveEmptyChildren) {
625 scoped_ptr<DictionaryValue> root(new DictionaryValue);
626 // Remove empty lists and dictionaries.
627 root->Set("empty_dict", new DictionaryValue);
628 root->Set("empty_list", new ListValue);
629 root->SetWithoutPathExpansion("a.b.c.d.e", new DictionaryValue);
630 root.reset(root->DeepCopyWithoutEmptyChildren());
631 EXPECT_TRUE(root->empty());
632
633 // Make sure we don't prune too much.
634 root->SetBoolean("bool", true);
635 root->Set("empty_dict", new DictionaryValue);
636 root->SetString("empty_string", std::string());
637 root.reset(root->DeepCopyWithoutEmptyChildren());
638 EXPECT_EQ(2U, root->size());
639
640 // Should do nothing.
641 root.reset(root->DeepCopyWithoutEmptyChildren());
642 EXPECT_EQ(2U, root->size());
643
644 // Nested test cases. These should all reduce back to the bool and string
645 // set above.
646 {
647 root->Set("a.b.c.d.e", new DictionaryValue);
648 root.reset(root->DeepCopyWithoutEmptyChildren());
649 EXPECT_EQ(2U, root->size());
650 }
651 {
652 DictionaryValue* inner = new DictionaryValue;
653 root->Set("dict_with_emtpy_children", inner);
654 inner->Set("empty_dict", new DictionaryValue);
655 inner->Set("empty_list", new ListValue);
656 root.reset(root->DeepCopyWithoutEmptyChildren());
657 EXPECT_EQ(2U, root->size());
658 }
659 {
660 ListValue* inner = new ListValue;
661 root->Set("list_with_empty_children", inner);
662 inner->Append(new DictionaryValue);
663 inner->Append(new ListValue);
664 root.reset(root->DeepCopyWithoutEmptyChildren());
665 EXPECT_EQ(2U, root->size());
666 }
667
668 // Nested with siblings.
669 {
670 ListValue* inner = new ListValue;
671 root->Set("list_with_empty_children", inner);
672 inner->Append(new DictionaryValue);
673 inner->Append(new ListValue);
674 DictionaryValue* inner2 = new DictionaryValue;
675 root->Set("dict_with_empty_children", inner2);
676 inner2->Set("empty_dict", new DictionaryValue);
677 inner2->Set("empty_list", new ListValue);
678 root.reset(root->DeepCopyWithoutEmptyChildren());
679 EXPECT_EQ(2U, root->size());
680 }
681
682 // Make sure nested values don't get pruned.
683 {
684 ListValue* inner = new ListValue;
685 root->Set("list_with_empty_children", inner);
686 ListValue* inner2 = new ListValue;
687 inner->Append(new DictionaryValue);
688 inner->Append(inner2);
689 inner2->Append(new StringValue("hello"));
690 root.reset(root->DeepCopyWithoutEmptyChildren());
691 EXPECT_EQ(3U, root->size());
692 EXPECT_TRUE(root->GetList("list_with_empty_children", &inner));
693 EXPECT_EQ(1U, inner->GetSize()); // Dictionary was pruned.
694 EXPECT_TRUE(inner->GetList(0, &inner2));
695 EXPECT_EQ(1U, inner2->GetSize());
696 }
697 }
698
TEST(ValuesTest,MergeDictionary)699 TEST(ValuesTest, MergeDictionary) {
700 scoped_ptr<DictionaryValue> base(new DictionaryValue);
701 base->SetString("base_key", "base_key_value_base");
702 base->SetString("collide_key", "collide_key_value_base");
703 DictionaryValue* base_sub_dict = new DictionaryValue;
704 base_sub_dict->SetString("sub_base_key", "sub_base_key_value_base");
705 base_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_base");
706 base->Set("sub_dict_key", base_sub_dict);
707
708 scoped_ptr<DictionaryValue> merge(new DictionaryValue);
709 merge->SetString("merge_key", "merge_key_value_merge");
710 merge->SetString("collide_key", "collide_key_value_merge");
711 DictionaryValue* merge_sub_dict = new DictionaryValue;
712 merge_sub_dict->SetString("sub_merge_key", "sub_merge_key_value_merge");
713 merge_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_merge");
714 merge->Set("sub_dict_key", merge_sub_dict);
715
716 base->MergeDictionary(merge.get());
717
718 EXPECT_EQ(4U, base->size());
719 std::string base_key_value;
720 EXPECT_TRUE(base->GetString("base_key", &base_key_value));
721 EXPECT_EQ("base_key_value_base", base_key_value); // Base value preserved.
722 std::string collide_key_value;
723 EXPECT_TRUE(base->GetString("collide_key", &collide_key_value));
724 EXPECT_EQ("collide_key_value_merge", collide_key_value); // Replaced.
725 std::string merge_key_value;
726 EXPECT_TRUE(base->GetString("merge_key", &merge_key_value));
727 EXPECT_EQ("merge_key_value_merge", merge_key_value); // Merged in.
728
729 DictionaryValue* res_sub_dict;
730 EXPECT_TRUE(base->GetDictionary("sub_dict_key", &res_sub_dict));
731 EXPECT_EQ(3U, res_sub_dict->size());
732 std::string sub_base_key_value;
733 EXPECT_TRUE(res_sub_dict->GetString("sub_base_key", &sub_base_key_value));
734 EXPECT_EQ("sub_base_key_value_base", sub_base_key_value); // Preserved.
735 std::string sub_collide_key_value;
736 EXPECT_TRUE(res_sub_dict->GetString("sub_collide_key",
737 &sub_collide_key_value));
738 EXPECT_EQ("sub_collide_key_value_merge", sub_collide_key_value); // Replaced.
739 std::string sub_merge_key_value;
740 EXPECT_TRUE(res_sub_dict->GetString("sub_merge_key", &sub_merge_key_value));
741 EXPECT_EQ("sub_merge_key_value_merge", sub_merge_key_value); // Merged in.
742 }
743
TEST(ValuesTest,MergeDictionaryDeepCopy)744 TEST(ValuesTest, MergeDictionaryDeepCopy) {
745 DictionaryValue* child = new DictionaryValue;
746 child->SetString("test", "value");
747 EXPECT_EQ(1U, child->size());
748
749 std::string value;
750 EXPECT_TRUE(child->GetString("test", &value));
751 EXPECT_EQ("value", value);
752
753 scoped_ptr<DictionaryValue> base(new DictionaryValue);
754 base->Set("dict", child);
755 EXPECT_EQ(1U, base->size());
756
757 DictionaryValue* ptr;
758 EXPECT_TRUE(base->GetDictionary("dict", &ptr));
759 EXPECT_EQ(child, ptr);
760
761 scoped_ptr<DictionaryValue> merged(new DictionaryValue);
762 merged->MergeDictionary(base.get());
763 EXPECT_EQ(1U, merged->size());
764 EXPECT_TRUE(merged->GetDictionary("dict", &ptr));
765 EXPECT_NE(child, ptr);
766 EXPECT_TRUE(ptr->GetString("test", &value));
767 EXPECT_EQ("value", value);
768
769 child->SetString("test", "overwrite");
770 base.reset();
771 EXPECT_TRUE(ptr->GetString("test", &value));
772 EXPECT_EQ("value", value);
773 }
774
TEST(ValuesTest,DictionaryIterator)775 TEST(ValuesTest, DictionaryIterator) {
776 DictionaryValue dict;
777 for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
778 ADD_FAILURE();
779 }
780
781 StringValue value1("value1");
782 dict.Set("key1", value1.DeepCopy());
783 bool seen1 = false;
784 for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
785 EXPECT_FALSE(seen1);
786 EXPECT_EQ("key1", it.key());
787 EXPECT_TRUE(value1.Equals(&it.value()));
788 seen1 = true;
789 }
790 EXPECT_TRUE(seen1);
791
792 StringValue value2("value2");
793 dict.Set("key2", value2.DeepCopy());
794 bool seen2 = seen1 = false;
795 for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
796 if (it.key() == "key1") {
797 EXPECT_FALSE(seen1);
798 EXPECT_TRUE(value1.Equals(&it.value()));
799 seen1 = true;
800 } else if (it.key() == "key2") {
801 EXPECT_FALSE(seen2);
802 EXPECT_TRUE(value2.Equals(&it.value()));
803 seen2 = true;
804 } else {
805 ADD_FAILURE();
806 }
807 }
808 EXPECT_TRUE(seen1);
809 EXPECT_TRUE(seen2);
810 }
811
812 // DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value
813 // and still return true/false based on success.
TEST(ValuesTest,GetWithNullOutValue)814 TEST(ValuesTest, GetWithNullOutValue) {
815 DictionaryValue main_dict;
816 ListValue main_list;
817
818 FundamentalValue bool_value(false);
819 FundamentalValue int_value(1234);
820 FundamentalValue double_value(12.34567);
821 StringValue string_value("foo");
822 BinaryValue binary_value;
823 DictionaryValue dict_value;
824 ListValue list_value;
825
826 main_dict.Set("bool", bool_value.DeepCopy());
827 main_dict.Set("int", int_value.DeepCopy());
828 main_dict.Set("double", double_value.DeepCopy());
829 main_dict.Set("string", string_value.DeepCopy());
830 main_dict.Set("binary", binary_value.DeepCopy());
831 main_dict.Set("dict", dict_value.DeepCopy());
832 main_dict.Set("list", list_value.DeepCopy());
833
834 main_list.Append(bool_value.DeepCopy());
835 main_list.Append(int_value.DeepCopy());
836 main_list.Append(double_value.DeepCopy());
837 main_list.Append(string_value.DeepCopy());
838 main_list.Append(binary_value.DeepCopy());
839 main_list.Append(dict_value.DeepCopy());
840 main_list.Append(list_value.DeepCopy());
841
842 EXPECT_TRUE(main_dict.Get("bool", NULL));
843 EXPECT_TRUE(main_dict.Get("int", NULL));
844 EXPECT_TRUE(main_dict.Get("double", NULL));
845 EXPECT_TRUE(main_dict.Get("string", NULL));
846 EXPECT_TRUE(main_dict.Get("binary", NULL));
847 EXPECT_TRUE(main_dict.Get("dict", NULL));
848 EXPECT_TRUE(main_dict.Get("list", NULL));
849 EXPECT_FALSE(main_dict.Get("DNE", NULL));
850
851 EXPECT_TRUE(main_dict.GetBoolean("bool", NULL));
852 EXPECT_FALSE(main_dict.GetBoolean("int", NULL));
853 EXPECT_FALSE(main_dict.GetBoolean("double", NULL));
854 EXPECT_FALSE(main_dict.GetBoolean("string", NULL));
855 EXPECT_FALSE(main_dict.GetBoolean("binary", NULL));
856 EXPECT_FALSE(main_dict.GetBoolean("dict", NULL));
857 EXPECT_FALSE(main_dict.GetBoolean("list", NULL));
858 EXPECT_FALSE(main_dict.GetBoolean("DNE", NULL));
859
860 EXPECT_FALSE(main_dict.GetInteger("bool", NULL));
861 EXPECT_TRUE(main_dict.GetInteger("int", NULL));
862 EXPECT_FALSE(main_dict.GetInteger("double", NULL));
863 EXPECT_FALSE(main_dict.GetInteger("string", NULL));
864 EXPECT_FALSE(main_dict.GetInteger("binary", NULL));
865 EXPECT_FALSE(main_dict.GetInteger("dict", NULL));
866 EXPECT_FALSE(main_dict.GetInteger("list", NULL));
867 EXPECT_FALSE(main_dict.GetInteger("DNE", NULL));
868
869 // Both int and double values can be obtained from GetDouble.
870 EXPECT_FALSE(main_dict.GetDouble("bool", NULL));
871 EXPECT_TRUE(main_dict.GetDouble("int", NULL));
872 EXPECT_TRUE(main_dict.GetDouble("double", NULL));
873 EXPECT_FALSE(main_dict.GetDouble("string", NULL));
874 EXPECT_FALSE(main_dict.GetDouble("binary", NULL));
875 EXPECT_FALSE(main_dict.GetDouble("dict", NULL));
876 EXPECT_FALSE(main_dict.GetDouble("list", NULL));
877 EXPECT_FALSE(main_dict.GetDouble("DNE", NULL));
878
879 EXPECT_FALSE(main_dict.GetString("bool", static_cast<std::string*>(NULL)));
880 EXPECT_FALSE(main_dict.GetString("int", static_cast<std::string*>(NULL)));
881 EXPECT_FALSE(main_dict.GetString("double", static_cast<std::string*>(NULL)));
882 EXPECT_TRUE(main_dict.GetString("string", static_cast<std::string*>(NULL)));
883 EXPECT_FALSE(main_dict.GetString("binary", static_cast<std::string*>(NULL)));
884 EXPECT_FALSE(main_dict.GetString("dict", static_cast<std::string*>(NULL)));
885 EXPECT_FALSE(main_dict.GetString("list", static_cast<std::string*>(NULL)));
886 EXPECT_FALSE(main_dict.GetString("DNE", static_cast<std::string*>(NULL)));
887
888 EXPECT_FALSE(main_dict.GetString("bool", static_cast<string16*>(NULL)));
889 EXPECT_FALSE(main_dict.GetString("int", static_cast<string16*>(NULL)));
890 EXPECT_FALSE(main_dict.GetString("double", static_cast<string16*>(NULL)));
891 EXPECT_TRUE(main_dict.GetString("string", static_cast<string16*>(NULL)));
892 EXPECT_FALSE(main_dict.GetString("binary", static_cast<string16*>(NULL)));
893 EXPECT_FALSE(main_dict.GetString("dict", static_cast<string16*>(NULL)));
894 EXPECT_FALSE(main_dict.GetString("list", static_cast<string16*>(NULL)));
895 EXPECT_FALSE(main_dict.GetString("DNE", static_cast<string16*>(NULL)));
896
897 EXPECT_FALSE(main_dict.GetBinary("bool", NULL));
898 EXPECT_FALSE(main_dict.GetBinary("int", NULL));
899 EXPECT_FALSE(main_dict.GetBinary("double", NULL));
900 EXPECT_FALSE(main_dict.GetBinary("string", NULL));
901 EXPECT_TRUE(main_dict.GetBinary("binary", NULL));
902 EXPECT_FALSE(main_dict.GetBinary("dict", NULL));
903 EXPECT_FALSE(main_dict.GetBinary("list", NULL));
904 EXPECT_FALSE(main_dict.GetBinary("DNE", NULL));
905
906 EXPECT_FALSE(main_dict.GetDictionary("bool", NULL));
907 EXPECT_FALSE(main_dict.GetDictionary("int", NULL));
908 EXPECT_FALSE(main_dict.GetDictionary("double", NULL));
909 EXPECT_FALSE(main_dict.GetDictionary("string", NULL));
910 EXPECT_FALSE(main_dict.GetDictionary("binary", NULL));
911 EXPECT_TRUE(main_dict.GetDictionary("dict", NULL));
912 EXPECT_FALSE(main_dict.GetDictionary("list", NULL));
913 EXPECT_FALSE(main_dict.GetDictionary("DNE", NULL));
914
915 EXPECT_FALSE(main_dict.GetList("bool", NULL));
916 EXPECT_FALSE(main_dict.GetList("int", NULL));
917 EXPECT_FALSE(main_dict.GetList("double", NULL));
918 EXPECT_FALSE(main_dict.GetList("string", NULL));
919 EXPECT_FALSE(main_dict.GetList("binary", NULL));
920 EXPECT_FALSE(main_dict.GetList("dict", NULL));
921 EXPECT_TRUE(main_dict.GetList("list", NULL));
922 EXPECT_FALSE(main_dict.GetList("DNE", NULL));
923
924 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("bool", NULL));
925 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("int", NULL));
926 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("double", NULL));
927 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("string", NULL));
928 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("binary", NULL));
929 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("dict", NULL));
930 EXPECT_TRUE(main_dict.GetWithoutPathExpansion("list", NULL));
931 EXPECT_FALSE(main_dict.GetWithoutPathExpansion("DNE", NULL));
932
933 EXPECT_TRUE(main_dict.GetBooleanWithoutPathExpansion("bool", NULL));
934 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("int", NULL));
935 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("double", NULL));
936 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("string", NULL));
937 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("binary", NULL));
938 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("dict", NULL));
939 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("list", NULL));
940 EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("DNE", NULL));
941
942 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("bool", NULL));
943 EXPECT_TRUE(main_dict.GetIntegerWithoutPathExpansion("int", NULL));
944 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("double", NULL));
945 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("string", NULL));
946 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("binary", NULL));
947 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("dict", NULL));
948 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("list", NULL));
949 EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("DNE", NULL));
950
951 EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("bool", NULL));
952 EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("int", NULL));
953 EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("double", NULL));
954 EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("string", NULL));
955 EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("binary", NULL));
956 EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("dict", NULL));
957 EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("list", NULL));
958 EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("DNE", NULL));
959
960 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
961 "bool", static_cast<std::string*>(NULL)));
962 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
963 "int", static_cast<std::string*>(NULL)));
964 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
965 "double", static_cast<std::string*>(NULL)));
966 EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
967 "string", static_cast<std::string*>(NULL)));
968 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
969 "binary", static_cast<std::string*>(NULL)));
970 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
971 "dict", static_cast<std::string*>(NULL)));
972 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
973 "list", static_cast<std::string*>(NULL)));
974 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
975 "DNE", static_cast<std::string*>(NULL)));
976
977 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
978 "bool", static_cast<string16*>(NULL)));
979 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
980 "int", static_cast<string16*>(NULL)));
981 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
982 "double", static_cast<string16*>(NULL)));
983 EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
984 "string", static_cast<string16*>(NULL)));
985 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
986 "binary", static_cast<string16*>(NULL)));
987 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
988 "dict", static_cast<string16*>(NULL)));
989 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
990 "list", static_cast<string16*>(NULL)));
991 EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
992 "DNE", static_cast<string16*>(NULL)));
993
994 // There is no GetBinaryWithoutPathExpansion for some reason, but if there
995 // were it should be tested here...
996
997 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("bool", NULL));
998 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("int", NULL));
999 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("double", NULL));
1000 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("string", NULL));
1001 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("binary", NULL));
1002 EXPECT_TRUE(main_dict.GetDictionaryWithoutPathExpansion("dict", NULL));
1003 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("list", NULL));
1004 EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("DNE", NULL));
1005
1006 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("bool", NULL));
1007 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("int", NULL));
1008 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("double", NULL));
1009 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("string", NULL));
1010 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("binary", NULL));
1011 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("dict", NULL));
1012 EXPECT_TRUE(main_dict.GetListWithoutPathExpansion("list", NULL));
1013 EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("DNE", NULL));
1014
1015 EXPECT_TRUE(main_list.Get(0, NULL));
1016 EXPECT_TRUE(main_list.Get(1, NULL));
1017 EXPECT_TRUE(main_list.Get(2, NULL));
1018 EXPECT_TRUE(main_list.Get(3, NULL));
1019 EXPECT_TRUE(main_list.Get(4, NULL));
1020 EXPECT_TRUE(main_list.Get(5, NULL));
1021 EXPECT_TRUE(main_list.Get(6, NULL));
1022 EXPECT_FALSE(main_list.Get(7, NULL));
1023
1024 EXPECT_TRUE(main_list.GetBoolean(0, NULL));
1025 EXPECT_FALSE(main_list.GetBoolean(1, NULL));
1026 EXPECT_FALSE(main_list.GetBoolean(2, NULL));
1027 EXPECT_FALSE(main_list.GetBoolean(3, NULL));
1028 EXPECT_FALSE(main_list.GetBoolean(4, NULL));
1029 EXPECT_FALSE(main_list.GetBoolean(5, NULL));
1030 EXPECT_FALSE(main_list.GetBoolean(6, NULL));
1031 EXPECT_FALSE(main_list.GetBoolean(7, NULL));
1032
1033 EXPECT_FALSE(main_list.GetInteger(0, NULL));
1034 EXPECT_TRUE(main_list.GetInteger(1, NULL));
1035 EXPECT_FALSE(main_list.GetInteger(2, NULL));
1036 EXPECT_FALSE(main_list.GetInteger(3, NULL));
1037 EXPECT_FALSE(main_list.GetInteger(4, NULL));
1038 EXPECT_FALSE(main_list.GetInteger(5, NULL));
1039 EXPECT_FALSE(main_list.GetInteger(6, NULL));
1040 EXPECT_FALSE(main_list.GetInteger(7, NULL));
1041
1042 EXPECT_FALSE(main_list.GetDouble(0, NULL));
1043 EXPECT_TRUE(main_list.GetDouble(1, NULL));
1044 EXPECT_TRUE(main_list.GetDouble(2, NULL));
1045 EXPECT_FALSE(main_list.GetDouble(3, NULL));
1046 EXPECT_FALSE(main_list.GetDouble(4, NULL));
1047 EXPECT_FALSE(main_list.GetDouble(5, NULL));
1048 EXPECT_FALSE(main_list.GetDouble(6, NULL));
1049 EXPECT_FALSE(main_list.GetDouble(7, NULL));
1050
1051 EXPECT_FALSE(main_list.GetString(0, static_cast<std::string*>(NULL)));
1052 EXPECT_FALSE(main_list.GetString(1, static_cast<std::string*>(NULL)));
1053 EXPECT_FALSE(main_list.GetString(2, static_cast<std::string*>(NULL)));
1054 EXPECT_TRUE(main_list.GetString(3, static_cast<std::string*>(NULL)));
1055 EXPECT_FALSE(main_list.GetString(4, static_cast<std::string*>(NULL)));
1056 EXPECT_FALSE(main_list.GetString(5, static_cast<std::string*>(NULL)));
1057 EXPECT_FALSE(main_list.GetString(6, static_cast<std::string*>(NULL)));
1058 EXPECT_FALSE(main_list.GetString(7, static_cast<std::string*>(NULL)));
1059
1060 EXPECT_FALSE(main_list.GetString(0, static_cast<string16*>(NULL)));
1061 EXPECT_FALSE(main_list.GetString(1, static_cast<string16*>(NULL)));
1062 EXPECT_FALSE(main_list.GetString(2, static_cast<string16*>(NULL)));
1063 EXPECT_TRUE(main_list.GetString(3, static_cast<string16*>(NULL)));
1064 EXPECT_FALSE(main_list.GetString(4, static_cast<string16*>(NULL)));
1065 EXPECT_FALSE(main_list.GetString(5, static_cast<string16*>(NULL)));
1066 EXPECT_FALSE(main_list.GetString(6, static_cast<string16*>(NULL)));
1067 EXPECT_FALSE(main_list.GetString(7, static_cast<string16*>(NULL)));
1068
1069 EXPECT_FALSE(main_list.GetBinary(0, NULL));
1070 EXPECT_FALSE(main_list.GetBinary(1, NULL));
1071 EXPECT_FALSE(main_list.GetBinary(2, NULL));
1072 EXPECT_FALSE(main_list.GetBinary(3, NULL));
1073 EXPECT_TRUE(main_list.GetBinary(4, NULL));
1074 EXPECT_FALSE(main_list.GetBinary(5, NULL));
1075 EXPECT_FALSE(main_list.GetBinary(6, NULL));
1076 EXPECT_FALSE(main_list.GetBinary(7, NULL));
1077
1078 EXPECT_FALSE(main_list.GetDictionary(0, NULL));
1079 EXPECT_FALSE(main_list.GetDictionary(1, NULL));
1080 EXPECT_FALSE(main_list.GetDictionary(2, NULL));
1081 EXPECT_FALSE(main_list.GetDictionary(3, NULL));
1082 EXPECT_FALSE(main_list.GetDictionary(4, NULL));
1083 EXPECT_TRUE(main_list.GetDictionary(5, NULL));
1084 EXPECT_FALSE(main_list.GetDictionary(6, NULL));
1085 EXPECT_FALSE(main_list.GetDictionary(7, NULL));
1086
1087 EXPECT_FALSE(main_list.GetList(0, NULL));
1088 EXPECT_FALSE(main_list.GetList(1, NULL));
1089 EXPECT_FALSE(main_list.GetList(2, NULL));
1090 EXPECT_FALSE(main_list.GetList(3, NULL));
1091 EXPECT_FALSE(main_list.GetList(4, NULL));
1092 EXPECT_FALSE(main_list.GetList(5, NULL));
1093 EXPECT_TRUE(main_list.GetList(6, NULL));
1094 EXPECT_FALSE(main_list.GetList(7, NULL));
1095 }
1096
1097 } // namespace base
1098