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