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