base/values_unittest.cc

   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 <functional>
  10 #include <limits>
  11 #include <memory>
  12 #include <string>
  13 #include <type_traits>
  14 #include <utility>
  15 #include <vector>
  16
  17 #include "base/containers/adapters.h"
  18 #include "base/strings/string16.h"
  19 #include "base/strings/string_piece.h"
  20 #include "base/strings/utf_string_conversions.h"
  21 #include "testing/gmock/include/gmock/gmock.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 namespace base {
  25
  26 TEST(ValuesTest, TestNothrow) {
  27   static_assert(std::is_nothrow_move_constructible<Value>::value,
  28                 "IsNothrowMoveConstructible");
  29   static_assert(std::is_nothrow_default_constructible<Value>::value,
  30                 "IsNothrowDefaultConstructible");
  31   static_assert(std::is_nothrow_constructible<Value, std::string&&>::value,
  32                 "IsNothrowMoveConstructibleFromString");
  33   static_assert(
  34       std::is_nothrow_constructible<Value, Value::BlobStorage&&>::value,
  35       "IsNothrowMoveConstructibleFromBlob");
  36   static_assert(
  37       std::is_nothrow_constructible<Value, Value::ListStorage&&>::value,
  38       "IsNothrowMoveConstructibleFromList");
  39   static_assert(std::is_nothrow_move_assignable<Value>::value,
  40                 "IsNothrowMoveAssignable");
  41   static_assert(
  42       std::is_nothrow_constructible<ListValue, Value::ListStorage&&>::value,
  43       "ListIsNothrowMoveConstructibleFromList");
  44 }
  45
  46 // Group of tests for the value constructors.
  47 TEST(ValuesTest, ConstructBool) {
  48   Value true_value(true);
  49   EXPECT_EQ(Value::Type::BOOLEAN, true_value.type());
  50   EXPECT_TRUE(true_value.GetBool());
  51
  52   Value false_value(false);
  53   EXPECT_EQ(Value::Type::BOOLEAN, false_value.type());
  54   EXPECT_FALSE(false_value.GetBool());
  55 }
  56
  57 TEST(ValuesTest, ConstructInt) {
  58   Value value(-37);
  59   EXPECT_EQ(Value::Type::INTEGER, value.type());
  60   EXPECT_EQ(-37, value.GetInt());
  61 }
  62
  63 TEST(ValuesTest, ConstructDouble) {
  64   Value value(-4.655);
  65   EXPECT_EQ(Value::Type::DOUBLE, value.type());
  66   EXPECT_EQ(-4.655, value.GetDouble());
  67 }
  68
  69 TEST(ValuesTest, ConstructStringFromConstCharPtr) {
  70   const char* str = "foobar";
  71   Value value(str);
  72   EXPECT_EQ(Value::Type::STRING, value.type());
  73   EXPECT_EQ("foobar", value.GetString());
  74 }
  75
  76 TEST(ValuesTest, ConstructStringFromStringPiece) {
  77   std::string str = "foobar";
  78   Value value{StringPiece(str)};
  79   EXPECT_EQ(Value::Type::STRING, value.type());
  80   EXPECT_EQ("foobar", value.GetString());
  81 }
  82
  83 TEST(ValuesTest, ConstructStringFromStdStringRRef) {
  84   std::string str = "foobar";
  85   Value value(std::move(str));
  86   EXPECT_EQ(Value::Type::STRING, value.type());
  87   EXPECT_EQ("foobar", value.GetString());
  88 }
  89
  90 TEST(ValuesTest, ConstructStringFromConstChar16Ptr) {
  91   string16 str = ASCIIToUTF16("foobar");
  92   Value value(str.c_str());
  93   EXPECT_EQ(Value::Type::STRING, value.type());
  94   EXPECT_EQ("foobar", value.GetString());
  95 }
  96
  97 TEST(ValuesTest, ConstructStringFromStringPiece16) {
  98   string16 str = ASCIIToUTF16("foobar");
  99   Value value{StringPiece16(str)};
 100   EXPECT_EQ(Value::Type::STRING, value.type());
 101   EXPECT_EQ("foobar", value.GetString());
 102 }
 103
 104 TEST(ValuesTest, ConstructBinary) {
 105   Value value(Value::BlobStorage({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
 106   EXPECT_EQ(Value::Type::BINARY, value.type());
 107   EXPECT_EQ(Value::BlobStorage({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}),
 108             value.GetBlob());
 109 }
 110
 111 TEST(ValuesTest, ConstructDict) {
 112   DictionaryValue value;
 113   EXPECT_EQ(Value::Type::DICTIONARY, value.type());
 114 }
 115
 116 TEST(ValuesTest, ConstructDictFromStorage) {
 117   Value::DictStorage storage;
 118   storage.emplace("foo", std::make_unique<Value>("bar"));
 119   {
 120     DictionaryValue value(storage);
 121     EXPECT_EQ(Value::Type::DICTIONARY, value.type());
 122     EXPECT_EQ(Value::Type::STRING, value.FindKey("foo")->type());
 123     EXPECT_EQ("bar", value.FindKey("foo")->GetString());
 124   }
 125
 126   *storage["foo"] = base::Value("baz");
 127   {
 128     DictionaryValue value(std::move(storage));
 129     EXPECT_EQ(Value::Type::DICTIONARY, value.type());
 130     EXPECT_EQ(Value::Type::STRING, value.FindKey("foo")->type());
 131     EXPECT_EQ("baz", value.FindKey("foo")->GetString());
 132   }
 133 }
 134
 135 TEST(ValuesTest, ConstructList) {
 136   ListValue value;
 137   EXPECT_EQ(Value::Type::LIST, value.type());
 138 }
 139
 140 TEST(ValuesTest, ConstructListFromStorage) {
 141   Value::ListStorage storage;
 142   storage.emplace_back("foo");
 143   {
 144     ListValue value(storage);
 145     EXPECT_EQ(Value::Type::LIST, value.type());
 146     EXPECT_EQ(1u, value.GetList().size());
 147     EXPECT_EQ(Value::Type::STRING, value.GetList()[0].type());
 148     EXPECT_EQ("foo", value.GetList()[0].GetString());
 149   }
 150
 151   storage.back() = base::Value("bar");
 152   {
 153     ListValue value(std::move(storage));
 154     EXPECT_EQ(Value::Type::LIST, value.type());
 155     EXPECT_EQ(1u, value.GetList().size());
 156     EXPECT_EQ(Value::Type::STRING, value.GetList()[0].type());
 157     EXPECT_EQ("bar", value.GetList()[0].GetString());
 158   }
 159 }
 160
 161 // Group of tests for the copy constructors and copy-assigmnent. For equality
 162 // checks comparisons of the interesting fields are done instead of relying on
 163 // Equals being correct.
 164 TEST(ValuesTest, CopyBool) {
 165   Value true_value(true);
 166   Value copied_true_value(true_value.Clone());
 167   EXPECT_EQ(true_value.type(), copied_true_value.type());
 168   EXPECT_EQ(true_value.GetBool(), copied_true_value.GetBool());
 169
 170   Value false_value(false);
 171   Value copied_false_value(false_value.Clone());
 172   EXPECT_EQ(false_value.type(), copied_false_value.type());
 173   EXPECT_EQ(false_value.GetBool(), copied_false_value.GetBool());
 174
 175   Value blank;
 176
 177   blank = true_value.Clone();
 178   EXPECT_EQ(true_value.type(), blank.type());
 179   EXPECT_EQ(true_value.GetBool(), blank.GetBool());
 180
 181   blank = false_value.Clone();
 182   EXPECT_EQ(false_value.type(), blank.type());
 183   EXPECT_EQ(false_value.GetBool(), blank.GetBool());
 184 }
 185
 186 TEST(ValuesTest, CopyInt) {
 187   Value value(74);
 188   Value copied_value(value.Clone());
 189   EXPECT_EQ(value.type(), copied_value.type());
 190   EXPECT_EQ(value.GetInt(), copied_value.GetInt());
 191
 192   Value blank;
 193
 194   blank = value.Clone();
 195   EXPECT_EQ(value.type(), blank.type());
 196   EXPECT_EQ(value.GetInt(), blank.GetInt());
 197 }
 198
 199 TEST(ValuesTest, CopyDouble) {
 200   Value value(74.896);
 201   Value copied_value(value.Clone());
 202   EXPECT_EQ(value.type(), copied_value.type());
 203   EXPECT_EQ(value.GetDouble(), copied_value.GetDouble());
 204
 205   Value blank;
 206
 207   blank = value.Clone();
 208   EXPECT_EQ(value.type(), blank.type());
 209   EXPECT_EQ(value.GetDouble(), blank.GetDouble());
 210 }
 211
 212 TEST(ValuesTest, CopyString) {
 213   Value value("foobar");
 214   Value copied_value(value.Clone());
 215   EXPECT_EQ(value.type(), copied_value.type());
 216   EXPECT_EQ(value.GetString(), copied_value.GetString());
 217
 218   Value blank;
 219
 220   blank = value.Clone();
 221   EXPECT_EQ(value.type(), blank.type());
 222   EXPECT_EQ(value.GetString(), blank.GetString());
 223 }
 224
 225 TEST(ValuesTest, CopyBinary) {
 226   Value value(Value::BlobStorage({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
 227   Value copied_value(value.Clone());
 228   EXPECT_EQ(value.type(), copied_value.type());
 229   EXPECT_EQ(value.GetBlob(), copied_value.GetBlob());
 230
 231   Value blank;
 232
 233   blank = value.Clone();
 234   EXPECT_EQ(value.type(), blank.type());
 235   EXPECT_EQ(value.GetBlob(), blank.GetBlob());
 236 }
 237
 238 TEST(ValuesTest, CopyDictionary) {
 239   Value::DictStorage storage;
 240   storage.emplace("Int", std::make_unique<Value>(123));
 241   Value value(std::move(storage));
 242
 243   Value copied_value(value.Clone());
 244   EXPECT_EQ(value, copied_value);
 245
 246   Value blank;
 247   blank = value.Clone();
 248   EXPECT_EQ(value, blank);
 249 }
 250
 251 TEST(ValuesTest, CopyList) {
 252   Value::ListStorage storage;
 253   storage.emplace_back(123);
 254   Value value(std::move(storage));
 255
 256   Value copied_value(value.Clone());
 257   EXPECT_EQ(value, copied_value);
 258
 259   Value blank;
 260   blank = value.Clone();
 261   EXPECT_EQ(value, blank);
 262 }
 263
 264 // Group of tests for the move constructors and move-assigmnent.
 265 TEST(ValuesTest, MoveBool) {
 266   Value true_value(true);
 267   Value moved_true_value(std::move(true_value));
 268   EXPECT_EQ(Value::Type::BOOLEAN, moved_true_value.type());
 269   EXPECT_TRUE(moved_true_value.GetBool());
 270
 271   Value false_value(false);
 272   Value moved_false_value(std::move(false_value));
 273   EXPECT_EQ(Value::Type::BOOLEAN, moved_false_value.type());
 274   EXPECT_FALSE(moved_false_value.GetBool());
 275
 276   Value blank;
 277
 278   blank = Value(true);
 279   EXPECT_EQ(Value::Type::BOOLEAN, blank.type());
 280   EXPECT_TRUE(blank.GetBool());
 281
 282   blank = Value(false);
 283   EXPECT_EQ(Value::Type::BOOLEAN, blank.type());
 284   EXPECT_FALSE(blank.GetBool());
 285 }
 286
 287 TEST(ValuesTest, MoveInt) {
 288   Value value(74);
 289   Value moved_value(std::move(value));
 290   EXPECT_EQ(Value::Type::INTEGER, moved_value.type());
 291   EXPECT_EQ(74, moved_value.GetInt());
 292
 293   Value blank;
 294
 295   blank = Value(47);
 296   EXPECT_EQ(Value::Type::INTEGER, blank.type());
 297   EXPECT_EQ(47, blank.GetInt());
 298 }
 299
 300 TEST(ValuesTest, MoveDouble) {
 301   Value value(74.896);
 302   Value moved_value(std::move(value));
 303   EXPECT_EQ(Value::Type::DOUBLE, moved_value.type());
 304   EXPECT_EQ(74.896, moved_value.GetDouble());
 305
 306   Value blank;
 307
 308   blank = Value(654.38);
 309   EXPECT_EQ(Value::Type::DOUBLE, blank.type());
 310   EXPECT_EQ(654.38, blank.GetDouble());
 311 }
 312
 313 TEST(ValuesTest, MoveString) {
 314   Value value("foobar");
 315   Value moved_value(std::move(value));
 316   EXPECT_EQ(Value::Type::STRING, moved_value.type());
 317   EXPECT_EQ("foobar", moved_value.GetString());
 318
 319   Value blank;
 320
 321   blank = Value("foobar");
 322   EXPECT_EQ(Value::Type::STRING, blank.type());
 323   EXPECT_EQ("foobar", blank.GetString());
 324 }
 325
 326 TEST(ValuesTest, MoveBinary) {
 327   const Value::BlobStorage buffer = {0xF, 0x0, 0x0, 0xB, 0xA, 0x2};
 328   Value value(buffer);
 329   Value moved_value(std::move(value));
 330   EXPECT_EQ(Value::Type::BINARY, moved_value.type());
 331   EXPECT_EQ(buffer, moved_value.GetBlob());
 332
 333   Value blank;
 334
 335   blank = Value(buffer);
 336   EXPECT_EQ(Value::Type::BINARY, blank.type());
 337   EXPECT_EQ(buffer, blank.GetBlob());
 338 }
 339
 340 TEST(ValuesTest, MoveConstructDictionary) {
 341   Value::DictStorage storage;
 342   storage.emplace("Int", std::make_unique<Value>(123));
 343
 344   Value value(std::move(storage));
 345   Value moved_value(std::move(value));
 346   EXPECT_EQ(Value::Type::DICTIONARY, moved_value.type());
 347   EXPECT_EQ(123, moved_value.FindKey("Int")->GetInt());
 348 }
 349
 350 TEST(ValuesTest, MoveAssignDictionary) {
 351   Value::DictStorage storage;
 352   storage.emplace("Int", std::make_unique<Value>(123));
 353
 354   Value blank;
 355   blank = Value(std::move(storage));
 356   EXPECT_EQ(Value::Type::DICTIONARY, blank.type());
 357   EXPECT_EQ(123, blank.FindKey("Int")->GetInt());
 358 }
 359
 360 TEST(ValuesTest, MoveList) {
 361   Value::ListStorage storage;
 362   storage.emplace_back(123);
 363   Value value(storage);
 364   Value moved_value(std::move(value));
 365   EXPECT_EQ(Value::Type::LIST, moved_value.type());
 366   EXPECT_EQ(123, moved_value.GetList().back().GetInt());
 367
 368   Value blank;
 369   blank = Value(std::move(storage));
 370   EXPECT_EQ(Value::Type::LIST, blank.type());
 371   EXPECT_EQ(123, blank.GetList().back().GetInt());
 372 }
 373
 374 TEST(ValuesTest, FindKey) {
 375   Value::DictStorage storage;
 376   storage.emplace("foo", std::make_unique<Value>("bar"));
 377   Value dict(std::move(storage));
 378   EXPECT_NE(nullptr, dict.FindKey("foo"));
 379   EXPECT_EQ(nullptr, dict.FindKey("baz"));
 380
 381   // Single not found key.
 382   bool found = dict.FindKey("notfound");
 383   EXPECT_FALSE(found);
 384 }
 385
 386 TEST(ValuesTest, FindKeyChangeValue) {
 387   Value::DictStorage storage;
 388   storage.emplace("foo", std::make_unique<Value>("bar"));
 389   Value dict(std::move(storage));
 390   Value* found = dict.FindKey("foo");
 391   EXPECT_NE(nullptr, found);
 392   EXPECT_EQ("bar", found->GetString());
 393
 394   *found = Value(123);
 395   EXPECT_EQ(123, dict.FindKey("foo")->GetInt());
 396 }
 397
 398 TEST(ValuesTest, FindKeyConst) {
 399   Value::DictStorage storage;
 400   storage.emplace("foo", std::make_unique<Value>("bar"));
 401   const Value dict(std::move(storage));
 402   EXPECT_NE(nullptr, dict.FindKey("foo"));
 403   EXPECT_EQ(nullptr, dict.FindKey("baz"));
 404 }
 405
 406 TEST(ValuesTest, FindKeyOfType) {
 407   Value::DictStorage storage;
 408   storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
 409   storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
 410   storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
 411   storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
 412   storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
 413   storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
 414   storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));
 415   storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
 416
 417   Value dict(std::move(storage));
 418   EXPECT_NE(nullptr, dict.FindKeyOfType("null", Value::Type::NONE));
 419   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::BOOLEAN));
 420   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::INTEGER));
 421   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::DOUBLE));
 422   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::STRING));
 423   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::BINARY));
 424   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::LIST));
 425   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::DICTIONARY));
 426
 427   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::NONE));
 428   EXPECT_NE(nullptr, dict.FindKeyOfType("bool", Value::Type::BOOLEAN));
 429   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::INTEGER));
 430   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::DOUBLE));
 431   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::STRING));
 432   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::BINARY));
 433   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::LIST));
 434   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::DICTIONARY));
 435
 436   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::NONE));
 437   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::BOOLEAN));
 438   EXPECT_NE(nullptr, dict.FindKeyOfType("int", Value::Type::INTEGER));
 439   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::DOUBLE));
 440   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::STRING));
 441   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::BINARY));
 442   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::LIST));
 443   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::DICTIONARY));
 444
 445   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::NONE));
 446   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::BOOLEAN));
 447   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::INTEGER));
 448   EXPECT_NE(nullptr, dict.FindKeyOfType("double", Value::Type::DOUBLE));
 449   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::STRING));
 450   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::BINARY));
 451   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::LIST));
 452   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::DICTIONARY));
 453
 454   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::NONE));
 455   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::BOOLEAN));
 456   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::INTEGER));
 457   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::DOUBLE));
 458   EXPECT_NE(nullptr, dict.FindKeyOfType("string", Value::Type::STRING));
 459   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::BINARY));
 460   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::LIST));
 461   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::DICTIONARY));
 462
 463   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::NONE));
 464   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::BOOLEAN));
 465   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::INTEGER));
 466   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::DOUBLE));
 467   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::STRING));
 468   EXPECT_NE(nullptr, dict.FindKeyOfType("blob", Value::Type::BINARY));
 469   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::LIST));
 470   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::DICTIONARY));
 471
 472   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::NONE));
 473   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::BOOLEAN));
 474   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::INTEGER));
 475   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::DOUBLE));
 476   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::STRING));
 477   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::BINARY));
 478   EXPECT_NE(nullptr, dict.FindKeyOfType("list", Value::Type::LIST));
 479   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::DICTIONARY));
 480
 481   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::NONE));
 482   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::BOOLEAN));
 483   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::INTEGER));
 484   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::DOUBLE));
 485   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::STRING));
 486   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::BINARY));
 487   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::LIST));
 488   EXPECT_NE(nullptr, dict.FindKeyOfType("dict", Value::Type::DICTIONARY));
 489 }
 490
 491 TEST(ValuesTest, FindKeyOfTypeConst) {
 492   Value::DictStorage storage;
 493   storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
 494   storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
 495   storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
 496   storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
 497   storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
 498   storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
 499   storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));
 500   storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
 501
 502   const Value dict(std::move(storage));
 503   EXPECT_NE(nullptr, dict.FindKeyOfType("null", Value::Type::NONE));
 504   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::BOOLEAN));
 505   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::INTEGER));
 506   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::DOUBLE));
 507   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::STRING));
 508   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::BINARY));
 509   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::LIST));
 510   EXPECT_EQ(nullptr, dict.FindKeyOfType("null", Value::Type::DICTIONARY));
 511
 512   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::NONE));
 513   EXPECT_NE(nullptr, dict.FindKeyOfType("bool", Value::Type::BOOLEAN));
 514   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::INTEGER));
 515   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::DOUBLE));
 516   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::STRING));
 517   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::BINARY));
 518   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::LIST));
 519   EXPECT_EQ(nullptr, dict.FindKeyOfType("bool", Value::Type::DICTIONARY));
 520
 521   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::NONE));
 522   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::BOOLEAN));
 523   EXPECT_NE(nullptr, dict.FindKeyOfType("int", Value::Type::INTEGER));
 524   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::DOUBLE));
 525   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::STRING));
 526   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::BINARY));
 527   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::LIST));
 528   EXPECT_EQ(nullptr, dict.FindKeyOfType("int", Value::Type::DICTIONARY));
 529
 530   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::NONE));
 531   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::BOOLEAN));
 532   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::INTEGER));
 533   EXPECT_NE(nullptr, dict.FindKeyOfType("double", Value::Type::DOUBLE));
 534   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::STRING));
 535   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::BINARY));
 536   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::LIST));
 537   EXPECT_EQ(nullptr, dict.FindKeyOfType("double", Value::Type::DICTIONARY));
 538
 539   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::NONE));
 540   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::BOOLEAN));
 541   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::INTEGER));
 542   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::DOUBLE));
 543   EXPECT_NE(nullptr, dict.FindKeyOfType("string", Value::Type::STRING));
 544   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::BINARY));
 545   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::LIST));
 546   EXPECT_EQ(nullptr, dict.FindKeyOfType("string", Value::Type::DICTIONARY));
 547
 548   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::NONE));
 549   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::BOOLEAN));
 550   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::INTEGER));
 551   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::DOUBLE));
 552   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::STRING));
 553   EXPECT_NE(nullptr, dict.FindKeyOfType("blob", Value::Type::BINARY));
 554   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::LIST));
 555   EXPECT_EQ(nullptr, dict.FindKeyOfType("blob", Value::Type::DICTIONARY));
 556
 557   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::NONE));
 558   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::BOOLEAN));
 559   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::INTEGER));
 560   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::DOUBLE));
 561   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::STRING));
 562   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::BINARY));
 563   EXPECT_NE(nullptr, dict.FindKeyOfType("list", Value::Type::LIST));
 564   EXPECT_EQ(nullptr, dict.FindKeyOfType("list", Value::Type::DICTIONARY));
 565
 566   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::NONE));
 567   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::BOOLEAN));
 568   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::INTEGER));
 569   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::DOUBLE));
 570   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::STRING));
 571   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::BINARY));
 572   EXPECT_EQ(nullptr, dict.FindKeyOfType("dict", Value::Type::LIST));
 573   EXPECT_NE(nullptr, dict.FindKeyOfType("dict", Value::Type::DICTIONARY));
 574 }
 575
 576 TEST(ValuesTest, FindBoolKey) {
 577   Value::DictStorage storage;
 578   storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
 579   storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
 580   storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
 581   storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
 582   storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
 583   storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
 584   storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));
 585   storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
 586
 587   const Value dict(std::move(storage));
 588   EXPECT_EQ(base::nullopt, dict.FindBoolKey("null"));
 589   EXPECT_NE(base::nullopt, dict.FindBoolKey("bool"));
 590   EXPECT_EQ(base::nullopt, dict.FindBoolKey("int"));
 591   EXPECT_EQ(base::nullopt, dict.FindBoolKey("double"));
 592   EXPECT_EQ(base::nullopt, dict.FindBoolKey("string"));
 593   EXPECT_EQ(base::nullopt, dict.FindBoolKey("blob"));
 594   EXPECT_EQ(base::nullopt, dict.FindBoolKey("list"));
 595   EXPECT_EQ(base::nullopt, dict.FindBoolKey("dist"));
 596 }
 597
 598 TEST(ValuesTest, FindIntKey) {
 599   Value::DictStorage storage;
 600   storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
 601   storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
 602   storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
 603   storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
 604   storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
 605   storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
 606   storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));
 607   storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
 608
 609   const Value dict(std::move(storage));
 610   EXPECT_EQ(base::nullopt, dict.FindIntKey("null"));
 611   EXPECT_EQ(base::nullopt, dict.FindIntKey("bool"));
 612   EXPECT_NE(base::nullopt, dict.FindIntKey("int"));
 613   EXPECT_EQ(base::nullopt, dict.FindIntKey("double"));
 614   EXPECT_EQ(base::nullopt, dict.FindIntKey("string"));
 615   EXPECT_EQ(base::nullopt, dict.FindIntKey("blob"));
 616   EXPECT_EQ(base::nullopt, dict.FindIntKey("list"));
 617   EXPECT_EQ(base::nullopt, dict.FindIntKey("dist"));
 618 }
 619
 620 TEST(ValuesTest, FindDoubleKey) {
 621   Value::DictStorage storage;
 622   storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
 623   storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
 624   storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
 625   storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
 626   storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
 627   storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
 628   storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));
 629   storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
 630
 631   const Value dict(std::move(storage));
 632   EXPECT_EQ(base::nullopt, dict.FindDoubleKey("null"));
 633   EXPECT_EQ(base::nullopt, dict.FindDoubleKey("bool"));
 634   EXPECT_EQ(base::nullopt, dict.FindDoubleKey("int"));
 635   EXPECT_NE(base::nullopt, dict.FindDoubleKey("double"));
 636   EXPECT_EQ(base::nullopt, dict.FindDoubleKey("string"));
 637   EXPECT_EQ(base::nullopt, dict.FindDoubleKey("blob"));
 638   EXPECT_EQ(base::nullopt, dict.FindDoubleKey("list"));
 639   EXPECT_EQ(base::nullopt, dict.FindDoubleKey("dist"));
 640 }
 641
 642 TEST(ValuesTest, FindStringKey) {
 643   Value::DictStorage storage;
 644   storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
 645   storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
 646   storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
 647   storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
 648   storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
 649   storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
 650   storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));
 651   storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
 652
 653   const Value dict(std::move(storage));
 654   EXPECT_EQ(nullptr, dict.FindStringKey("null"));
 655   EXPECT_EQ(nullptr, dict.FindStringKey("bool"));
 656   EXPECT_EQ(nullptr, dict.FindStringKey("int"));
 657   EXPECT_EQ(nullptr, dict.FindStringKey("double"));
 658   EXPECT_NE(nullptr, dict.FindStringKey("string"));
 659   EXPECT_EQ(nullptr, dict.FindStringKey("blob"));
 660   EXPECT_EQ(nullptr, dict.FindStringKey("list"));
 661   EXPECT_EQ(nullptr, dict.FindStringKey("dist"));
 662 }
 663
 664 TEST(ValuesTest, SetKey) {
 665   Value::DictStorage storage;
 666   storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
 667   storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
 668   storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
 669   storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
 670   storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
 671   storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
 672   storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));
 673   storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
 674
 675   Value dict(Value::Type::DICTIONARY);
 676   dict.SetKey(StringPiece("null"), Value(Value::Type::NONE));
 677   dict.SetKey(StringPiece("bool"), Value(Value::Type::BOOLEAN));
 678   dict.SetKey(std::string("int"), Value(Value::Type::INTEGER));
 679   dict.SetKey(std::string("double"), Value(Value::Type::DOUBLE));
 680   dict.SetKey(std::string("string"), Value(Value::Type::STRING));
 681   dict.SetKey("blob", Value(Value::Type::BINARY));
 682   dict.SetKey("list", Value(Value::Type::LIST));
 683   dict.SetKey("dict", Value(Value::Type::DICTIONARY));
 684
 685   EXPECT_EQ(Value(std::move(storage)), dict);
 686 }
 687
 688 TEST(ValuesTest, FindPath) {
 689   // Construct a dictionary path {root}.foo.bar = 123
 690   Value foo(Value::Type::DICTIONARY);
 691   foo.SetKey("bar", Value(123));
 692
 693   Value root(Value::Type::DICTIONARY);
 694   root.SetKey("foo", std::move(foo));
 695
 696   // No key (stupid but well-defined and takes work to prevent).
 697   Value* found = root.FindPath(std::vector<StringPiece>{});
 698   EXPECT_EQ(&root, found);
 699
 700   // Double key, second not found.
 701   found = root.FindPath(std::vector<StringPiece>{"foo", "notfound"});
 702   EXPECT_FALSE(found);
 703
 704   // Double key, found.
 705   found = root.FindPath(std::vector<StringPiece>{"foo", "bar"});
 706   EXPECT_TRUE(found);
 707   EXPECT_TRUE(found->is_int());
 708   EXPECT_EQ(123, found->GetInt());
 709 }
 710
 711 TEST(ValuesTest, SetPath) {
 712   Value root(Value::Type::DICTIONARY);
 713
 714   Value* inserted = root.SetPath({"one", "two"}, Value(123));
 715   Value* found = root.FindPathOfType({"one", "two"}, Value::Type::INTEGER);
 716   ASSERT_TRUE(found);
 717   EXPECT_EQ(inserted, found);
 718   EXPECT_EQ(123, found->GetInt());
 719
 720   inserted = root.SetPath(std::vector<StringPiece>{"foo", "bar"}, Value(123));
 721   found = root.FindPathOfType({"foo", "bar"}, Value::Type::INTEGER);
 722   ASSERT_TRUE(found);
 723   EXPECT_EQ(inserted, found);
 724   EXPECT_EQ(123, found->GetInt());
 725
 726   // Overwrite with a different value.
 727   root.SetPath({"foo", "bar"}, Value("hello"));
 728   found = root.FindPathOfType(std::vector<StringPiece>{"foo", "bar"},
 729                               Value::Type::STRING);
 730   ASSERT_TRUE(found);
 731   EXPECT_EQ("hello", found->GetString());
 732
 733   // Can't change existing non-dictionary keys to dictionaries.
 734   found =
 735       root.SetPath(std::vector<StringPiece>{"foo", "bar", "baz"}, Value(123));
 736   EXPECT_FALSE(found);
 737 }
 738
 739 TEST(ValuesTest, RemoveKey) {
 740   Value root(Value::Type::DICTIONARY);
 741   root.SetKey("one", Value(123));
 742
 743   // Removal of missing key should fail.
 744   EXPECT_FALSE(root.RemoveKey("two"));
 745
 746   // Removal of existing key should succeed.
 747   EXPECT_TRUE(root.RemoveKey("one"));
 748
 749   // Second removal of previously existing key should fail.
 750   EXPECT_FALSE(root.RemoveKey("one"));
 751 }
 752
 753 TEST(ValuesTest, RemovePath) {
 754   Value root(Value::Type::DICTIONARY);
 755   root.SetPath({"one", "two", "three"}, Value(123));
 756
 757   // Removal of missing key should fail.
 758   EXPECT_FALSE(root.RemovePath({"one", "two", "four"}));
 759
 760   // Removal of existing key should succeed.
 761   EXPECT_TRUE(root.RemovePath({"one", "two", "three"}));
 762
 763   // Second removal of previously existing key should fail.
 764   EXPECT_FALSE(root.RemovePath({"one", "two", "three"}));
 765
 766   // Intermediate empty dictionaries should be cleared.
 767   EXPECT_FALSE(root.FindKey("one"));
 768
 769   root.SetPath({"one", "two", "three"}, Value(123));
 770   root.SetPath({"one", "two", "four"}, Value(124));
 771
 772   EXPECT_TRUE(root.RemovePath(std::vector<StringPiece>{"one", "two", "three"}));
 773   // Intermediate non-empty dictionaries should be kept.
 774   EXPECT_TRUE(root.FindKey("one"));
 775   EXPECT_TRUE(root.FindPath({"one", "two"}));
 776   EXPECT_TRUE(root.FindPath({"one", "two", "four"}));
 777 }
 778
 779 TEST(ValuesTest, Basic) {
 780   // Test basic dictionary getting/setting
 781   DictionaryValue settings;
 782   std::string homepage = "http://google.com";
 783   ASSERT_FALSE(settings.GetString("global.homepage", &homepage));
 784   ASSERT_EQ(std::string("http://google.com"), homepage);
 785
 786   ASSERT_FALSE(settings.Get("global", nullptr));
 787   settings.SetBoolean("global", true);
 788   ASSERT_TRUE(settings.Get("global", nullptr));
 789   settings.SetString("global.homepage", "http://scurvy.com");
 790   ASSERT_TRUE(settings.Get("global", nullptr));
 791   homepage = "http://google.com";
 792   ASSERT_TRUE(settings.GetString("global.homepage", &homepage));
 793   ASSERT_EQ(std::string("http://scurvy.com"), homepage);
 794
 795   // Test storing a dictionary in a list.
 796   ListValue* toolbar_bookmarks;
 797   ASSERT_FALSE(
 798     settings.GetList("global.toolbar.bookmarks", &toolbar_bookmarks));
 799
 800   std::unique_ptr<ListValue> new_toolbar_bookmarks(new ListValue);
 801   settings.Set("global.toolbar.bookmarks", std::move(new_toolbar_bookmarks));
 802   ASSERT_TRUE(settings.GetList("global.toolbar.bookmarks", &toolbar_bookmarks));
 803
 804   std::unique_ptr<DictionaryValue> new_bookmark(new DictionaryValue);
 805   new_bookmark->SetString("name", "Froogle");
 806   new_bookmark->SetString("url", "http://froogle.com");
 807   toolbar_bookmarks->Append(std::move(new_bookmark));
 808
 809   ListValue* bookmark_list;
 810   ASSERT_TRUE(settings.GetList("global.toolbar.bookmarks", &bookmark_list));
 811   DictionaryValue* bookmark;
 812   ASSERT_EQ(1U, bookmark_list->GetSize());
 813   ASSERT_TRUE(bookmark_list->GetDictionary(0, &bookmark));
 814   std::string bookmark_name = "Unnamed";
 815   ASSERT_TRUE(bookmark->GetString("name", &bookmark_name));
 816   ASSERT_EQ(std::string("Froogle"), bookmark_name);
 817   std::string bookmark_url;
 818   ASSERT_TRUE(bookmark->GetString("url", &bookmark_url));
 819   ASSERT_EQ(std::string("http://froogle.com"), bookmark_url);
 820 }
 821
 822 TEST(ValuesTest, List) {
 823   std::unique_ptr<ListValue> mixed_list(new ListValue());
 824   mixed_list->Set(0, std::make_unique<Value>(true));
 825   mixed_list->Set(1, std::make_unique<Value>(42));
 826   mixed_list->Set(2, std::make_unique<Value>(88.8));
 827   mixed_list->Set(3, std::make_unique<Value>("foo"));
 828   ASSERT_EQ(4u, mixed_list->GetSize());
 829
 830   Value* value = nullptr;
 831   bool bool_value = false;
 832   int int_value = 0;
 833   double double_value = 0.0;
 834   std::string string_value;
 835
 836   ASSERT_FALSE(mixed_list->Get(4, &value));
 837
 838   ASSERT_FALSE(mixed_list->GetInteger(0, &int_value));
 839   ASSERT_EQ(0, int_value);
 840   ASSERT_FALSE(mixed_list->GetBoolean(1, &bool_value));
 841   ASSERT_FALSE(bool_value);
 842   ASSERT_FALSE(mixed_list->GetString(2, &string_value));
 843   ASSERT_EQ("", string_value);
 844   ASSERT_FALSE(mixed_list->GetInteger(2, &int_value));
 845   ASSERT_EQ(0, int_value);
 846   ASSERT_FALSE(mixed_list->GetBoolean(3, &bool_value));
 847   ASSERT_FALSE(bool_value);
 848
 849   ASSERT_TRUE(mixed_list->GetBoolean(0, &bool_value));
 850   ASSERT_TRUE(bool_value);
 851   ASSERT_TRUE(mixed_list->GetInteger(1, &int_value));
 852   ASSERT_EQ(42, int_value);
 853   // implicit conversion from Integer to Double should be possible.
 854   ASSERT_TRUE(mixed_list->GetDouble(1, &double_value));
 855   ASSERT_EQ(42, double_value);
 856   ASSERT_TRUE(mixed_list->GetDouble(2, &double_value));
 857   ASSERT_EQ(88.8, double_value);
 858   ASSERT_TRUE(mixed_list->GetString(3, &string_value));
 859   ASSERT_EQ("foo", string_value);
 860
 861   // Try searching in the mixed list.
 862   base::Value sought_value(42);
 863   base::Value not_found_value(false);
 864
 865   ASSERT_NE(mixed_list->end(), mixed_list->Find(sought_value));
 866   ASSERT_TRUE((*mixed_list->Find(sought_value)).GetAsInteger(&int_value));
 867   ASSERT_EQ(42, int_value);
 868   ASSERT_EQ(mixed_list->end(), mixed_list->Find(not_found_value));
 869 }
 870
 871 TEST(ValuesTest, BinaryValue) {
 872   // Default constructor creates a BinaryValue with a buffer of size 0.
 873   auto binary = std::make_unique<Value>(Value::Type::BINARY);
 874   ASSERT_TRUE(binary.get());
 875   ASSERT_TRUE(binary->GetBlob().empty());
 876
 877   // Test the common case of a non-empty buffer
 878   Value::BlobStorage buffer(15);
 879   uint8_t* original_buffer = buffer.data();
 880   binary.reset(new Value(std::move(buffer)));
 881   ASSERT_TRUE(binary.get());
 882   ASSERT_TRUE(binary->GetBlob().data());
 883   ASSERT_EQ(original_buffer, binary->GetBlob().data());
 884   ASSERT_EQ(15U, binary->GetBlob().size());
 885
 886   char stack_buffer[42];
 887   memset(stack_buffer, '!', 42);
 888   binary = Value::CreateWithCopiedBuffer(stack_buffer, 42);
 889   ASSERT_TRUE(binary.get());
 890   ASSERT_TRUE(binary->GetBlob().data());
 891   ASSERT_NE(stack_buffer,
 892             reinterpret_cast<const char*>(binary->GetBlob().data()));
 893   ASSERT_EQ(42U, binary->GetBlob().size());
 894   ASSERT_EQ(0, memcmp(stack_buffer, binary->GetBlob().data(),
 895                       binary->GetBlob().size()));
 896 }
 897
 898 TEST(ValuesTest, StringValue) {
 899   // Test overloaded StringValue constructor.
 900   std::unique_ptr<Value> narrow_value(new Value("narrow"));
 901   ASSERT_TRUE(narrow_value.get());
 902   ASSERT_TRUE(narrow_value->is_string());
 903   std::unique_ptr<Value> utf16_value(new Value(ASCIIToUTF16("utf16")));
 904   ASSERT_TRUE(utf16_value.get());
 905   ASSERT_TRUE(utf16_value->is_string());
 906
 907   // Test overloaded GetAsString.
 908   std::string narrow = "http://google.com";
 909   string16 utf16 = ASCIIToUTF16("http://google.com");
 910   const Value* string_value = nullptr;
 911   ASSERT_TRUE(narrow_value->GetAsString(&narrow));
 912   ASSERT_TRUE(narrow_value->GetAsString(&utf16));
 913   ASSERT_TRUE(narrow_value->GetAsString(&string_value));
 914   ASSERT_EQ(std::string("narrow"), narrow);
 915   ASSERT_EQ(ASCIIToUTF16("narrow"), utf16);
 916   ASSERT_EQ(string_value->GetString(), narrow);
 917
 918   ASSERT_TRUE(utf16_value->GetAsString(&narrow));
 919   ASSERT_TRUE(utf16_value->GetAsString(&utf16));
 920   ASSERT_TRUE(utf16_value->GetAsString(&string_value));
 921   ASSERT_EQ(std::string("utf16"), narrow);
 922   ASSERT_EQ(ASCIIToUTF16("utf16"), utf16);
 923   ASSERT_EQ(string_value->GetString(), narrow);
 924
 925   // Don't choke on NULL values.
 926   ASSERT_TRUE(narrow_value->GetAsString(static_cast<string16*>(nullptr)));
 927   ASSERT_TRUE(narrow_value->GetAsString(static_cast<std::string*>(nullptr)));
 928   ASSERT_TRUE(narrow_value->GetAsString(static_cast<const Value**>(nullptr)));
 929 }
 930
 931 TEST(ValuesTest, ListDeletion) {
 932   ListValue list;
 933   list.Append(std::make_unique<Value>());
 934   EXPECT_FALSE(list.empty());
 935   list.Clear();
 936   EXPECT_TRUE(list.empty());
 937 }
 938
 939 TEST(ValuesTest, ListRemoval) {
 940   std::unique_ptr<Value> removed_item;
 941
 942   {
 943     ListValue list;
 944     list.Append(std::make_unique<Value>());
 945     EXPECT_EQ(1U, list.GetSize());
 946     EXPECT_FALSE(list.Remove(std::numeric_limits<size_t>::max(),
 947                              &removed_item));
 948     EXPECT_FALSE(list.Remove(1, &removed_item));
 949     EXPECT_TRUE(list.Remove(0, &removed_item));
 950     ASSERT_TRUE(removed_item);
 951     EXPECT_EQ(0U, list.GetSize());
 952   }
 953   removed_item.reset();
 954
 955   {
 956     ListValue list;
 957     list.Append(std::make_unique<Value>());
 958     EXPECT_TRUE(list.Remove(0, nullptr));
 959     EXPECT_EQ(0U, list.GetSize());
 960   }
 961
 962   {
 963     ListValue list;
 964     auto value = std::make_unique<Value>();
 965     Value original_value = value->Clone();
 966     list.Append(std::move(value));
 967     size_t index = 0;
 968     list.Remove(original_value, &index);
 969     EXPECT_EQ(0U, index);
 970     EXPECT_EQ(0U, list.GetSize());
 971   }
 972 }
 973
 974 TEST(ValuesTest, DictionaryDeletion) {
 975   std::string key = "test";
 976   DictionaryValue dict;
 977   dict.Set(key, std::make_unique<Value>());
 978   EXPECT_FALSE(dict.empty());
 979   EXPECT_FALSE(dict.DictEmpty());
 980   EXPECT_EQ(1U, dict.DictSize());
 981   dict.Clear();
 982   EXPECT_TRUE(dict.empty());
 983   EXPECT_TRUE(dict.DictEmpty());
 984   EXPECT_EQ(0U, dict.DictSize());
 985 }
 986
 987 TEST(ValuesTest, DictionarySetReturnsPointer) {
 988   {
 989     DictionaryValue dict;
 990     Value* blank_ptr = dict.Set("foo.bar", std::make_unique<base::Value>());
 991     EXPECT_EQ(Value::Type::NONE, blank_ptr->type());
 992   }
 993
 994   {
 995     DictionaryValue dict;
 996     Value* blank_ptr = dict.SetWithoutPathExpansion(
 997         "foo.bar", std::make_unique<base::Value>());
 998     EXPECT_EQ(Value::Type::NONE, blank_ptr->type());
 999   }
1000
1001   {
1002     DictionaryValue dict;
1003     Value* int_ptr = dict.SetInteger("foo.bar", 42);
1004     EXPECT_EQ(Value::Type::INTEGER, int_ptr->type());
1005     EXPECT_EQ(42, int_ptr->GetInt());
1006   }
1007
1008   {
1009     DictionaryValue dict;
1010     Value* double_ptr = dict.SetDouble("foo.bar", 3.142);
1011     EXPECT_EQ(Value::Type::DOUBLE, double_ptr->type());
1012     EXPECT_EQ(3.142, double_ptr->GetDouble());
1013   }
1014
1015   {
1016     DictionaryValue dict;
1017     Value* string_ptr = dict.SetString("foo.bar", "foo");
1018     EXPECT_EQ(Value::Type::STRING, string_ptr->type());
1019     EXPECT_EQ("foo", string_ptr->GetString());
1020   }
1021
1022   {
1023     DictionaryValue dict;
1024     Value* string16_ptr = dict.SetString("foo.bar", ASCIIToUTF16("baz"));
1025     EXPECT_EQ(Value::Type::STRING, string16_ptr->type());
1026     EXPECT_EQ("baz", string16_ptr->GetString());
1027   }
1028
1029   {
1030     DictionaryValue dict;
1031     DictionaryValue* dict_ptr = dict.SetDictionary(
1032         "foo.bar", std::make_unique<base::DictionaryValue>());
1033     EXPECT_EQ(Value::Type::DICTIONARY, dict_ptr->type());
1034   }
1035
1036   {
1037     DictionaryValue dict;
1038     ListValue* list_ptr =
1039         dict.SetList("foo.bar", std::make_unique<base::ListValue>());
1040     EXPECT_EQ(Value::Type::LIST, list_ptr->type());
1041   }
1042 }
1043
1044 TEST(ValuesTest, DictionaryRemoval) {
1045   std::string key = "test";
1046   std::unique_ptr<Value> removed_item;
1047
1048   {
1049     DictionaryValue dict;
1050     EXPECT_EQ(0U, dict.DictSize());
1051     EXPECT_TRUE(dict.DictEmpty());
1052     dict.Set(key, std::make_unique<Value>());
1053     EXPECT_TRUE(dict.HasKey(key));
1054     EXPECT_FALSE(dict.Remove("absent key", &removed_item));
1055     EXPECT_EQ(1U, dict.DictSize());
1056     EXPECT_FALSE(dict.DictEmpty());
1057
1058     EXPECT_TRUE(dict.Remove(key, &removed_item));
1059     EXPECT_FALSE(dict.HasKey(key));
1060     ASSERT_TRUE(removed_item);
1061     EXPECT_EQ(0U, dict.DictSize());
1062     EXPECT_TRUE(dict.DictEmpty());
1063   }
1064
1065   {
1066     DictionaryValue dict;
1067     dict.Set(key, std::make_unique<Value>());
1068     EXPECT_TRUE(dict.HasKey(key));
1069     EXPECT_TRUE(dict.Remove(key, nullptr));
1070     EXPECT_FALSE(dict.HasKey(key));
1071   }
1072 }
1073
1074 TEST(ValuesTest, DictionaryWithoutPathExpansion) {
1075   DictionaryValue dict;
1076   dict.Set("this.is.expanded", std::make_unique<Value>());
1077   dict.SetWithoutPathExpansion("this.isnt.expanded", std::make_unique<Value>());
1078
1079   EXPECT_FALSE(dict.HasKey("this.is.expanded"));
1080   EXPECT_TRUE(dict.HasKey("this"));
1081   Value* value1;
1082   EXPECT_TRUE(dict.Get("this", &value1));
1083   DictionaryValue* value2;
1084   ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2));
1085   EXPECT_EQ(value1, value2);
1086   EXPECT_EQ(1U, value2->size());
1087
1088   EXPECT_TRUE(dict.HasKey("this.isnt.expanded"));
1089   Value* value3;
1090   EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3));
1091   Value* value4;
1092   ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4));
1093   EXPECT_EQ(Value::Type::NONE, value4->type());
1094 }
1095
1096 // Tests the deprecated version of SetWithoutPathExpansion.
1097 // TODO(estade): remove.
1098 TEST(ValuesTest, DictionaryWithoutPathExpansionDeprecated) {
1099   DictionaryValue dict;
1100   dict.Set("this.is.expanded", std::make_unique<Value>());
1101   dict.SetWithoutPathExpansion("this.isnt.expanded", std::make_unique<Value>());
1102
1103   EXPECT_FALSE(dict.HasKey("this.is.expanded"));
1104   EXPECT_TRUE(dict.HasKey("this"));
1105   Value* value1;
1106   EXPECT_TRUE(dict.Get("this", &value1));
1107   DictionaryValue* value2;
1108   ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2));
1109   EXPECT_EQ(value1, value2);
1110   EXPECT_EQ(1U, value2->size());
1111
1112   EXPECT_TRUE(dict.HasKey("this.isnt.expanded"));
1113   Value* value3;
1114   EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3));
1115   Value* value4;
1116   ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4));
1117   EXPECT_EQ(Value::Type::NONE, value4->type());
1118 }
1119
1120 TEST(ValuesTest, DictionaryRemovePath) {
1121   DictionaryValue dict;
1122   dict.SetInteger("a.long.way.down", 1);
1123   dict.SetBoolean("a.long.key.path", true);
1124
1125   std::unique_ptr<Value> removed_item;
1126   EXPECT_TRUE(dict.RemovePath("a.long.way.down", &removed_item));
1127   ASSERT_TRUE(removed_item);
1128   EXPECT_TRUE(removed_item->is_int());
1129   EXPECT_FALSE(dict.HasKey("a.long.way.down"));
1130   EXPECT_FALSE(dict.HasKey("a.long.way"));
1131   EXPECT_TRUE(dict.Get("a.long.key.path", nullptr));
1132
1133   removed_item.reset();
1134   EXPECT_FALSE(dict.RemovePath("a.long.way.down", &removed_item));
1135   EXPECT_FALSE(removed_item);
1136   EXPECT_TRUE(dict.Get("a.long.key.path", nullptr));
1137
1138   removed_item.reset();
1139   EXPECT_TRUE(dict.RemovePath("a.long.key.path", &removed_item));
1140   ASSERT_TRUE(removed_item);
1141   EXPECT_TRUE(removed_item->is_bool());
1142   EXPECT_TRUE(dict.empty());
1143 }
1144
1145 TEST(ValuesTest, DeepCopy) {
1146   DictionaryValue original_dict;
1147   Value* null_weak = original_dict.Set("null", std::make_unique<Value>());
1148   Value* bool_weak = original_dict.Set("bool", std::make_unique<Value>(true));
1149   Value* int_weak = original_dict.Set("int", std::make_unique<Value>(42));
1150   Value* double_weak =
1151       original_dict.Set("double", std::make_unique<Value>(3.14));
1152   Value* string_weak =
1153       original_dict.Set("string", std::make_unique<Value>("hello"));
1154   Value* string16_weak = original_dict.Set(
1155       "string16", std::make_unique<Value>(ASCIIToUTF16("hello16")));
1156
1157   Value* binary_weak = original_dict.Set(
1158       "binary", std::make_unique<Value>(Value::BlobStorage(42, '!')));
1159
1160   Value::ListStorage storage;
1161   storage.emplace_back(0);
1162   storage.emplace_back(1);
1163   Value* list_weak =
1164       original_dict.Set("list", std::make_unique<Value>(std::move(storage)));
1165   Value* list_element_0_weak = &list_weak->GetList()[0];
1166   Value* list_element_1_weak = &list_weak->GetList()[1];
1167
1168   DictionaryValue* dict_weak = original_dict.SetDictionary(
1169       "dictionary", std::make_unique<DictionaryValue>());
1170   dict_weak->SetString("key", "value");
1171
1172   auto copy_dict = original_dict.CreateDeepCopy();
1173   ASSERT_TRUE(copy_dict.get());
1174   ASSERT_NE(copy_dict.get(), &original_dict);
1175
1176   Value* copy_null = nullptr;
1177   ASSERT_TRUE(copy_dict->Get("null", &copy_null));
1178   ASSERT_TRUE(copy_null);
1179   ASSERT_NE(copy_null, null_weak);
1180   ASSERT_TRUE(copy_null->is_none());
1181
1182   Value* copy_bool = nullptr;
1183   ASSERT_TRUE(copy_dict->Get("bool", &copy_bool));
1184   ASSERT_TRUE(copy_bool);
1185   ASSERT_NE(copy_bool, bool_weak);
1186   ASSERT_TRUE(copy_bool->is_bool());
1187   bool copy_bool_value = false;
1188   ASSERT_TRUE(copy_bool->GetAsBoolean(&copy_bool_value));
1189   ASSERT_TRUE(copy_bool_value);
1190
1191   Value* copy_int = nullptr;
1192   ASSERT_TRUE(copy_dict->Get("int", &copy_int));
1193   ASSERT_TRUE(copy_int);
1194   ASSERT_NE(copy_int, int_weak);
1195   ASSERT_TRUE(copy_int->is_int());
1196   int copy_int_value = 0;
1197   ASSERT_TRUE(copy_int->GetAsInteger(&copy_int_value));
1198   ASSERT_EQ(42, copy_int_value);
1199
1200   Value* copy_double = nullptr;
1201   ASSERT_TRUE(copy_dict->Get("double", &copy_double));
1202   ASSERT_TRUE(copy_double);
1203   ASSERT_NE(copy_double, double_weak);
1204   ASSERT_TRUE(copy_double->is_double());
1205   double copy_double_value = 0;
1206   ASSERT_TRUE(copy_double->GetAsDouble(&copy_double_value));
1207   ASSERT_EQ(3.14, copy_double_value);
1208
1209   Value* copy_string = nullptr;
1210   ASSERT_TRUE(copy_dict->Get("string", &copy_string));
1211   ASSERT_TRUE(copy_string);
1212   ASSERT_NE(copy_string, string_weak);
1213   ASSERT_TRUE(copy_string->is_string());
1214   std::string copy_string_value;
1215   string16 copy_string16_value;
1216   ASSERT_TRUE(copy_string->GetAsString(&copy_string_value));
1217   ASSERT_TRUE(copy_string->GetAsString(&copy_string16_value));
1218   ASSERT_EQ(std::string("hello"), copy_string_value);
1219   ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value);
1220
1221   Value* copy_string16 = nullptr;
1222   ASSERT_TRUE(copy_dict->Get("string16", &copy_string16));
1223   ASSERT_TRUE(copy_string16);
1224   ASSERT_NE(copy_string16, string16_weak);
1225   ASSERT_TRUE(copy_string16->is_string());
1226   ASSERT_TRUE(copy_string16->GetAsString(&copy_string_value));
1227   ASSERT_TRUE(copy_string16->GetAsString(&copy_string16_value));
1228   ASSERT_EQ(std::string("hello16"), copy_string_value);
1229   ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value);
1230
1231   Value* copy_binary = nullptr;
1232   ASSERT_TRUE(copy_dict->Get("binary", &copy_binary));
1233   ASSERT_TRUE(copy_binary);
1234   ASSERT_NE(copy_binary, binary_weak);
1235   ASSERT_TRUE(copy_binary->is_blob());
1236   ASSERT_NE(binary_weak->GetBlob().data(), copy_binary->GetBlob().data());
1237   ASSERT_EQ(binary_weak->GetBlob(), copy_binary->GetBlob());
1238
1239   Value* copy_value = nullptr;
1240   ASSERT_TRUE(copy_dict->Get("list", &copy_value));
1241   ASSERT_TRUE(copy_value);
1242   ASSERT_NE(copy_value, list_weak);
1243   ASSERT_TRUE(copy_value->is_list());
1244   ListValue* copy_list = nullptr;
1245   ASSERT_TRUE(copy_value->GetAsList(&copy_list));
1246   ASSERT_TRUE(copy_list);
1247   ASSERT_EQ(2U, copy_list->GetSize());
1248
1249   Value* copy_list_element_0;
1250   ASSERT_TRUE(copy_list->Get(0, &copy_list_element_0));
1251   ASSERT_TRUE(copy_list_element_0);
1252   ASSERT_NE(copy_list_element_0, list_element_0_weak);
1253   int copy_list_element_0_value;
1254   ASSERT_TRUE(copy_list_element_0->GetAsInteger(&copy_list_element_0_value));
1255   ASSERT_EQ(0, copy_list_element_0_value);
1256
1257   Value* copy_list_element_1;
1258   ASSERT_TRUE(copy_list->Get(1, &copy_list_element_1));
1259   ASSERT_TRUE(copy_list_element_1);
1260   ASSERT_NE(copy_list_element_1, list_element_1_weak);
1261   int copy_list_element_1_value;
1262   ASSERT_TRUE(copy_list_element_1->GetAsInteger(&copy_list_element_1_value));
1263   ASSERT_EQ(1, copy_list_element_1_value);
1264
1265   copy_value = nullptr;
1266   ASSERT_TRUE(copy_dict->Get("dictionary", &copy_value));
1267   ASSERT_TRUE(copy_value);
1268   ASSERT_NE(copy_value, dict_weak);
1269   ASSERT_TRUE(copy_value->is_dict());
1270   DictionaryValue* copy_nested_dictionary = nullptr;
1271   ASSERT_TRUE(copy_value->GetAsDictionary(&copy_nested_dictionary));
1272   ASSERT_TRUE(copy_nested_dictionary);
1273   EXPECT_TRUE(copy_nested_dictionary->HasKey("key"));
1274 }
1275
1276 TEST(ValuesTest, Equals) {
1277   auto null1 = std::make_unique<Value>();
1278   auto null2 = std::make_unique<Value>();
1279   EXPECT_NE(null1.get(), null2.get());
1280   EXPECT_EQ(*null1, *null2);
1281
1282   Value boolean(false);
1283   EXPECT_NE(*null1, boolean);
1284
1285   DictionaryValue dv;
1286   dv.SetBoolean("a", false);
1287   dv.SetInteger("b", 2);
1288   dv.SetDouble("c", 2.5);
1289   dv.SetString("d1", "string");
1290   dv.SetString("d2", ASCIIToUTF16("http://google.com"));
1291   dv.Set("e", std::make_unique<Value>());
1292
1293   auto copy = dv.CreateDeepCopy();
1294   EXPECT_EQ(dv, *copy);
1295
1296   std::unique_ptr<ListValue> list(new ListValue);
1297   list->Append(std::make_unique<Value>());
1298   list->Append(std::make_unique<DictionaryValue>());
1299   auto list_copy = std::make_unique<Value>(list->Clone());
1300
1301   ListValue* list_weak = dv.SetList("f", std::move(list));
1302   EXPECT_NE(dv, *copy);
1303   copy->Set("f", std::move(list_copy));
1304   EXPECT_EQ(dv, *copy);
1305
1306   list_weak->Append(std::make_unique<Value>(true));
1307   EXPECT_NE(dv, *copy);
1308
1309   // Check if Equals detects differences in only the keys.
1310   copy = dv.CreateDeepCopy();
1311   EXPECT_EQ(dv, *copy);
1312   copy->Remove("a", nullptr);
1313   copy->SetBoolean("aa", false);
1314   EXPECT_NE(dv, *copy);
1315 }
1316
1317 TEST(ValuesTest, Comparisons) {
1318   // Test None Values.
1319   Value null1;
1320   Value null2;
1321   EXPECT_EQ(null1, null2);
1322   EXPECT_FALSE(null1 != null2);
1323   EXPECT_FALSE(null1 < null2);
1324   EXPECT_FALSE(null1 > null2);
1325   EXPECT_LE(null1, null2);
1326   EXPECT_GE(null1, null2);
1327
1328   // Test Bool Values.
1329   Value bool1(false);
1330   Value bool2(true);
1331   EXPECT_FALSE(bool1 == bool2);
1332   EXPECT_NE(bool1, bool2);
1333   EXPECT_LT(bool1, bool2);
1334   EXPECT_FALSE(bool1 > bool2);
1335   EXPECT_LE(bool1, bool2);
1336   EXPECT_FALSE(bool1 >= bool2);
1337
1338   // Test Int Values.
1339   Value int1(1);
1340   Value int2(2);
1341   EXPECT_FALSE(int1 == int2);
1342   EXPECT_NE(int1, int2);
1343   EXPECT_LT(int1, int2);
1344   EXPECT_FALSE(int1 > int2);
1345   EXPECT_LE(int1, int2);
1346   EXPECT_FALSE(int1 >= int2);
1347
1348   // Test Double Values.
1349   Value double1(1.0);
1350   Value double2(2.0);
1351   EXPECT_FALSE(double1 == double2);
1352   EXPECT_NE(double1, double2);
1353   EXPECT_LT(double1, double2);
1354   EXPECT_FALSE(double1 > double2);
1355   EXPECT_LE(double1, double2);
1356   EXPECT_FALSE(double1 >= double2);
1357
1358   // Test String Values.
1359   Value string1("1");
1360   Value string2("2");
1361   EXPECT_FALSE(string1 == string2);
1362   EXPECT_NE(string1, string2);
1363   EXPECT_LT(string1, string2);
1364   EXPECT_FALSE(string1 > string2);
1365   EXPECT_LE(string1, string2);
1366   EXPECT_FALSE(string1 >= string2);
1367
1368   // Test Binary Values.
1369   Value binary1(Value::BlobStorage{0x01});
1370   Value binary2(Value::BlobStorage{0x02});
1371   EXPECT_FALSE(binary1 == binary2);
1372   EXPECT_NE(binary1, binary2);
1373   EXPECT_LT(binary1, binary2);
1374   EXPECT_FALSE(binary1 > binary2);
1375   EXPECT_LE(binary1, binary2);
1376   EXPECT_FALSE(binary1 >= binary2);
1377
1378   // Test Empty List Values.
1379   ListValue null_list1;
1380   ListValue null_list2;
1381   EXPECT_EQ(null_list1, null_list2);
1382   EXPECT_FALSE(null_list1 != null_list2);
1383   EXPECT_FALSE(null_list1 < null_list2);
1384   EXPECT_FALSE(null_list1 > null_list2);
1385   EXPECT_LE(null_list1, null_list2);
1386   EXPECT_GE(null_list1, null_list2);
1387
1388   // Test Non Empty List Values.
1389   ListValue int_list1;
1390   ListValue int_list2;
1391   int_list1.AppendInteger(1);
1392   int_list2.AppendInteger(2);
1393   EXPECT_FALSE(int_list1 == int_list2);
1394   EXPECT_NE(int_list1, int_list2);
1395   EXPECT_LT(int_list1, int_list2);
1396   EXPECT_FALSE(int_list1 > int_list2);
1397   EXPECT_LE(int_list1, int_list2);
1398   EXPECT_FALSE(int_list1 >= int_list2);
1399
1400   // Test Empty Dict Values.
1401   DictionaryValue null_dict1;
1402   DictionaryValue null_dict2;
1403   EXPECT_EQ(null_dict1, null_dict2);
1404   EXPECT_FALSE(null_dict1 != null_dict2);
1405   EXPECT_FALSE(null_dict1 < null_dict2);
1406   EXPECT_FALSE(null_dict1 > null_dict2);
1407   EXPECT_LE(null_dict1, null_dict2);
1408   EXPECT_GE(null_dict1, null_dict2);
1409
1410   // Test Non Empty Dict Values.
1411   DictionaryValue int_dict1;
1412   DictionaryValue int_dict2;
1413   int_dict1.SetInteger("key", 1);
1414   int_dict2.SetInteger("key", 2);
1415   EXPECT_FALSE(int_dict1 == int_dict2);
1416   EXPECT_NE(int_dict1, int_dict2);
1417   EXPECT_LT(int_dict1, int_dict2);
1418   EXPECT_FALSE(int_dict1 > int_dict2);
1419   EXPECT_LE(int_dict1, int_dict2);
1420   EXPECT_FALSE(int_dict1 >= int_dict2);
1421
1422   // Test Values of different types.
1423   std::vector<Value> values;
1424   values.emplace_back(std::move(null1));
1425   values.emplace_back(std::move(bool1));
1426   values.emplace_back(std::move(int1));
1427   values.emplace_back(std::move(double1));
1428   values.emplace_back(std::move(string1));
1429   values.emplace_back(std::move(binary1));
1430   values.emplace_back(std::move(int_dict1));
1431   values.emplace_back(std::move(int_list1));
1432   for (size_t i = 0; i < values.size(); ++i) {
1433     for (size_t j = i + 1; j < values.size(); ++j) {
1434       EXPECT_FALSE(values[i] == values[j]);
1435       EXPECT_NE(values[i], values[j]);
1436       EXPECT_LT(values[i], values[j]);
1437       EXPECT_FALSE(values[i] > values[j]);
1438       EXPECT_LE(values[i], values[j]);
1439       EXPECT_FALSE(values[i] >= values[j]);
1440     }
1441   }
1442 }
1443
1444 TEST(ValuesTest, DeepCopyCovariantReturnTypes) {
1445   DictionaryValue original_dict;
1446   Value* null_weak = original_dict.SetKey("null", Value());
1447   Value* bool_weak = original_dict.SetKey("bool", Value(true));
1448   Value* int_weak = original_dict.SetKey("int", Value(42));
1449   Value* double_weak = original_dict.SetKey("double", Value(3.14));
1450   Value* string_weak = original_dict.SetKey("string", Value("hello"));
1451   Value* string16_weak =
1452       original_dict.SetKey("string16", Value(ASCIIToUTF16("hello16")));
1453   Value* binary_weak =
1454       original_dict.SetKey("binary", Value(Value::BlobStorage(42, '!')));
1455
1456   Value::ListStorage storage;
1457   storage.emplace_back(0);
1458   storage.emplace_back(1);
1459   Value* list_weak = original_dict.SetKey("list", Value(std::move(storage)));
1460
1461   auto copy_dict = std::make_unique<Value>(original_dict.Clone());
1462   auto copy_null = std::make_unique<Value>(null_weak->Clone());
1463   auto copy_bool = std::make_unique<Value>(bool_weak->Clone());
1464   auto copy_int = std::make_unique<Value>(int_weak->Clone());
1465   auto copy_double = std::make_unique<Value>(double_weak->Clone());
1466   auto copy_string = std::make_unique<Value>(string_weak->Clone());
1467   auto copy_string16 = std::make_unique<Value>(string16_weak->Clone());
1468   auto copy_binary = std::make_unique<Value>(binary_weak->Clone());
1469   auto copy_list = std::make_unique<Value>(list_weak->Clone());
1470
1471   EXPECT_EQ(original_dict, *copy_dict);
1472   EXPECT_EQ(*null_weak, *copy_null);
1473   EXPECT_EQ(*bool_weak, *copy_bool);
1474   EXPECT_EQ(*int_weak, *copy_int);
1475   EXPECT_EQ(*double_weak, *copy_double);
1476   EXPECT_EQ(*string_weak, *copy_string);
1477   EXPECT_EQ(*string16_weak, *copy_string16);
1478   EXPECT_EQ(*binary_weak, *copy_binary);
1479   EXPECT_EQ(*list_weak, *copy_list);
1480 }
1481
1482 TEST(ValuesTest, RemoveEmptyChildren) {
1483   auto root = std::make_unique<DictionaryValue>();
1484   // Remove empty lists and dictionaries.
1485   root->Set("empty_dict", std::make_unique<DictionaryValue>());
1486   root->Set("empty_list", std::make_unique<ListValue>());
1487   root->SetWithoutPathExpansion("a.b.c.d.e",
1488                                 std::make_unique<DictionaryValue>());
1489   root = root->DeepCopyWithoutEmptyChildren();
1490   EXPECT_TRUE(root->empty());
1491
1492   // Make sure we don't prune too much.
1493   root->SetBoolean("bool", true);
1494   root->Set("empty_dict", std::make_unique<DictionaryValue>());
1495   root->SetString("empty_string", std::string());
1496   root = root->DeepCopyWithoutEmptyChildren();
1497   EXPECT_EQ(2U, root->size());
1498
1499   // Should do nothing.
1500   root = root->DeepCopyWithoutEmptyChildren();
1501   EXPECT_EQ(2U, root->size());
1502
1503   // Nested test cases.  These should all reduce back to the bool and string
1504   // set above.
1505   {
1506     root->Set("a.b.c.d.e", std::make_unique<DictionaryValue>());
1507     root = root->DeepCopyWithoutEmptyChildren();
1508     EXPECT_EQ(2U, root->size());
1509   }
1510   {
1511     auto inner = std::make_unique<DictionaryValue>();
1512     inner->Set("empty_dict", std::make_unique<DictionaryValue>());
1513     inner->Set("empty_list", std::make_unique<ListValue>());
1514     root->Set("dict_with_empty_children", std::move(inner));
1515     root = root->DeepCopyWithoutEmptyChildren();
1516     EXPECT_EQ(2U, root->size());
1517   }
1518   {
1519     auto inner = std::make_unique<ListValue>();
1520     inner->Append(std::make_unique<DictionaryValue>());
1521     inner->Append(std::make_unique<ListValue>());
1522     root->Set("list_with_empty_children", std::move(inner));
1523     root = root->DeepCopyWithoutEmptyChildren();
1524     EXPECT_EQ(2U, root->size());
1525   }
1526
1527   // Nested with siblings.
1528   {
1529     auto inner = std::make_unique<ListValue>();
1530     inner->Append(std::make_unique<DictionaryValue>());
1531     inner->Append(std::make_unique<ListValue>());
1532     root->Set("list_with_empty_children", std::move(inner));
1533     auto inner2 = std::make_unique<DictionaryValue>();
1534     inner2->Set("empty_dict", std::make_unique<DictionaryValue>());
1535     inner2->Set("empty_list", std::make_unique<ListValue>());
1536     root->Set("dict_with_empty_children", std::move(inner2));
1537     root = root->DeepCopyWithoutEmptyChildren();
1538     EXPECT_EQ(2U, root->size());
1539   }
1540
1541   // Make sure nested values don't get pruned.
1542   {
1543     auto inner = std::make_unique<ListValue>();
1544     auto inner2 = std::make_unique<ListValue>();
1545     inner2->Append(std::make_unique<Value>("hello"));
1546     inner->Append(std::make_unique<DictionaryValue>());
1547     inner->Append(std::move(inner2));
1548     root->Set("list_with_empty_children", std::move(inner));
1549     root = root->DeepCopyWithoutEmptyChildren();
1550     EXPECT_EQ(3U, root->size());
1551
1552     ListValue* inner_value, *inner_value2;
1553     EXPECT_TRUE(root->GetList("list_with_empty_children", &inner_value));
1554     EXPECT_EQ(1U, inner_value->GetSize());  // Dictionary was pruned.
1555     EXPECT_TRUE(inner_value->GetList(0, &inner_value2));
1556     EXPECT_EQ(1U, inner_value2->GetSize());
1557   }
1558 }
1559
1560 TEST(ValuesTest, MergeDictionary) {
1561   std::unique_ptr<DictionaryValue> base(new DictionaryValue);
1562   base->SetString("base_key", "base_key_value_base");
1563   base->SetString("collide_key", "collide_key_value_base");
1564   std::unique_ptr<DictionaryValue> base_sub_dict(new DictionaryValue);
1565   base_sub_dict->SetString("sub_base_key", "sub_base_key_value_base");
1566   base_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_base");
1567   base->Set("sub_dict_key", std::move(base_sub_dict));
1568
1569   std::unique_ptr<DictionaryValue> merge(new DictionaryValue);
1570   merge->SetString("merge_key", "merge_key_value_merge");
1571   merge->SetString("collide_key", "collide_key_value_merge");
1572   std::unique_ptr<DictionaryValue> merge_sub_dict(new DictionaryValue);
1573   merge_sub_dict->SetString("sub_merge_key", "sub_merge_key_value_merge");
1574   merge_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_merge");
1575   merge->Set("sub_dict_key", std::move(merge_sub_dict));
1576
1577   base->MergeDictionary(merge.get());
1578
1579   EXPECT_EQ(4U, base->size());
1580   std::string base_key_value;
1581   EXPECT_TRUE(base->GetString("base_key", &base_key_value));
1582   EXPECT_EQ("base_key_value_base", base_key_value); // Base value preserved.
1583   std::string collide_key_value;
1584   EXPECT_TRUE(base->GetString("collide_key", &collide_key_value));
1585   EXPECT_EQ("collide_key_value_merge", collide_key_value); // Replaced.
1586   std::string merge_key_value;
1587   EXPECT_TRUE(base->GetString("merge_key", &merge_key_value));
1588   EXPECT_EQ("merge_key_value_merge", merge_key_value); // Merged in.
1589
1590   DictionaryValue* res_sub_dict;
1591   EXPECT_TRUE(base->GetDictionary("sub_dict_key", &res_sub_dict));
1592   EXPECT_EQ(3U, res_sub_dict->size());
1593   std::string sub_base_key_value;
1594   EXPECT_TRUE(res_sub_dict->GetString("sub_base_key", &sub_base_key_value));
1595   EXPECT_EQ("sub_base_key_value_base", sub_base_key_value); // Preserved.
1596   std::string sub_collide_key_value;
1597   EXPECT_TRUE(res_sub_dict->GetString("sub_collide_key",
1598                                       &sub_collide_key_value));
1599   EXPECT_EQ("sub_collide_key_value_merge", sub_collide_key_value); // Replaced.
1600   std::string sub_merge_key_value;
1601   EXPECT_TRUE(res_sub_dict->GetString("sub_merge_key", &sub_merge_key_value));
1602   EXPECT_EQ("sub_merge_key_value_merge", sub_merge_key_value); // Merged in.
1603 }
1604
1605 TEST(ValuesTest, MergeDictionaryDeepCopy) {
1606   std::unique_ptr<DictionaryValue> child(new DictionaryValue);
1607   DictionaryValue* original_child = child.get();
1608   child->SetString("test", "value");
1609   EXPECT_EQ(1U, child->size());
1610
1611   std::string value;
1612   EXPECT_TRUE(child->GetString("test", &value));
1613   EXPECT_EQ("value", value);
1614
1615   std::unique_ptr<DictionaryValue> base(new DictionaryValue);
1616   base->Set("dict", std::move(child));
1617   EXPECT_EQ(1U, base->size());
1618
1619   DictionaryValue* ptr;
1620   EXPECT_TRUE(base->GetDictionary("dict", &ptr));
1621   EXPECT_EQ(original_child, ptr);
1622
1623   std::unique_ptr<DictionaryValue> merged(new DictionaryValue);
1624   merged->MergeDictionary(base.get());
1625   EXPECT_EQ(1U, merged->size());
1626   EXPECT_TRUE(merged->GetDictionary("dict", &ptr));
1627   EXPECT_NE(original_child, ptr);
1628   EXPECT_TRUE(ptr->GetString("test", &value));
1629   EXPECT_EQ("value", value);
1630
1631   original_child->SetString("test", "overwrite");
1632   base.reset();
1633   EXPECT_TRUE(ptr->GetString("test", &value));
1634   EXPECT_EQ("value", value);
1635 }
1636
1637 TEST(ValuesTest, DictionaryIterator) {
1638   DictionaryValue dict;
1639   for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
1640     ADD_FAILURE();
1641   }
1642
1643   Value value1("value1");
1644   dict.SetKey("key1", value1.Clone());
1645   bool seen1 = false;
1646   for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
1647     EXPECT_FALSE(seen1);
1648     EXPECT_EQ("key1", it.key());
1649     EXPECT_EQ(value1, it.value());
1650     seen1 = true;
1651   }
1652   EXPECT_TRUE(seen1);
1653
1654   Value value2("value2");
1655   dict.SetKey("key2", value2.Clone());
1656   bool seen2 = seen1 = false;
1657   for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
1658     if (it.key() == "key1") {
1659       EXPECT_FALSE(seen1);
1660       EXPECT_EQ(value1, it.value());
1661       seen1 = true;
1662     } else if (it.key() == "key2") {
1663       EXPECT_FALSE(seen2);
1664       EXPECT_EQ(value2, it.value());
1665       seen2 = true;
1666     } else {
1667       ADD_FAILURE();
1668     }
1669   }
1670   EXPECT_TRUE(seen1);
1671   EXPECT_TRUE(seen2);
1672 }
1673
1674 TEST(ValuesTest, StdDictionaryIterator) {
1675   DictionaryValue dict;
1676   for (auto it = dict.begin(); it != dict.end(); ++it) {
1677     ADD_FAILURE();
1678   }
1679
1680   Value value1("value1");
1681   dict.SetKey("key1", value1.Clone());
1682   bool seen1 = false;
1683   for (const auto& it : dict) {
1684     EXPECT_FALSE(seen1);
1685     EXPECT_EQ("key1", it.first);
1686     EXPECT_EQ(value1, *it.second);
1687     seen1 = true;
1688   }
1689   EXPECT_TRUE(seen1);
1690
1691   Value value2("value2");
1692   dict.SetKey("key2", value2.Clone());
1693   bool seen2 = seen1 = false;
1694   for (const auto& it : dict) {
1695     if (it.first == "key1") {
1696       EXPECT_FALSE(seen1);
1697       EXPECT_EQ(value1, *it.second);
1698       seen1 = true;
1699     } else if (it.first == "key2") {
1700       EXPECT_FALSE(seen2);
1701       EXPECT_EQ(value2, *it.second);
1702       seen2 = true;
1703     } else {
1704       ADD_FAILURE();
1705     }
1706   }
1707   EXPECT_TRUE(seen1);
1708   EXPECT_TRUE(seen2);
1709 }
1710
1711 // DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value
1712 // and still return true/false based on success.
1713 TEST(ValuesTest, GetWithNullOutValue) {
1714   DictionaryValue main_dict;
1715   ListValue main_list;
1716
1717   Value bool_value(false);
1718   Value int_value(1234);
1719   Value double_value(12.34567);
1720   Value string_value("foo");
1721   Value binary_value(Value::Type::BINARY);
1722   DictionaryValue dict_value;
1723   ListValue list_value;
1724
1725   main_dict.SetKey("bool", bool_value.Clone());
1726   main_dict.SetKey("int", int_value.Clone());
1727   main_dict.SetKey("double", double_value.Clone());
1728   main_dict.SetKey("string", string_value.Clone());
1729   main_dict.SetKey("binary", binary_value.Clone());
1730   main_dict.SetKey("dict", dict_value.Clone());
1731   main_dict.SetKey("list", list_value.Clone());
1732
1733   main_list.Append(std::make_unique<Value>(bool_value.Clone()));
1734   main_list.Append(std::make_unique<Value>(int_value.Clone()));
1735   main_list.Append(std::make_unique<Value>(double_value.Clone()));
1736   main_list.Append(std::make_unique<Value>(string_value.Clone()));
1737   main_list.Append(std::make_unique<Value>(binary_value.Clone()));
1738   main_list.Append(std::make_unique<Value>(dict_value.Clone()));
1739   main_list.Append(std::make_unique<Value>(list_value.Clone()));
1740
1741   EXPECT_TRUE(main_dict.Get("bool", nullptr));
1742   EXPECT_TRUE(main_dict.Get("int", nullptr));
1743   EXPECT_TRUE(main_dict.Get("double", nullptr));
1744   EXPECT_TRUE(main_dict.Get("string", nullptr));
1745   EXPECT_TRUE(main_dict.Get("binary", nullptr));
1746   EXPECT_TRUE(main_dict.Get("dict", nullptr));
1747   EXPECT_TRUE(main_dict.Get("list", nullptr));
1748   EXPECT_FALSE(main_dict.Get("DNE", nullptr));
1749
1750   EXPECT_TRUE(main_dict.GetBoolean("bool", nullptr));
1751   EXPECT_FALSE(main_dict.GetBoolean("int", nullptr));
1752   EXPECT_FALSE(main_dict.GetBoolean("double", nullptr));
1753   EXPECT_FALSE(main_dict.GetBoolean("string", nullptr));
1754   EXPECT_FALSE(main_dict.GetBoolean("binary", nullptr));
1755   EXPECT_FALSE(main_dict.GetBoolean("dict", nullptr));
1756   EXPECT_FALSE(main_dict.GetBoolean("list", nullptr));
1757   EXPECT_FALSE(main_dict.GetBoolean("DNE", nullptr));
1758
1759   EXPECT_FALSE(main_dict.GetInteger("bool", nullptr));
1760   EXPECT_TRUE(main_dict.GetInteger("int", nullptr));
1761   EXPECT_FALSE(main_dict.GetInteger("double", nullptr));
1762   EXPECT_FALSE(main_dict.GetInteger("string", nullptr));
1763   EXPECT_FALSE(main_dict.GetInteger("binary", nullptr));
1764   EXPECT_FALSE(main_dict.GetInteger("dict", nullptr));
1765   EXPECT_FALSE(main_dict.GetInteger("list", nullptr));
1766   EXPECT_FALSE(main_dict.GetInteger("DNE", nullptr));
1767
1768   // Both int and double values can be obtained from GetDouble.
1769   EXPECT_FALSE(main_dict.GetDouble("bool", nullptr));
1770   EXPECT_TRUE(main_dict.GetDouble("int", nullptr));
1771   EXPECT_TRUE(main_dict.GetDouble("double", nullptr));
1772   EXPECT_FALSE(main_dict.GetDouble("string", nullptr));
1773   EXPECT_FALSE(main_dict.GetDouble("binary", nullptr));
1774   EXPECT_FALSE(main_dict.GetDouble("dict", nullptr));
1775   EXPECT_FALSE(main_dict.GetDouble("list", nullptr));
1776   EXPECT_FALSE(main_dict.GetDouble("DNE", nullptr));
1777
1778   EXPECT_FALSE(main_dict.GetString("bool", static_cast<std::string*>(nullptr)));
1779   EXPECT_FALSE(main_dict.GetString("int", static_cast<std::string*>(nullptr)));
1780   EXPECT_FALSE(
1781       main_dict.GetString("double", static_cast<std::string*>(nullptr)));
1782   EXPECT_TRUE(
1783       main_dict.GetString("string", static_cast<std::string*>(nullptr)));
1784   EXPECT_FALSE(
1785       main_dict.GetString("binary", static_cast<std::string*>(nullptr)));
1786   EXPECT_FALSE(main_dict.GetString("dict", static_cast<std::string*>(nullptr)));
1787   EXPECT_FALSE(main_dict.GetString("list", static_cast<std::string*>(nullptr)));
1788   EXPECT_FALSE(main_dict.GetString("DNE", static_cast<std::string*>(nullptr)));
1789
1790   EXPECT_FALSE(main_dict.GetString("bool", static_cast<string16*>(nullptr)));
1791   EXPECT_FALSE(main_dict.GetString("int", static_cast<string16*>(nullptr)));
1792   EXPECT_FALSE(main_dict.GetString("double", static_cast<string16*>(nullptr)));
1793   EXPECT_TRUE(main_dict.GetString("string", static_cast<string16*>(nullptr)));
1794   EXPECT_FALSE(main_dict.GetString("binary", static_cast<string16*>(nullptr)));
1795   EXPECT_FALSE(main_dict.GetString("dict", static_cast<string16*>(nullptr)));
1796   EXPECT_FALSE(main_dict.GetString("list", static_cast<string16*>(nullptr)));
1797   EXPECT_FALSE(main_dict.GetString("DNE", static_cast<string16*>(nullptr)));
1798
1799   EXPECT_FALSE(main_dict.GetBinary("bool", nullptr));
1800   EXPECT_FALSE(main_dict.GetBinary("int", nullptr));
1801   EXPECT_FALSE(main_dict.GetBinary("double", nullptr));
1802   EXPECT_FALSE(main_dict.GetBinary("string", nullptr));
1803   EXPECT_TRUE(main_dict.GetBinary("binary", nullptr));
1804   EXPECT_FALSE(main_dict.GetBinary("dict", nullptr));
1805   EXPECT_FALSE(main_dict.GetBinary("list", nullptr));
1806   EXPECT_FALSE(main_dict.GetBinary("DNE", nullptr));
1807
1808   EXPECT_FALSE(main_dict.GetDictionary("bool", nullptr));
1809   EXPECT_FALSE(main_dict.GetDictionary("int", nullptr));
1810   EXPECT_FALSE(main_dict.GetDictionary("double", nullptr));
1811   EXPECT_FALSE(main_dict.GetDictionary("string", nullptr));
1812   EXPECT_FALSE(main_dict.GetDictionary("binary", nullptr));
1813   EXPECT_TRUE(main_dict.GetDictionary("dict", nullptr));
1814   EXPECT_FALSE(main_dict.GetDictionary("list", nullptr));
1815   EXPECT_FALSE(main_dict.GetDictionary("DNE", nullptr));
1816
1817   EXPECT_FALSE(main_dict.GetList("bool", nullptr));
1818   EXPECT_FALSE(main_dict.GetList("int", nullptr));
1819   EXPECT_FALSE(main_dict.GetList("double", nullptr));
1820   EXPECT_FALSE(main_dict.GetList("string", nullptr));
1821   EXPECT_FALSE(main_dict.GetList("binary", nullptr));
1822   EXPECT_FALSE(main_dict.GetList("dict", nullptr));
1823   EXPECT_TRUE(main_dict.GetList("list", nullptr));
1824   EXPECT_FALSE(main_dict.GetList("DNE", nullptr));
1825
1826   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("bool", nullptr));
1827   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("int", nullptr));
1828   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("double", nullptr));
1829   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("string", nullptr));
1830   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("binary", nullptr));
1831   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("dict", nullptr));
1832   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("list", nullptr));
1833   EXPECT_FALSE(main_dict.GetWithoutPathExpansion("DNE", nullptr));
1834
1835   EXPECT_TRUE(main_dict.GetBooleanWithoutPathExpansion("bool", nullptr));
1836   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("int", nullptr));
1837   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("double", nullptr));
1838   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("string", nullptr));
1839   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("binary", nullptr));
1840   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("dict", nullptr));
1841   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("list", nullptr));
1842   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("DNE", nullptr));
1843
1844   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("bool", nullptr));
1845   EXPECT_TRUE(main_dict.GetIntegerWithoutPathExpansion("int", nullptr));
1846   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("double", nullptr));
1847   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("string", nullptr));
1848   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("binary", nullptr));
1849   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("dict", nullptr));
1850   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("list", nullptr));
1851   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("DNE", nullptr));
1852
1853   EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("bool", nullptr));
1854   EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("int", nullptr));
1855   EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("double", nullptr));
1856   EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("string", nullptr));
1857   EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("binary", nullptr));
1858   EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("dict", nullptr));
1859   EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("list", nullptr));
1860   EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("DNE", nullptr));
1861
1862   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1863       "bool", static_cast<std::string*>(nullptr)));
1864   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1865       "int", static_cast<std::string*>(nullptr)));
1866   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1867       "double", static_cast<std::string*>(nullptr)));
1868   EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
1869       "string", static_cast<std::string*>(nullptr)));
1870   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1871       "binary", static_cast<std::string*>(nullptr)));
1872   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1873       "dict", static_cast<std::string*>(nullptr)));
1874   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1875       "list", static_cast<std::string*>(nullptr)));
1876   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1877       "DNE", static_cast<std::string*>(nullptr)));
1878
1879   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1880       "bool", static_cast<string16*>(nullptr)));
1881   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1882       "int", static_cast<string16*>(nullptr)));
1883   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1884       "double", static_cast<string16*>(nullptr)));
1885   EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
1886       "string", static_cast<string16*>(nullptr)));
1887   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1888       "binary", static_cast<string16*>(nullptr)));
1889   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1890       "dict", static_cast<string16*>(nullptr)));
1891   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1892       "list", static_cast<string16*>(nullptr)));
1893   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
1894       "DNE", static_cast<string16*>(nullptr)));
1895
1896   // There is no GetBinaryWithoutPathExpansion for some reason, but if there
1897   // were it should be tested here...
1898
1899   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("bool", nullptr));
1900   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("int", nullptr));
1901   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("double", nullptr));
1902   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("string", nullptr));
1903   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("binary", nullptr));
1904   EXPECT_TRUE(main_dict.GetDictionaryWithoutPathExpansion("dict", nullptr));
1905   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("list", nullptr));
1906   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("DNE", nullptr));
1907
1908   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("bool", nullptr));
1909   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("int", nullptr));
1910   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("double", nullptr));
1911   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("string", nullptr));
1912   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("binary", nullptr));
1913   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("dict", nullptr));
1914   EXPECT_TRUE(main_dict.GetListWithoutPathExpansion("list", nullptr));
1915   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("DNE", nullptr));
1916
1917   EXPECT_TRUE(main_list.Get(0, nullptr));
1918   EXPECT_TRUE(main_list.Get(1, nullptr));
1919   EXPECT_TRUE(main_list.Get(2, nullptr));
1920   EXPECT_TRUE(main_list.Get(3, nullptr));
1921   EXPECT_TRUE(main_list.Get(4, nullptr));
1922   EXPECT_TRUE(main_list.Get(5, nullptr));
1923   EXPECT_TRUE(main_list.Get(6, nullptr));
1924   EXPECT_FALSE(main_list.Get(7, nullptr));
1925
1926   EXPECT_TRUE(main_list.GetBoolean(0, nullptr));
1927   EXPECT_FALSE(main_list.GetBoolean(1, nullptr));
1928   EXPECT_FALSE(main_list.GetBoolean(2, nullptr));
1929   EXPECT_FALSE(main_list.GetBoolean(3, nullptr));
1930   EXPECT_FALSE(main_list.GetBoolean(4, nullptr));
1931   EXPECT_FALSE(main_list.GetBoolean(5, nullptr));
1932   EXPECT_FALSE(main_list.GetBoolean(6, nullptr));
1933   EXPECT_FALSE(main_list.GetBoolean(7, nullptr));
1934
1935   EXPECT_FALSE(main_list.GetInteger(0, nullptr));
1936   EXPECT_TRUE(main_list.GetInteger(1, nullptr));
1937   EXPECT_FALSE(main_list.GetInteger(2, nullptr));
1938   EXPECT_FALSE(main_list.GetInteger(3, nullptr));
1939   EXPECT_FALSE(main_list.GetInteger(4, nullptr));
1940   EXPECT_FALSE(main_list.GetInteger(5, nullptr));
1941   EXPECT_FALSE(main_list.GetInteger(6, nullptr));
1942   EXPECT_FALSE(main_list.GetInteger(7, nullptr));
1943
1944   EXPECT_FALSE(main_list.GetDouble(0, nullptr));
1945   EXPECT_TRUE(main_list.GetDouble(1, nullptr));
1946   EXPECT_TRUE(main_list.GetDouble(2, nullptr));
1947   EXPECT_FALSE(main_list.GetDouble(3, nullptr));
1948   EXPECT_FALSE(main_list.GetDouble(4, nullptr));
1949   EXPECT_FALSE(main_list.GetDouble(5, nullptr));
1950   EXPECT_FALSE(main_list.GetDouble(6, nullptr));
1951   EXPECT_FALSE(main_list.GetDouble(7, nullptr));
1952
1953   EXPECT_FALSE(main_list.GetString(0, static_cast<std::string*>(nullptr)));
1954   EXPECT_FALSE(main_list.GetString(1, static_cast<std::string*>(nullptr)));
1955   EXPECT_FALSE(main_list.GetString(2, static_cast<std::string*>(nullptr)));
1956   EXPECT_TRUE(main_list.GetString(3, static_cast<std::string*>(nullptr)));
1957   EXPECT_FALSE(main_list.GetString(4, static_cast<std::string*>(nullptr)));
1958   EXPECT_FALSE(main_list.GetString(5, static_cast<std::string*>(nullptr)));
1959   EXPECT_FALSE(main_list.GetString(6, static_cast<std::string*>(nullptr)));
1960   EXPECT_FALSE(main_list.GetString(7, static_cast<std::string*>(nullptr)));
1961
1962   EXPECT_FALSE(main_list.GetString(0, static_cast<string16*>(nullptr)));
1963   EXPECT_FALSE(main_list.GetString(1, static_cast<string16*>(nullptr)));
1964   EXPECT_FALSE(main_list.GetString(2, static_cast<string16*>(nullptr)));
1965   EXPECT_TRUE(main_list.GetString(3, static_cast<string16*>(nullptr)));
1966   EXPECT_FALSE(main_list.GetString(4, static_cast<string16*>(nullptr)));
1967   EXPECT_FALSE(main_list.GetString(5, static_cast<string16*>(nullptr)));
1968   EXPECT_FALSE(main_list.GetString(6, static_cast<string16*>(nullptr)));
1969   EXPECT_FALSE(main_list.GetString(7, static_cast<string16*>(nullptr)));
1970
1971   EXPECT_FALSE(main_list.GetDictionary(0, nullptr));
1972   EXPECT_FALSE(main_list.GetDictionary(1, nullptr));
1973   EXPECT_FALSE(main_list.GetDictionary(2, nullptr));
1974   EXPECT_FALSE(main_list.GetDictionary(3, nullptr));
1975   EXPECT_FALSE(main_list.GetDictionary(4, nullptr));
1976   EXPECT_TRUE(main_list.GetDictionary(5, nullptr));
1977   EXPECT_FALSE(main_list.GetDictionary(6, nullptr));
1978   EXPECT_FALSE(main_list.GetDictionary(7, nullptr));
1979
1980   EXPECT_FALSE(main_list.GetList(0, nullptr));
1981   EXPECT_FALSE(main_list.GetList(1, nullptr));
1982   EXPECT_FALSE(main_list.GetList(2, nullptr));
1983   EXPECT_FALSE(main_list.GetList(3, nullptr));
1984   EXPECT_FALSE(main_list.GetList(4, nullptr));
1985   EXPECT_FALSE(main_list.GetList(5, nullptr));
1986   EXPECT_TRUE(main_list.GetList(6, nullptr));
1987   EXPECT_FALSE(main_list.GetList(7, nullptr));
1988 }
1989
1990 TEST(ValuesTest, SelfSwap) {
1991   base::Value test(1);
1992   std::swap(test, test);
1993   EXPECT_EQ(1, test.GetInt());
1994 }
1995
1996 TEST(ValuesTest, FromToUniquePtrValue) {
1997   std::unique_ptr<DictionaryValue> dict = std::make_unique<DictionaryValue>();
1998   dict->SetString("name", "Froogle");
1999   dict->SetString("url", "http://froogle.com");
2000   Value dict_copy = dict->Clone();
2001
2002   Value dict_converted = Value::FromUniquePtrValue(std::move(dict));
2003   EXPECT_EQ(dict_copy, dict_converted);
2004
2005   std::unique_ptr<Value> val =
2006       Value::ToUniquePtrValue(std::move(dict_converted));
2007   EXPECT_EQ(dict_copy, *val);
2008 }
2009
2010 }  // namespace base