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