OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/values.h" | 5 #include "base/values.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <limits> | 9 #include <limits> |
10 #include <memory> | 10 #include <memory> |
(...skipping 127 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
138 Value* narrow_value = binary.get(); | 138 Value* narrow_value = binary.get(); |
139 const BinaryValue* narrow_binary = NULL; | 139 const BinaryValue* narrow_binary = NULL; |
140 ASSERT_TRUE(narrow_value->GetAsBinary(&narrow_binary)); | 140 ASSERT_TRUE(narrow_value->GetAsBinary(&narrow_binary)); |
141 EXPECT_EQ(binary.get(), narrow_binary); | 141 EXPECT_EQ(binary.get(), narrow_binary); |
142 } | 142 } |
143 | 143 |
144 TEST(ValuesTest, StringValue) { | 144 TEST(ValuesTest, StringValue) { |
145 // Test overloaded StringValue constructor. | 145 // Test overloaded StringValue constructor. |
146 std::unique_ptr<Value> narrow_value(new StringValue("narrow")); | 146 std::unique_ptr<Value> narrow_value(new StringValue("narrow")); |
147 ASSERT_TRUE(narrow_value.get()); | 147 ASSERT_TRUE(narrow_value.get()); |
148 ASSERT_TRUE(narrow_value->IsType(Value::TYPE_STRING)); | 148 ASSERT_TRUE(narrow_value->IsType(Value::Type::STRING)); |
149 std::unique_ptr<Value> utf16_value(new StringValue(ASCIIToUTF16("utf16"))); | 149 std::unique_ptr<Value> utf16_value(new StringValue(ASCIIToUTF16("utf16"))); |
150 ASSERT_TRUE(utf16_value.get()); | 150 ASSERT_TRUE(utf16_value.get()); |
151 ASSERT_TRUE(utf16_value->IsType(Value::TYPE_STRING)); | 151 ASSERT_TRUE(utf16_value->IsType(Value::Type::STRING)); |
152 | 152 |
153 // Test overloaded GetAsString. | 153 // Test overloaded GetAsString. |
154 std::string narrow = "http://google.com"; | 154 std::string narrow = "http://google.com"; |
155 string16 utf16 = ASCIIToUTF16("http://google.com"); | 155 string16 utf16 = ASCIIToUTF16("http://google.com"); |
156 const StringValue* string_value = NULL; | 156 const StringValue* string_value = NULL; |
157 ASSERT_TRUE(narrow_value->GetAsString(&narrow)); | 157 ASSERT_TRUE(narrow_value->GetAsString(&narrow)); |
158 ASSERT_TRUE(narrow_value->GetAsString(&utf16)); | 158 ASSERT_TRUE(narrow_value->GetAsString(&utf16)); |
159 ASSERT_TRUE(narrow_value->GetAsString(&string_value)); | 159 ASSERT_TRUE(narrow_value->GetAsString(&string_value)); |
160 ASSERT_EQ(std::string("narrow"), narrow); | 160 ASSERT_EQ(std::string("narrow"), narrow); |
161 ASSERT_EQ(ASCIIToUTF16("narrow"), utf16); | 161 ASSERT_EQ(ASCIIToUTF16("narrow"), utf16); |
(...skipping 10 matching lines...) Expand all Loading... |
172 ASSERT_TRUE(narrow_value->GetAsString(static_cast<string16*>(NULL))); | 172 ASSERT_TRUE(narrow_value->GetAsString(static_cast<string16*>(NULL))); |
173 ASSERT_TRUE(narrow_value->GetAsString(static_cast<std::string*>(NULL))); | 173 ASSERT_TRUE(narrow_value->GetAsString(static_cast<std::string*>(NULL))); |
174 ASSERT_TRUE(narrow_value->GetAsString( | 174 ASSERT_TRUE(narrow_value->GetAsString( |
175 static_cast<const StringValue**>(NULL))); | 175 static_cast<const StringValue**>(NULL))); |
176 } | 176 } |
177 | 177 |
178 // This is a Value object that allows us to tell if it's been | 178 // This is a Value object that allows us to tell if it's been |
179 // properly deleted by modifying the value of external flag on destruction. | 179 // properly deleted by modifying the value of external flag on destruction. |
180 class DeletionTestValue : public Value { | 180 class DeletionTestValue : public Value { |
181 public: | 181 public: |
182 explicit DeletionTestValue(bool* deletion_flag) : Value(TYPE_NULL) { | 182 explicit DeletionTestValue(bool* deletion_flag) : Value(Type::NONE) { |
183 Init(deletion_flag); // Separate function so that we can use ASSERT_* | 183 Init(deletion_flag); // Separate function so that we can use ASSERT_* |
184 } | 184 } |
185 | 185 |
186 void Init(bool* deletion_flag) { | 186 void Init(bool* deletion_flag) { |
187 ASSERT_TRUE(deletion_flag); | 187 ASSERT_TRUE(deletion_flag); |
188 deletion_flag_ = deletion_flag; | 188 deletion_flag_ = deletion_flag; |
189 *deletion_flag_ = false; | 189 *deletion_flag_ = false; |
190 } | 190 } |
191 | 191 |
192 ~DeletionTestValue() override { *deletion_flag_ = true; } | 192 ~DeletionTestValue() override { *deletion_flag_ = true; } |
(...skipping 143 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
336 DictionaryValue* value2; | 336 DictionaryValue* value2; |
337 ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2)); | 337 ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2)); |
338 EXPECT_EQ(value1, value2); | 338 EXPECT_EQ(value1, value2); |
339 EXPECT_EQ(1U, value2->size()); | 339 EXPECT_EQ(1U, value2->size()); |
340 | 340 |
341 EXPECT_TRUE(dict.HasKey("this.isnt.expanded")); | 341 EXPECT_TRUE(dict.HasKey("this.isnt.expanded")); |
342 Value* value3; | 342 Value* value3; |
343 EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3)); | 343 EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3)); |
344 Value* value4; | 344 Value* value4; |
345 ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4)); | 345 ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4)); |
346 EXPECT_EQ(Value::TYPE_NULL, value4->GetType()); | 346 EXPECT_EQ(Value::Type::NONE, value4->GetType()); |
347 } | 347 } |
348 | 348 |
349 // Tests the deprecated version of SetWithoutPathExpansion. | 349 // Tests the deprecated version of SetWithoutPathExpansion. |
350 // TODO(estade): remove. | 350 // TODO(estade): remove. |
351 TEST(ValuesTest, DictionaryWithoutPathExpansionDeprecated) { | 351 TEST(ValuesTest, DictionaryWithoutPathExpansionDeprecated) { |
352 DictionaryValue dict; | 352 DictionaryValue dict; |
353 dict.Set("this.is.expanded", Value::CreateNullValue()); | 353 dict.Set("this.is.expanded", Value::CreateNullValue()); |
354 dict.SetWithoutPathExpansion("this.isnt.expanded", Value::CreateNullValue()); | 354 dict.SetWithoutPathExpansion("this.isnt.expanded", Value::CreateNullValue()); |
355 | 355 |
356 EXPECT_FALSE(dict.HasKey("this.is.expanded")); | 356 EXPECT_FALSE(dict.HasKey("this.is.expanded")); |
357 EXPECT_TRUE(dict.HasKey("this")); | 357 EXPECT_TRUE(dict.HasKey("this")); |
358 Value* value1; | 358 Value* value1; |
359 EXPECT_TRUE(dict.Get("this", &value1)); | 359 EXPECT_TRUE(dict.Get("this", &value1)); |
360 DictionaryValue* value2; | 360 DictionaryValue* value2; |
361 ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2)); | 361 ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2)); |
362 EXPECT_EQ(value1, value2); | 362 EXPECT_EQ(value1, value2); |
363 EXPECT_EQ(1U, value2->size()); | 363 EXPECT_EQ(1U, value2->size()); |
364 | 364 |
365 EXPECT_TRUE(dict.HasKey("this.isnt.expanded")); | 365 EXPECT_TRUE(dict.HasKey("this.isnt.expanded")); |
366 Value* value3; | 366 Value* value3; |
367 EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3)); | 367 EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3)); |
368 Value* value4; | 368 Value* value4; |
369 ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4)); | 369 ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4)); |
370 EXPECT_EQ(Value::TYPE_NULL, value4->GetType()); | 370 EXPECT_EQ(Value::Type::NONE, value4->GetType()); |
371 } | 371 } |
372 | 372 |
373 TEST(ValuesTest, DictionaryRemovePath) { | 373 TEST(ValuesTest, DictionaryRemovePath) { |
374 DictionaryValue dict; | 374 DictionaryValue dict; |
375 dict.SetInteger("a.long.way.down", 1); | 375 dict.SetInteger("a.long.way.down", 1); |
376 dict.SetBoolean("a.long.key.path", true); | 376 dict.SetBoolean("a.long.key.path", true); |
377 | 377 |
378 std::unique_ptr<Value> removed_item; | 378 std::unique_ptr<Value> removed_item; |
379 EXPECT_TRUE(dict.RemovePath("a.long.way.down", &removed_item)); | 379 EXPECT_TRUE(dict.RemovePath("a.long.way.down", &removed_item)); |
380 ASSERT_TRUE(removed_item); | 380 ASSERT_TRUE(removed_item); |
381 EXPECT_TRUE(removed_item->IsType(base::Value::TYPE_INTEGER)); | 381 EXPECT_TRUE(removed_item->IsType(base::Value::Type::INTEGER)); |
382 EXPECT_FALSE(dict.HasKey("a.long.way.down")); | 382 EXPECT_FALSE(dict.HasKey("a.long.way.down")); |
383 EXPECT_FALSE(dict.HasKey("a.long.way")); | 383 EXPECT_FALSE(dict.HasKey("a.long.way")); |
384 EXPECT_TRUE(dict.Get("a.long.key.path", NULL)); | 384 EXPECT_TRUE(dict.Get("a.long.key.path", NULL)); |
385 | 385 |
386 removed_item.reset(); | 386 removed_item.reset(); |
387 EXPECT_FALSE(dict.RemovePath("a.long.way.down", &removed_item)); | 387 EXPECT_FALSE(dict.RemovePath("a.long.way.down", &removed_item)); |
388 EXPECT_FALSE(removed_item); | 388 EXPECT_FALSE(removed_item); |
389 EXPECT_TRUE(dict.Get("a.long.key.path", NULL)); | 389 EXPECT_TRUE(dict.Get("a.long.key.path", NULL)); |
390 | 390 |
391 removed_item.reset(); | 391 removed_item.reset(); |
392 EXPECT_TRUE(dict.RemovePath("a.long.key.path", &removed_item)); | 392 EXPECT_TRUE(dict.RemovePath("a.long.key.path", &removed_item)); |
393 ASSERT_TRUE(removed_item); | 393 ASSERT_TRUE(removed_item); |
394 EXPECT_TRUE(removed_item->IsType(base::Value::TYPE_BOOLEAN)); | 394 EXPECT_TRUE(removed_item->IsType(base::Value::Type::BOOLEAN)); |
395 EXPECT_TRUE(dict.empty()); | 395 EXPECT_TRUE(dict.empty()); |
396 } | 396 } |
397 | 397 |
398 TEST(ValuesTest, DeepCopy) { | 398 TEST(ValuesTest, DeepCopy) { |
399 DictionaryValue original_dict; | 399 DictionaryValue original_dict; |
400 std::unique_ptr<Value> scoped_null = Value::CreateNullValue(); | 400 std::unique_ptr<Value> scoped_null = Value::CreateNullValue(); |
401 Value* original_null = scoped_null.get(); | 401 Value* original_null = scoped_null.get(); |
402 original_dict.Set("null", std::move(scoped_null)); | 402 original_dict.Set("null", std::move(scoped_null)); |
403 std::unique_ptr<FundamentalValue> scoped_bool(new FundamentalValue(true)); | 403 std::unique_ptr<FundamentalValue> scoped_bool(new FundamentalValue(true)); |
404 FundamentalValue* original_bool = scoped_bool.get(); | 404 FundamentalValue* original_bool = scoped_bool.get(); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
443 original_dict.Set("dictionary", std::move(scoped_nested_dictionary)); | 443 original_dict.Set("dictionary", std::move(scoped_nested_dictionary)); |
444 | 444 |
445 std::unique_ptr<DictionaryValue> copy_dict = original_dict.CreateDeepCopy(); | 445 std::unique_ptr<DictionaryValue> copy_dict = original_dict.CreateDeepCopy(); |
446 ASSERT_TRUE(copy_dict.get()); | 446 ASSERT_TRUE(copy_dict.get()); |
447 ASSERT_NE(copy_dict.get(), &original_dict); | 447 ASSERT_NE(copy_dict.get(), &original_dict); |
448 | 448 |
449 Value* copy_null = NULL; | 449 Value* copy_null = NULL; |
450 ASSERT_TRUE(copy_dict->Get("null", ©_null)); | 450 ASSERT_TRUE(copy_dict->Get("null", ©_null)); |
451 ASSERT_TRUE(copy_null); | 451 ASSERT_TRUE(copy_null); |
452 ASSERT_NE(copy_null, original_null); | 452 ASSERT_NE(copy_null, original_null); |
453 ASSERT_TRUE(copy_null->IsType(Value::TYPE_NULL)); | 453 ASSERT_TRUE(copy_null->IsType(Value::Type::NONE)); |
454 | 454 |
455 Value* copy_bool = NULL; | 455 Value* copy_bool = NULL; |
456 ASSERT_TRUE(copy_dict->Get("bool", ©_bool)); | 456 ASSERT_TRUE(copy_dict->Get("bool", ©_bool)); |
457 ASSERT_TRUE(copy_bool); | 457 ASSERT_TRUE(copy_bool); |
458 ASSERT_NE(copy_bool, original_bool); | 458 ASSERT_NE(copy_bool, original_bool); |
459 ASSERT_TRUE(copy_bool->IsType(Value::TYPE_BOOLEAN)); | 459 ASSERT_TRUE(copy_bool->IsType(Value::Type::BOOLEAN)); |
460 bool copy_bool_value = false; | 460 bool copy_bool_value = false; |
461 ASSERT_TRUE(copy_bool->GetAsBoolean(©_bool_value)); | 461 ASSERT_TRUE(copy_bool->GetAsBoolean(©_bool_value)); |
462 ASSERT_TRUE(copy_bool_value); | 462 ASSERT_TRUE(copy_bool_value); |
463 | 463 |
464 Value* copy_int = NULL; | 464 Value* copy_int = NULL; |
465 ASSERT_TRUE(copy_dict->Get("int", ©_int)); | 465 ASSERT_TRUE(copy_dict->Get("int", ©_int)); |
466 ASSERT_TRUE(copy_int); | 466 ASSERT_TRUE(copy_int); |
467 ASSERT_NE(copy_int, original_int); | 467 ASSERT_NE(copy_int, original_int); |
468 ASSERT_TRUE(copy_int->IsType(Value::TYPE_INTEGER)); | 468 ASSERT_TRUE(copy_int->IsType(Value::Type::INTEGER)); |
469 int copy_int_value = 0; | 469 int copy_int_value = 0; |
470 ASSERT_TRUE(copy_int->GetAsInteger(©_int_value)); | 470 ASSERT_TRUE(copy_int->GetAsInteger(©_int_value)); |
471 ASSERT_EQ(42, copy_int_value); | 471 ASSERT_EQ(42, copy_int_value); |
472 | 472 |
473 Value* copy_double = NULL; | 473 Value* copy_double = NULL; |
474 ASSERT_TRUE(copy_dict->Get("double", ©_double)); | 474 ASSERT_TRUE(copy_dict->Get("double", ©_double)); |
475 ASSERT_TRUE(copy_double); | 475 ASSERT_TRUE(copy_double); |
476 ASSERT_NE(copy_double, original_double); | 476 ASSERT_NE(copy_double, original_double); |
477 ASSERT_TRUE(copy_double->IsType(Value::TYPE_DOUBLE)); | 477 ASSERT_TRUE(copy_double->IsType(Value::Type::DOUBLE)); |
478 double copy_double_value = 0; | 478 double copy_double_value = 0; |
479 ASSERT_TRUE(copy_double->GetAsDouble(©_double_value)); | 479 ASSERT_TRUE(copy_double->GetAsDouble(©_double_value)); |
480 ASSERT_EQ(3.14, copy_double_value); | 480 ASSERT_EQ(3.14, copy_double_value); |
481 | 481 |
482 Value* copy_string = NULL; | 482 Value* copy_string = NULL; |
483 ASSERT_TRUE(copy_dict->Get("string", ©_string)); | 483 ASSERT_TRUE(copy_dict->Get("string", ©_string)); |
484 ASSERT_TRUE(copy_string); | 484 ASSERT_TRUE(copy_string); |
485 ASSERT_NE(copy_string, original_string); | 485 ASSERT_NE(copy_string, original_string); |
486 ASSERT_TRUE(copy_string->IsType(Value::TYPE_STRING)); | 486 ASSERT_TRUE(copy_string->IsType(Value::Type::STRING)); |
487 std::string copy_string_value; | 487 std::string copy_string_value; |
488 string16 copy_string16_value; | 488 string16 copy_string16_value; |
489 ASSERT_TRUE(copy_string->GetAsString(©_string_value)); | 489 ASSERT_TRUE(copy_string->GetAsString(©_string_value)); |
490 ASSERT_TRUE(copy_string->GetAsString(©_string16_value)); | 490 ASSERT_TRUE(copy_string->GetAsString(©_string16_value)); |
491 ASSERT_EQ(std::string("hello"), copy_string_value); | 491 ASSERT_EQ(std::string("hello"), copy_string_value); |
492 ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value); | 492 ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value); |
493 | 493 |
494 Value* copy_string16 = NULL; | 494 Value* copy_string16 = NULL; |
495 ASSERT_TRUE(copy_dict->Get("string16", ©_string16)); | 495 ASSERT_TRUE(copy_dict->Get("string16", ©_string16)); |
496 ASSERT_TRUE(copy_string16); | 496 ASSERT_TRUE(copy_string16); |
497 ASSERT_NE(copy_string16, original_string16); | 497 ASSERT_NE(copy_string16, original_string16); |
498 ASSERT_TRUE(copy_string16->IsType(Value::TYPE_STRING)); | 498 ASSERT_TRUE(copy_string16->IsType(Value::Type::STRING)); |
499 ASSERT_TRUE(copy_string16->GetAsString(©_string_value)); | 499 ASSERT_TRUE(copy_string16->GetAsString(©_string_value)); |
500 ASSERT_TRUE(copy_string16->GetAsString(©_string16_value)); | 500 ASSERT_TRUE(copy_string16->GetAsString(©_string16_value)); |
501 ASSERT_EQ(std::string("hello16"), copy_string_value); | 501 ASSERT_EQ(std::string("hello16"), copy_string_value); |
502 ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value); | 502 ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value); |
503 | 503 |
504 Value* copy_binary = NULL; | 504 Value* copy_binary = NULL; |
505 ASSERT_TRUE(copy_dict->Get("binary", ©_binary)); | 505 ASSERT_TRUE(copy_dict->Get("binary", ©_binary)); |
506 ASSERT_TRUE(copy_binary); | 506 ASSERT_TRUE(copy_binary); |
507 ASSERT_NE(copy_binary, original_binary); | 507 ASSERT_NE(copy_binary, original_binary); |
508 ASSERT_TRUE(copy_binary->IsType(Value::TYPE_BINARY)); | 508 ASSERT_TRUE(copy_binary->IsType(Value::Type::BINARY)); |
509 ASSERT_NE(original_binary->GetBuffer(), | 509 ASSERT_NE(original_binary->GetBuffer(), |
510 static_cast<BinaryValue*>(copy_binary)->GetBuffer()); | 510 static_cast<BinaryValue*>(copy_binary)->GetBuffer()); |
511 ASSERT_EQ(original_binary->GetSize(), | 511 ASSERT_EQ(original_binary->GetSize(), |
512 static_cast<BinaryValue*>(copy_binary)->GetSize()); | 512 static_cast<BinaryValue*>(copy_binary)->GetSize()); |
513 ASSERT_EQ(0, memcmp(original_binary->GetBuffer(), | 513 ASSERT_EQ(0, memcmp(original_binary->GetBuffer(), |
514 static_cast<BinaryValue*>(copy_binary)->GetBuffer(), | 514 static_cast<BinaryValue*>(copy_binary)->GetBuffer(), |
515 original_binary->GetSize())); | 515 original_binary->GetSize())); |
516 | 516 |
517 Value* copy_value = NULL; | 517 Value* copy_value = NULL; |
518 ASSERT_TRUE(copy_dict->Get("list", ©_value)); | 518 ASSERT_TRUE(copy_dict->Get("list", ©_value)); |
519 ASSERT_TRUE(copy_value); | 519 ASSERT_TRUE(copy_value); |
520 ASSERT_NE(copy_value, original_list); | 520 ASSERT_NE(copy_value, original_list); |
521 ASSERT_TRUE(copy_value->IsType(Value::TYPE_LIST)); | 521 ASSERT_TRUE(copy_value->IsType(Value::Type::LIST)); |
522 ListValue* copy_list = NULL; | 522 ListValue* copy_list = NULL; |
523 ASSERT_TRUE(copy_value->GetAsList(©_list)); | 523 ASSERT_TRUE(copy_value->GetAsList(©_list)); |
524 ASSERT_TRUE(copy_list); | 524 ASSERT_TRUE(copy_list); |
525 ASSERT_EQ(2U, copy_list->GetSize()); | 525 ASSERT_EQ(2U, copy_list->GetSize()); |
526 | 526 |
527 Value* copy_list_element_0; | 527 Value* copy_list_element_0; |
528 ASSERT_TRUE(copy_list->Get(0, ©_list_element_0)); | 528 ASSERT_TRUE(copy_list->Get(0, ©_list_element_0)); |
529 ASSERT_TRUE(copy_list_element_0); | 529 ASSERT_TRUE(copy_list_element_0); |
530 ASSERT_NE(copy_list_element_0, original_list_element_0); | 530 ASSERT_NE(copy_list_element_0, original_list_element_0); |
531 int copy_list_element_0_value; | 531 int copy_list_element_0_value; |
532 ASSERT_TRUE(copy_list_element_0->GetAsInteger(©_list_element_0_value)); | 532 ASSERT_TRUE(copy_list_element_0->GetAsInteger(©_list_element_0_value)); |
533 ASSERT_EQ(0, copy_list_element_0_value); | 533 ASSERT_EQ(0, copy_list_element_0_value); |
534 | 534 |
535 Value* copy_list_element_1; | 535 Value* copy_list_element_1; |
536 ASSERT_TRUE(copy_list->Get(1, ©_list_element_1)); | 536 ASSERT_TRUE(copy_list->Get(1, ©_list_element_1)); |
537 ASSERT_TRUE(copy_list_element_1); | 537 ASSERT_TRUE(copy_list_element_1); |
538 ASSERT_NE(copy_list_element_1, original_list_element_1); | 538 ASSERT_NE(copy_list_element_1, original_list_element_1); |
539 int copy_list_element_1_value; | 539 int copy_list_element_1_value; |
540 ASSERT_TRUE(copy_list_element_1->GetAsInteger(©_list_element_1_value)); | 540 ASSERT_TRUE(copy_list_element_1->GetAsInteger(©_list_element_1_value)); |
541 ASSERT_EQ(1, copy_list_element_1_value); | 541 ASSERT_EQ(1, copy_list_element_1_value); |
542 | 542 |
543 copy_value = NULL; | 543 copy_value = NULL; |
544 ASSERT_TRUE(copy_dict->Get("dictionary", ©_value)); | 544 ASSERT_TRUE(copy_dict->Get("dictionary", ©_value)); |
545 ASSERT_TRUE(copy_value); | 545 ASSERT_TRUE(copy_value); |
546 ASSERT_NE(copy_value, original_nested_dictionary); | 546 ASSERT_NE(copy_value, original_nested_dictionary); |
547 ASSERT_TRUE(copy_value->IsType(Value::TYPE_DICTIONARY)); | 547 ASSERT_TRUE(copy_value->IsType(Value::Type::DICTIONARY)); |
548 DictionaryValue* copy_nested_dictionary = NULL; | 548 DictionaryValue* copy_nested_dictionary = NULL; |
549 ASSERT_TRUE(copy_value->GetAsDictionary(©_nested_dictionary)); | 549 ASSERT_TRUE(copy_value->GetAsDictionary(©_nested_dictionary)); |
550 ASSERT_TRUE(copy_nested_dictionary); | 550 ASSERT_TRUE(copy_nested_dictionary); |
551 EXPECT_TRUE(copy_nested_dictionary->HasKey("key")); | 551 EXPECT_TRUE(copy_nested_dictionary->HasKey("key")); |
552 } | 552 } |
553 | 553 |
554 TEST(ValuesTest, Equals) { | 554 TEST(ValuesTest, Equals) { |
555 std::unique_ptr<Value> null1(Value::CreateNullValue()); | 555 std::unique_ptr<Value> null1(Value::CreateNullValue()); |
556 std::unique_ptr<Value> null2(Value::CreateNullValue()); | 556 std::unique_ptr<Value> null2(Value::CreateNullValue()); |
557 EXPECT_NE(null1.get(), null2.get()); | 557 EXPECT_NE(null1.get(), null2.get()); |
(...skipping 589 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1147 EXPECT_FALSE(main_list.GetList(1, NULL)); | 1147 EXPECT_FALSE(main_list.GetList(1, NULL)); |
1148 EXPECT_FALSE(main_list.GetList(2, NULL)); | 1148 EXPECT_FALSE(main_list.GetList(2, NULL)); |
1149 EXPECT_FALSE(main_list.GetList(3, NULL)); | 1149 EXPECT_FALSE(main_list.GetList(3, NULL)); |
1150 EXPECT_FALSE(main_list.GetList(4, NULL)); | 1150 EXPECT_FALSE(main_list.GetList(4, NULL)); |
1151 EXPECT_FALSE(main_list.GetList(5, NULL)); | 1151 EXPECT_FALSE(main_list.GetList(5, NULL)); |
1152 EXPECT_TRUE(main_list.GetList(6, NULL)); | 1152 EXPECT_TRUE(main_list.GetList(6, NULL)); |
1153 EXPECT_FALSE(main_list.GetList(7, NULL)); | 1153 EXPECT_FALSE(main_list.GetList(7, NULL)); |
1154 } | 1154 } |
1155 | 1155 |
1156 } // namespace base | 1156 } // namespace base |
OLD | NEW |