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 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
93 } | 93 } |
94 | 94 |
95 TEST(ValuesTest, ConstructStringFromStringPiece) { | 95 TEST(ValuesTest, ConstructStringFromStringPiece) { |
96 StringPiece str = "foobar"; | 96 StringPiece str = "foobar"; |
97 Value value(str); | 97 Value value(str); |
98 EXPECT_EQ(Value::Type::STRING, value.type()); | 98 EXPECT_EQ(Value::Type::STRING, value.type()); |
99 EXPECT_EQ("foobar", value.GetString()); | 99 EXPECT_EQ("foobar", value.GetString()); |
100 } | 100 } |
101 | 101 |
102 TEST(ValuesTest, ConstructBinary) { | 102 TEST(ValuesTest, ConstructBinary) { |
103 BinaryValue value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2})); | 103 Value value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2})); |
104 EXPECT_EQ(Value::Type::BINARY, value.type()); | 104 EXPECT_EQ(Value::Type::BINARY, value.type()); |
105 EXPECT_EQ(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}), value.GetBlob()); | 105 EXPECT_EQ(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}), value.GetBlob()); |
106 } | 106 } |
107 | 107 |
108 TEST(ValuesTest, ConstructDict) { | 108 TEST(ValuesTest, ConstructDict) { |
109 DictionaryValue value; | 109 DictionaryValue value; |
110 EXPECT_EQ(Value::Type::DICTIONARY, value.type()); | 110 EXPECT_EQ(Value::Type::DICTIONARY, value.type()); |
111 } | 111 } |
112 | 112 |
113 TEST(ValuesTest, ConstructList) { | 113 TEST(ValuesTest, ConstructList) { |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
173 EXPECT_EQ(value.GetString(), copied_value.GetString()); | 173 EXPECT_EQ(value.GetString(), copied_value.GetString()); |
174 | 174 |
175 Value blank; | 175 Value blank; |
176 | 176 |
177 blank = value; | 177 blank = value; |
178 EXPECT_EQ(value.type(), blank.type()); | 178 EXPECT_EQ(value.type(), blank.type()); |
179 EXPECT_EQ(value.GetString(), blank.GetString()); | 179 EXPECT_EQ(value.GetString(), blank.GetString()); |
180 } | 180 } |
181 | 181 |
182 TEST(ValuesTest, CopyBinary) { | 182 TEST(ValuesTest, CopyBinary) { |
183 BinaryValue value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2})); | 183 Value value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2})); |
184 BinaryValue copied_value(value); | 184 Value copied_value(value); |
185 EXPECT_EQ(value.type(), copied_value.type()); | 185 EXPECT_EQ(value.type(), copied_value.type()); |
186 EXPECT_EQ(value.GetBlob(), copied_value.GetBlob()); | 186 EXPECT_EQ(value.GetBlob(), copied_value.GetBlob()); |
187 | 187 |
188 Value blank; | 188 Value blank; |
189 | 189 |
190 blank = value; | 190 blank = value; |
191 EXPECT_EQ(value.type(), blank.type()); | 191 EXPECT_EQ(value.type(), blank.type()); |
192 EXPECT_EQ(value.GetBlob(), blank.GetBlob()); | 192 EXPECT_EQ(value.GetBlob(), blank.GetBlob()); |
193 } | 193 } |
194 | 194 |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
293 | 293 |
294 Value blank; | 294 Value blank; |
295 | 295 |
296 blank = Value("foobar"); | 296 blank = Value("foobar"); |
297 EXPECT_EQ(Value::Type::STRING, blank.type()); | 297 EXPECT_EQ(Value::Type::STRING, blank.type()); |
298 EXPECT_EQ("foobar", blank.GetString()); | 298 EXPECT_EQ("foobar", blank.GetString()); |
299 } | 299 } |
300 | 300 |
301 TEST(ValuesTest, MoveBinary) { | 301 TEST(ValuesTest, MoveBinary) { |
302 const std::vector<char> buffer = {0xF, 0x0, 0x0, 0xB, 0xA, 0x2}; | 302 const std::vector<char> buffer = {0xF, 0x0, 0x0, 0xB, 0xA, 0x2}; |
303 BinaryValue value(buffer); | 303 Value value(buffer); |
304 BinaryValue moved_value(std::move(value)); | 304 Value moved_value(std::move(value)); |
305 EXPECT_EQ(Value::Type::BINARY, moved_value.type()); | 305 EXPECT_EQ(Value::Type::BINARY, moved_value.type()); |
306 EXPECT_EQ(buffer, moved_value.GetBlob()); | 306 EXPECT_EQ(buffer, moved_value.GetBlob()); |
307 | 307 |
308 Value blank; | 308 Value blank; |
309 | 309 |
310 blank = BinaryValue(buffer); | 310 blank = Value(buffer); |
311 EXPECT_EQ(Value::Type::BINARY, blank.type()); | 311 EXPECT_EQ(Value::Type::BINARY, blank.type()); |
312 EXPECT_EQ(buffer, blank.GetBlob()); | 312 EXPECT_EQ(buffer, blank.GetBlob()); |
313 } | 313 } |
314 | 314 |
315 TEST(ValuesTest, MoveDictionary) { | 315 TEST(ValuesTest, MoveDictionary) { |
316 // TODO(crbug.com/646113): Clean this up once DictionaryValue switched to | 316 // TODO(crbug.com/646113): Clean this up once DictionaryValue switched to |
317 // value semantics. | 317 // value semantics. |
318 int move; | 318 int move; |
319 DictionaryValue value; | 319 DictionaryValue value; |
320 value.SetInteger("Int", 123); | 320 value.SetInteger("Int", 123); |
(...skipping 123 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
444 | 444 |
445 TEST(ValuesTest, BinaryValue) { | 445 TEST(ValuesTest, BinaryValue) { |
446 // Default constructor creates a BinaryValue with a buffer of size 0. | 446 // Default constructor creates a BinaryValue with a buffer of size 0. |
447 auto binary = MakeUnique<Value>(Value::Type::BINARY); | 447 auto binary = MakeUnique<Value>(Value::Type::BINARY); |
448 ASSERT_TRUE(binary.get()); | 448 ASSERT_TRUE(binary.get()); |
449 ASSERT_EQ(0U, binary->GetSize()); | 449 ASSERT_EQ(0U, binary->GetSize()); |
450 | 450 |
451 // Test the common case of a non-empty buffer | 451 // Test the common case of a non-empty buffer |
452 std::vector<char> buffer(15); | 452 std::vector<char> buffer(15); |
453 char* original_buffer = buffer.data(); | 453 char* original_buffer = buffer.data(); |
454 binary.reset(new BinaryValue(std::move(buffer))); | 454 binary.reset(new Value(std::move(buffer))); |
455 ASSERT_TRUE(binary.get()); | 455 ASSERT_TRUE(binary.get()); |
456 ASSERT_TRUE(binary->GetBuffer()); | 456 ASSERT_TRUE(binary->GetBuffer()); |
457 ASSERT_EQ(original_buffer, binary->GetBuffer()); | 457 ASSERT_EQ(original_buffer, binary->GetBuffer()); |
458 ASSERT_EQ(15U, binary->GetSize()); | 458 ASSERT_EQ(15U, binary->GetSize()); |
459 | 459 |
460 char stack_buffer[42]; | 460 char stack_buffer[42]; |
461 memset(stack_buffer, '!', 42); | 461 memset(stack_buffer, '!', 42); |
462 binary = BinaryValue::CreateWithCopiedBuffer(stack_buffer, 42); | 462 binary = Value::CreateWithCopiedBuffer(stack_buffer, 42); |
463 ASSERT_TRUE(binary.get()); | 463 ASSERT_TRUE(binary.get()); |
464 ASSERT_TRUE(binary->GetBuffer()); | 464 ASSERT_TRUE(binary->GetBuffer()); |
465 ASSERT_NE(stack_buffer, binary->GetBuffer()); | 465 ASSERT_NE(stack_buffer, binary->GetBuffer()); |
466 ASSERT_EQ(42U, binary->GetSize()); | 466 ASSERT_EQ(42U, binary->GetSize()); |
467 ASSERT_EQ(0, memcmp(stack_buffer, binary->GetBuffer(), binary->GetSize())); | 467 ASSERT_EQ(0, memcmp(stack_buffer, binary->GetBuffer(), binary->GetSize())); |
468 | 468 |
469 // Test overloaded GetAsBinary. | 469 // Test overloaded GetAsBinary. |
470 Value* narrow_value = binary.get(); | 470 Value* narrow_value = binary.get(); |
471 const BinaryValue* narrow_binary = NULL; | 471 const Value* narrow_binary = NULL; |
472 ASSERT_TRUE(narrow_value->GetAsBinary(&narrow_binary)); | 472 ASSERT_TRUE(narrow_value->GetAsBinary(&narrow_binary)); |
473 EXPECT_EQ(binary.get(), narrow_binary); | 473 EXPECT_EQ(binary.get(), narrow_binary); |
474 } | 474 } |
475 | 475 |
476 TEST(ValuesTest, StringValue) { | 476 TEST(ValuesTest, StringValue) { |
477 // Test overloaded StringValue constructor. | 477 // Test overloaded StringValue constructor. |
478 std::unique_ptr<Value> narrow_value(new Value("narrow")); | 478 std::unique_ptr<Value> narrow_value(new Value("narrow")); |
479 ASSERT_TRUE(narrow_value.get()); | 479 ASSERT_TRUE(narrow_value.get()); |
480 ASSERT_TRUE(narrow_value->IsType(Value::Type::STRING)); | 480 ASSERT_TRUE(narrow_value->IsType(Value::Type::STRING)); |
481 std::unique_ptr<Value> utf16_value(new Value(ASCIIToUTF16("utf16"))); | 481 std::unique_ptr<Value> utf16_value(new Value(ASCIIToUTF16("utf16"))); |
(...skipping 185 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
667 Value* original_double = scoped_double.get(); | 667 Value* original_double = scoped_double.get(); |
668 original_dict.Set("double", std::move(scoped_double)); | 668 original_dict.Set("double", std::move(scoped_double)); |
669 std::unique_ptr<Value> scoped_string(new Value("hello")); | 669 std::unique_ptr<Value> scoped_string(new Value("hello")); |
670 Value* original_string = scoped_string.get(); | 670 Value* original_string = scoped_string.get(); |
671 original_dict.Set("string", std::move(scoped_string)); | 671 original_dict.Set("string", std::move(scoped_string)); |
672 std::unique_ptr<Value> scoped_string16(new Value(ASCIIToUTF16("hello16"))); | 672 std::unique_ptr<Value> scoped_string16(new Value(ASCIIToUTF16("hello16"))); |
673 Value* original_string16 = scoped_string16.get(); | 673 Value* original_string16 = scoped_string16.get(); |
674 original_dict.Set("string16", std::move(scoped_string16)); | 674 original_dict.Set("string16", std::move(scoped_string16)); |
675 | 675 |
676 std::vector<char> original_buffer(42, '!'); | 676 std::vector<char> original_buffer(42, '!'); |
677 std::unique_ptr<BinaryValue> scoped_binary( | 677 std::unique_ptr<Value> scoped_binary(new Value(std::move(original_buffer))); |
678 new BinaryValue(std::move(original_buffer))); | 678 Value* original_binary = scoped_binary.get(); |
679 BinaryValue* original_binary = scoped_binary.get(); | |
680 original_dict.Set("binary", std::move(scoped_binary)); | 679 original_dict.Set("binary", std::move(scoped_binary)); |
681 | 680 |
682 std::unique_ptr<ListValue> scoped_list(new ListValue()); | 681 std::unique_ptr<ListValue> scoped_list(new ListValue()); |
683 Value* original_list = scoped_list.get(); | 682 Value* original_list = scoped_list.get(); |
684 std::unique_ptr<Value> scoped_list_element_0(new Value(0)); | 683 std::unique_ptr<Value> scoped_list_element_0(new Value(0)); |
685 Value* original_list_element_0 = scoped_list_element_0.get(); | 684 Value* original_list_element_0 = scoped_list_element_0.get(); |
686 scoped_list->Append(std::move(scoped_list_element_0)); | 685 scoped_list->Append(std::move(scoped_list_element_0)); |
687 std::unique_ptr<Value> scoped_list_element_1(new Value(1)); | 686 std::unique_ptr<Value> scoped_list_element_1(new Value(1)); |
688 Value* original_list_element_1 = scoped_list_element_1.get(); | 687 Value* original_list_element_1 = scoped_list_element_1.get(); |
689 scoped_list->Append(std::move(scoped_list_element_1)); | 688 scoped_list->Append(std::move(scoped_list_element_1)); |
(...skipping 311 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1001 Value* original_double = scoped_double.get(); | 1000 Value* original_double = scoped_double.get(); |
1002 original_dict.Set("double", std::move(scoped_double)); | 1001 original_dict.Set("double", std::move(scoped_double)); |
1003 std::unique_ptr<Value> scoped_string(new Value("hello")); | 1002 std::unique_ptr<Value> scoped_string(new Value("hello")); |
1004 Value* original_string = scoped_string.get(); | 1003 Value* original_string = scoped_string.get(); |
1005 original_dict.Set("string", std::move(scoped_string)); | 1004 original_dict.Set("string", std::move(scoped_string)); |
1006 std::unique_ptr<Value> scoped_string16(new Value(ASCIIToUTF16("hello16"))); | 1005 std::unique_ptr<Value> scoped_string16(new Value(ASCIIToUTF16("hello16"))); |
1007 Value* original_string16 = scoped_string16.get(); | 1006 Value* original_string16 = scoped_string16.get(); |
1008 original_dict.Set("string16", std::move(scoped_string16)); | 1007 original_dict.Set("string16", std::move(scoped_string16)); |
1009 | 1008 |
1010 std::vector<char> original_buffer(42, '!'); | 1009 std::vector<char> original_buffer(42, '!'); |
1011 std::unique_ptr<BinaryValue> scoped_binary( | 1010 std::unique_ptr<Value> scoped_binary(new Value(std::move(original_buffer))); |
1012 new BinaryValue(std::move(original_buffer))); | |
1013 Value* original_binary = scoped_binary.get(); | 1011 Value* original_binary = scoped_binary.get(); |
1014 original_dict.Set("binary", std::move(scoped_binary)); | 1012 original_dict.Set("binary", std::move(scoped_binary)); |
1015 | 1013 |
1016 std::unique_ptr<ListValue> scoped_list(new ListValue()); | 1014 std::unique_ptr<ListValue> scoped_list(new ListValue()); |
1017 Value* original_list = scoped_list.get(); | 1015 Value* original_list = scoped_list.get(); |
1018 std::unique_ptr<Value> scoped_list_element_0(new Value(0)); | 1016 std::unique_ptr<Value> scoped_list_element_0(new Value(0)); |
1019 scoped_list->Append(std::move(scoped_list_element_0)); | 1017 scoped_list->Append(std::move(scoped_list_element_0)); |
1020 std::unique_ptr<Value> scoped_list_element_1(new Value(1)); | 1018 std::unique_ptr<Value> scoped_list_element_1(new Value(1)); |
1021 scoped_list->Append(std::move(scoped_list_element_1)); | 1019 scoped_list->Append(std::move(scoped_list_element_1)); |
1022 original_dict.Set("list", std::move(scoped_list)); | 1020 original_dict.Set("list", std::move(scoped_list)); |
(...skipping 214 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1237 // DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value | 1235 // DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value |
1238 // and still return true/false based on success. | 1236 // and still return true/false based on success. |
1239 TEST(ValuesTest, GetWithNullOutValue) { | 1237 TEST(ValuesTest, GetWithNullOutValue) { |
1240 DictionaryValue main_dict; | 1238 DictionaryValue main_dict; |
1241 ListValue main_list; | 1239 ListValue main_list; |
1242 | 1240 |
1243 Value bool_value(false); | 1241 Value bool_value(false); |
1244 Value int_value(1234); | 1242 Value int_value(1234); |
1245 Value double_value(12.34567); | 1243 Value double_value(12.34567); |
1246 Value string_value("foo"); | 1244 Value string_value("foo"); |
1247 BinaryValue binary_value(Value::Type::BINARY); | 1245 Value binary_value(Value::Type::BINARY); |
1248 DictionaryValue dict_value; | 1246 DictionaryValue dict_value; |
1249 ListValue list_value; | 1247 ListValue list_value; |
1250 | 1248 |
1251 main_dict.Set("bool", MakeUnique<Value>(bool_value)); | 1249 main_dict.Set("bool", MakeUnique<Value>(bool_value)); |
1252 main_dict.Set("int", MakeUnique<Value>(int_value)); | 1250 main_dict.Set("int", MakeUnique<Value>(int_value)); |
1253 main_dict.Set("double", MakeUnique<Value>(double_value)); | 1251 main_dict.Set("double", MakeUnique<Value>(double_value)); |
1254 main_dict.Set("string", MakeUnique<Value>(string_value)); | 1252 main_dict.Set("string", MakeUnique<Value>(string_value)); |
1255 main_dict.Set("binary", MakeUnique<Value>(binary_value)); | 1253 main_dict.Set("binary", MakeUnique<Value>(binary_value)); |
1256 main_dict.Set("dict", MakeUnique<Value>(dict_value)); | 1254 main_dict.Set("dict", MakeUnique<Value>(dict_value)); |
1257 main_dict.Set("list", MakeUnique<Value>(list_value)); | 1255 main_dict.Set("list", MakeUnique<Value>(list_value)); |
(...skipping 261 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1519 EXPECT_FALSE(main_list.GetList(7, NULL)); | 1517 EXPECT_FALSE(main_list.GetList(7, NULL)); |
1520 } | 1518 } |
1521 | 1519 |
1522 TEST(ValuesTest, SelfSwap) { | 1520 TEST(ValuesTest, SelfSwap) { |
1523 base::Value test(1); | 1521 base::Value test(1); |
1524 std::swap(test, test); | 1522 std::swap(test, test); |
1525 EXPECT_TRUE(test.GetInt() == 1); | 1523 EXPECT_TRUE(test.GetInt() == 1); |
1526 } | 1524 } |
1527 | 1525 |
1528 } // namespace base | 1526 } // namespace base |
OLD | NEW |