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 "dbus/values_util.h" | 5 #include "dbus/values_util.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <cmath> | 10 #include <cmath> |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
48 writer.AppendString(kEmptyStringValue); | 48 writer.AppendString(kEmptyStringValue); |
49 const ObjectPath kObjectPathValue("/ObjectPath"); | 49 const ObjectPath kObjectPathValue("/ObjectPath"); |
50 writer.AppendObjectPath(kObjectPathValue); | 50 writer.AppendObjectPath(kObjectPathValue); |
51 | 51 |
52 MessageReader reader(response.get()); | 52 MessageReader reader(response.get()); |
53 std::unique_ptr<base::Value> value; | 53 std::unique_ptr<base::Value> value; |
54 std::unique_ptr<base::Value> expected_value; | 54 std::unique_ptr<base::Value> expected_value; |
55 // Pop a byte. | 55 // Pop a byte. |
56 value = PopDataAsValue(&reader); | 56 value = PopDataAsValue(&reader); |
57 ASSERT_TRUE(value.get() != NULL); | 57 ASSERT_TRUE(value.get() != NULL); |
58 expected_value.reset(new base::FundamentalValue(kByteValue)); | 58 expected_value.reset(new base::Value(kByteValue)); |
59 EXPECT_TRUE(value->Equals(expected_value.get())); | 59 EXPECT_TRUE(value->Equals(expected_value.get())); |
60 // Pop a bool. | 60 // Pop a bool. |
61 value = PopDataAsValue(&reader); | 61 value = PopDataAsValue(&reader); |
62 ASSERT_TRUE(value.get() != NULL); | 62 ASSERT_TRUE(value.get() != NULL); |
63 expected_value.reset(new base::FundamentalValue(kBoolValue)); | 63 expected_value.reset(new base::Value(kBoolValue)); |
64 EXPECT_TRUE(value->Equals(expected_value.get())); | 64 EXPECT_TRUE(value->Equals(expected_value.get())); |
65 // Pop an int16_t. | 65 // Pop an int16_t. |
66 value = PopDataAsValue(&reader); | 66 value = PopDataAsValue(&reader); |
67 ASSERT_TRUE(value.get() != NULL); | 67 ASSERT_TRUE(value.get() != NULL); |
68 expected_value.reset(new base::FundamentalValue(kInt16Value)); | 68 expected_value.reset(new base::Value(kInt16Value)); |
69 EXPECT_TRUE(value->Equals(expected_value.get())); | 69 EXPECT_TRUE(value->Equals(expected_value.get())); |
70 // Pop a uint16_t. | 70 // Pop a uint16_t. |
71 value = PopDataAsValue(&reader); | 71 value = PopDataAsValue(&reader); |
72 ASSERT_TRUE(value.get() != NULL); | 72 ASSERT_TRUE(value.get() != NULL); |
73 expected_value.reset(new base::FundamentalValue(kUint16Value)); | 73 expected_value.reset(new base::Value(kUint16Value)); |
74 EXPECT_TRUE(value->Equals(expected_value.get())); | 74 EXPECT_TRUE(value->Equals(expected_value.get())); |
75 // Pop an int32_t. | 75 // Pop an int32_t. |
76 value = PopDataAsValue(&reader); | 76 value = PopDataAsValue(&reader); |
77 ASSERT_TRUE(value.get() != NULL); | 77 ASSERT_TRUE(value.get() != NULL); |
78 expected_value.reset(new base::FundamentalValue(kInt32Value)); | 78 expected_value.reset(new base::Value(kInt32Value)); |
79 EXPECT_TRUE(value->Equals(expected_value.get())); | 79 EXPECT_TRUE(value->Equals(expected_value.get())); |
80 // Pop a uint32_t. | 80 // Pop a uint32_t. |
81 value = PopDataAsValue(&reader); | 81 value = PopDataAsValue(&reader); |
82 ASSERT_TRUE(value.get() != NULL); | 82 ASSERT_TRUE(value.get() != NULL); |
83 expected_value.reset( | 83 expected_value.reset(new base::Value(static_cast<double>(kUint32Value))); |
84 new base::FundamentalValue(static_cast<double>(kUint32Value))); | |
85 EXPECT_TRUE(value->Equals(expected_value.get())); | 84 EXPECT_TRUE(value->Equals(expected_value.get())); |
86 // Pop an int64_t. | 85 // Pop an int64_t. |
87 value = PopDataAsValue(&reader); | 86 value = PopDataAsValue(&reader); |
88 ASSERT_TRUE(value.get() != NULL); | 87 ASSERT_TRUE(value.get() != NULL); |
89 expected_value.reset( | 88 expected_value.reset(new base::Value(static_cast<double>(kInt64Value))); |
90 new base::FundamentalValue(static_cast<double>(kInt64Value))); | |
91 EXPECT_TRUE(value->Equals(expected_value.get())); | 89 EXPECT_TRUE(value->Equals(expected_value.get())); |
92 // Pop a uint64_t. | 90 // Pop a uint64_t. |
93 value = PopDataAsValue(&reader); | 91 value = PopDataAsValue(&reader); |
94 ASSERT_TRUE(value.get() != NULL); | 92 ASSERT_TRUE(value.get() != NULL); |
95 expected_value.reset( | 93 expected_value.reset(new base::Value(static_cast<double>(kUint64Value))); |
96 new base::FundamentalValue(static_cast<double>(kUint64Value))); | |
97 EXPECT_TRUE(value->Equals(expected_value.get())); | 94 EXPECT_TRUE(value->Equals(expected_value.get())); |
98 // Pop a double. | 95 // Pop a double. |
99 value = PopDataAsValue(&reader); | 96 value = PopDataAsValue(&reader); |
100 ASSERT_TRUE(value.get() != NULL); | 97 ASSERT_TRUE(value.get() != NULL); |
101 expected_value.reset(new base::FundamentalValue(kDoubleValue)); | 98 expected_value.reset(new base::Value(kDoubleValue)); |
102 EXPECT_TRUE(value->Equals(expected_value.get())); | 99 EXPECT_TRUE(value->Equals(expected_value.get())); |
103 // Pop a string. | 100 // Pop a string. |
104 value = PopDataAsValue(&reader); | 101 value = PopDataAsValue(&reader); |
105 ASSERT_TRUE(value.get() != NULL); | 102 ASSERT_TRUE(value.get() != NULL); |
106 expected_value.reset(new base::StringValue(kStringValue)); | 103 expected_value.reset(new base::StringValue(kStringValue)); |
107 EXPECT_TRUE(value->Equals(expected_value.get())); | 104 EXPECT_TRUE(value->Equals(expected_value.get())); |
108 // Pop an empty string. | 105 // Pop an empty string. |
109 value = PopDataAsValue(&reader); | 106 value = PopDataAsValue(&reader); |
110 ASSERT_TRUE(value.get() != NULL); | 107 ASSERT_TRUE(value.get() != NULL); |
111 expected_value.reset(new base::StringValue(kEmptyStringValue)); | 108 expected_value.reset(new base::StringValue(kEmptyStringValue)); |
(...skipping 17 matching lines...) Expand all Loading... |
129 writer.AppendVariantOfDouble(kDoubleValue); | 126 writer.AppendVariantOfDouble(kDoubleValue); |
130 const std::string kStringValue = "fifty"; | 127 const std::string kStringValue = "fifty"; |
131 writer.AppendVariantOfString(kStringValue); | 128 writer.AppendVariantOfString(kStringValue); |
132 | 129 |
133 MessageReader reader(response.get()); | 130 MessageReader reader(response.get()); |
134 std::unique_ptr<base::Value> value; | 131 std::unique_ptr<base::Value> value; |
135 std::unique_ptr<base::Value> expected_value; | 132 std::unique_ptr<base::Value> expected_value; |
136 // Pop a bool. | 133 // Pop a bool. |
137 value = PopDataAsValue(&reader); | 134 value = PopDataAsValue(&reader); |
138 ASSERT_TRUE(value.get() != NULL); | 135 ASSERT_TRUE(value.get() != NULL); |
139 expected_value.reset(new base::FundamentalValue(kBoolValue)); | 136 expected_value.reset(new base::Value(kBoolValue)); |
140 EXPECT_TRUE(value->Equals(expected_value.get())); | 137 EXPECT_TRUE(value->Equals(expected_value.get())); |
141 // Pop an int32_t. | 138 // Pop an int32_t. |
142 value = PopDataAsValue(&reader); | 139 value = PopDataAsValue(&reader); |
143 ASSERT_TRUE(value.get() != NULL); | 140 ASSERT_TRUE(value.get() != NULL); |
144 expected_value.reset(new base::FundamentalValue(kInt32Value)); | 141 expected_value.reset(new base::Value(kInt32Value)); |
145 EXPECT_TRUE(value->Equals(expected_value.get())); | 142 EXPECT_TRUE(value->Equals(expected_value.get())); |
146 // Pop a double. | 143 // Pop a double. |
147 value = PopDataAsValue(&reader); | 144 value = PopDataAsValue(&reader); |
148 ASSERT_TRUE(value.get() != NULL); | 145 ASSERT_TRUE(value.get() != NULL); |
149 expected_value.reset(new base::FundamentalValue(kDoubleValue)); | 146 expected_value.reset(new base::Value(kDoubleValue)); |
150 EXPECT_TRUE(value->Equals(expected_value.get())); | 147 EXPECT_TRUE(value->Equals(expected_value.get())); |
151 // Pop a string. | 148 // Pop a string. |
152 value = PopDataAsValue(&reader); | 149 value = PopDataAsValue(&reader); |
153 ASSERT_TRUE(value.get() != NULL); | 150 ASSERT_TRUE(value.get() != NULL); |
154 expected_value.reset(new base::StringValue(kStringValue)); | 151 expected_value.reset(new base::StringValue(kStringValue)); |
155 EXPECT_TRUE(value->Equals(expected_value.get())); | 152 EXPECT_TRUE(value->Equals(expected_value.get())); |
156 } | 153 } |
157 | 154 |
158 // Pop extremely large integers which cannot be precisely represented in | 155 // Pop extremely large integers which cannot be precisely represented in |
159 // double. | 156 // double. |
160 TEST(ValuesUtilTest, PopExtremelyLargeIntegers) { | 157 TEST(ValuesUtilTest, PopExtremelyLargeIntegers) { |
161 std::unique_ptr<Response> response(Response::CreateEmpty()); | 158 std::unique_ptr<Response> response(Response::CreateEmpty()); |
162 // Append large integers. | 159 // Append large integers. |
163 MessageWriter writer(response.get()); | 160 MessageWriter writer(response.get()); |
164 const int64_t kInt64Value = -123456789012345689LL; | 161 const int64_t kInt64Value = -123456789012345689LL; |
165 writer.AppendInt64(kInt64Value); | 162 writer.AppendInt64(kInt64Value); |
166 const uint64_t kUint64Value = 9876543210987654321ULL; | 163 const uint64_t kUint64Value = 9876543210987654321ULL; |
167 writer.AppendUint64(kUint64Value); | 164 writer.AppendUint64(kUint64Value); |
168 | 165 |
169 MessageReader reader(response.get()); | 166 MessageReader reader(response.get()); |
170 std::unique_ptr<base::Value> value; | 167 std::unique_ptr<base::Value> value; |
171 std::unique_ptr<base::Value> expected_value; | 168 std::unique_ptr<base::Value> expected_value; |
172 double double_value = 0; | 169 double double_value = 0; |
173 // Pop an int64_t. | 170 // Pop an int64_t. |
174 value = PopDataAsValue(&reader); | 171 value = PopDataAsValue(&reader); |
175 ASSERT_TRUE(value.get() != NULL); | 172 ASSERT_TRUE(value.get() != NULL); |
176 expected_value.reset( | 173 expected_value.reset(new base::Value(static_cast<double>(kInt64Value))); |
177 new base::FundamentalValue(static_cast<double>(kInt64Value))); | |
178 EXPECT_TRUE(value->Equals(expected_value.get())); | 174 EXPECT_TRUE(value->Equals(expected_value.get())); |
179 ASSERT_TRUE(value->GetAsDouble(&double_value)); | 175 ASSERT_TRUE(value->GetAsDouble(&double_value)); |
180 EXPECT_NE(kInt64Value, static_cast<int64_t>(double_value)); | 176 EXPECT_NE(kInt64Value, static_cast<int64_t>(double_value)); |
181 // Pop a uint64_t. | 177 // Pop a uint64_t. |
182 value = PopDataAsValue(&reader); | 178 value = PopDataAsValue(&reader); |
183 ASSERT_TRUE(value.get() != NULL); | 179 ASSERT_TRUE(value.get() != NULL); |
184 expected_value.reset( | 180 expected_value.reset(new base::Value(static_cast<double>(kUint64Value))); |
185 new base::FundamentalValue(static_cast<double>(kUint64Value))); | |
186 EXPECT_TRUE(value->Equals(expected_value.get())); | 181 EXPECT_TRUE(value->Equals(expected_value.get())); |
187 ASSERT_TRUE(value->GetAsDouble(&double_value)); | 182 ASSERT_TRUE(value->GetAsDouble(&double_value)); |
188 EXPECT_NE(kUint64Value, static_cast<uint64_t>(double_value)); | 183 EXPECT_NE(kUint64Value, static_cast<uint64_t>(double_value)); |
189 } | 184 } |
190 | 185 |
191 TEST(ValuesUtilTest, PopIntArray) { | 186 TEST(ValuesUtilTest, PopIntArray) { |
192 std::unique_ptr<Response> response(Response::CreateEmpty()); | 187 std::unique_ptr<Response> response(Response::CreateEmpty()); |
193 // Append an int32_t array. | 188 // Append an int32_t array. |
194 MessageWriter writer(response.get()); | 189 MessageWriter writer(response.get()); |
195 MessageWriter sub_writer(NULL); | 190 MessageWriter sub_writer(NULL); |
(...skipping 140 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
336 sub_writer.OpenDictEntry(&entry_writer); | 331 sub_writer.OpenDictEntry(&entry_writer); |
337 const std::string kKey3 = "example."; // String ending with a dot. | 332 const std::string kKey3 = "example."; // String ending with a dot. |
338 entry_writer.AppendString(kKey3); | 333 entry_writer.AppendString(kKey3); |
339 const double kDoubleValue = 4.9; | 334 const double kDoubleValue = 4.9; |
340 entry_writer.AppendVariantOfDouble(kDoubleValue); | 335 entry_writer.AppendVariantOfDouble(kDoubleValue); |
341 sub_writer.CloseContainer(&entry_writer); | 336 sub_writer.CloseContainer(&entry_writer); |
342 writer.CloseContainer(&sub_writer); | 337 writer.CloseContainer(&sub_writer); |
343 | 338 |
344 // Create the expected value. | 339 // Create the expected value. |
345 base::DictionaryValue dictionary_value; | 340 base::DictionaryValue dictionary_value; |
346 dictionary_value.SetWithoutPathExpansion( | 341 dictionary_value.SetWithoutPathExpansion(kKey1, new base::Value(kBoolValue)); |
347 kKey1, new base::FundamentalValue(kBoolValue)); | 342 dictionary_value.SetWithoutPathExpansion(kKey2, new base::Value(kInt32Value)); |
348 dictionary_value.SetWithoutPathExpansion( | 343 dictionary_value.SetWithoutPathExpansion(kKey3, |
349 kKey2, new base::FundamentalValue(kInt32Value)); | 344 new base::Value(kDoubleValue)); |
350 dictionary_value.SetWithoutPathExpansion( | |
351 kKey3, new base::FundamentalValue(kDoubleValue)); | |
352 | 345 |
353 // Pop a dictinoary. | 346 // Pop a dictinoary. |
354 MessageReader reader(response.get()); | 347 MessageReader reader(response.get()); |
355 std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); | 348 std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
356 ASSERT_TRUE(value.get() != NULL); | 349 ASSERT_TRUE(value.get() != NULL); |
357 EXPECT_TRUE(value->Equals(&dictionary_value)); | 350 EXPECT_TRUE(value->Equals(&dictionary_value)); |
358 } | 351 } |
359 | 352 |
360 TEST(ValuesUtilTest, PopDoubleToIntDictionary) { | 353 TEST(ValuesUtilTest, PopDoubleToIntDictionary) { |
361 // Create test data. | 354 // Create test data. |
(...skipping 14 matching lines...) Expand all Loading... |
376 entry_writer.AppendDouble(keys[i]); | 369 entry_writer.AppendDouble(keys[i]); |
377 entry_writer.AppendInt32(values[i]); | 370 entry_writer.AppendInt32(values[i]); |
378 sub_writer.CloseContainer(&entry_writer); | 371 sub_writer.CloseContainer(&entry_writer); |
379 } | 372 } |
380 writer.CloseContainer(&sub_writer); | 373 writer.CloseContainer(&sub_writer); |
381 | 374 |
382 // Create the expected value. | 375 // Create the expected value. |
383 base::DictionaryValue dictionary_value; | 376 base::DictionaryValue dictionary_value; |
384 for (size_t i = 0; i != values.size(); ++i) { | 377 for (size_t i = 0; i != values.size(); ++i) { |
385 std::string key_string; | 378 std::string key_string; |
386 base::JSONWriter::Write(base::FundamentalValue(keys[i]), &key_string); | 379 base::JSONWriter::Write(base::Value(keys[i]), &key_string); |
387 dictionary_value.SetIntegerWithoutPathExpansion(key_string, values[i]); | 380 dictionary_value.SetIntegerWithoutPathExpansion(key_string, values[i]); |
388 } | 381 } |
389 | 382 |
390 // Pop a dictionary. | 383 // Pop a dictionary. |
391 MessageReader reader(response.get()); | 384 MessageReader reader(response.get()); |
392 std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); | 385 std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
393 ASSERT_TRUE(value.get() != NULL); | 386 ASSERT_TRUE(value.get() != NULL); |
394 EXPECT_TRUE(value->Equals(&dictionary_value)); | 387 EXPECT_TRUE(value->Equals(&dictionary_value)); |
395 } | 388 } |
396 | 389 |
397 TEST(ValuesUtilTest, AppendBasicTypes) { | 390 TEST(ValuesUtilTest, AppendBasicTypes) { |
398 const base::FundamentalValue kBoolValue(false); | 391 const base::Value kBoolValue(false); |
399 const base::FundamentalValue kIntegerValue(42); | 392 const base::Value kIntegerValue(42); |
400 const base::FundamentalValue kDoubleValue(4.2); | 393 const base::Value kDoubleValue(4.2); |
401 const base::StringValue kStringValue("string"); | 394 const base::StringValue kStringValue("string"); |
402 | 395 |
403 std::unique_ptr<Response> response(Response::CreateEmpty()); | 396 std::unique_ptr<Response> response(Response::CreateEmpty()); |
404 MessageWriter writer(response.get()); | 397 MessageWriter writer(response.get()); |
405 AppendBasicTypeValueData(&writer, kBoolValue); | 398 AppendBasicTypeValueData(&writer, kBoolValue); |
406 AppendBasicTypeValueData(&writer, kIntegerValue); | 399 AppendBasicTypeValueData(&writer, kIntegerValue); |
407 AppendBasicTypeValueData(&writer, kDoubleValue); | 400 AppendBasicTypeValueData(&writer, kDoubleValue); |
408 AppendBasicTypeValueData(&writer, kStringValue); | 401 AppendBasicTypeValueData(&writer, kStringValue); |
409 | 402 |
410 MessageReader reader(response.get()); | 403 MessageReader reader(response.get()); |
411 std::unique_ptr<base::Value> value; | 404 std::unique_ptr<base::Value> value; |
412 value = PopDataAsValue(&reader); | 405 value = PopDataAsValue(&reader); |
413 ASSERT_TRUE(value.get() != NULL); | 406 ASSERT_TRUE(value.get() != NULL); |
414 EXPECT_TRUE(value->Equals(&kBoolValue)); | 407 EXPECT_TRUE(value->Equals(&kBoolValue)); |
415 value = PopDataAsValue(&reader); | 408 value = PopDataAsValue(&reader); |
416 ASSERT_TRUE(value.get() != NULL); | 409 ASSERT_TRUE(value.get() != NULL); |
417 EXPECT_TRUE(value->Equals(&kIntegerValue)); | 410 EXPECT_TRUE(value->Equals(&kIntegerValue)); |
418 value = PopDataAsValue(&reader); | 411 value = PopDataAsValue(&reader); |
419 ASSERT_TRUE(value.get() != NULL); | 412 ASSERT_TRUE(value.get() != NULL); |
420 EXPECT_TRUE(value->Equals(&kDoubleValue)); | 413 EXPECT_TRUE(value->Equals(&kDoubleValue)); |
421 value = PopDataAsValue(&reader); | 414 value = PopDataAsValue(&reader); |
422 ASSERT_TRUE(value.get() != NULL); | 415 ASSERT_TRUE(value.get() != NULL); |
423 EXPECT_TRUE(value->Equals(&kStringValue)); | 416 EXPECT_TRUE(value->Equals(&kStringValue)); |
424 } | 417 } |
425 | 418 |
426 TEST(ValuesUtilTest, AppendBasicTypesAsVariant) { | 419 TEST(ValuesUtilTest, AppendBasicTypesAsVariant) { |
427 const base::FundamentalValue kBoolValue(false); | 420 const base::Value kBoolValue(false); |
428 const base::FundamentalValue kIntegerValue(42); | 421 const base::Value kIntegerValue(42); |
429 const base::FundamentalValue kDoubleValue(4.2); | 422 const base::Value kDoubleValue(4.2); |
430 const base::StringValue kStringValue("string"); | 423 const base::StringValue kStringValue("string"); |
431 | 424 |
432 std::unique_ptr<Response> response(Response::CreateEmpty()); | 425 std::unique_ptr<Response> response(Response::CreateEmpty()); |
433 MessageWriter writer(response.get()); | 426 MessageWriter writer(response.get()); |
434 AppendBasicTypeValueDataAsVariant(&writer, kBoolValue); | 427 AppendBasicTypeValueDataAsVariant(&writer, kBoolValue); |
435 AppendBasicTypeValueDataAsVariant(&writer, kIntegerValue); | 428 AppendBasicTypeValueDataAsVariant(&writer, kIntegerValue); |
436 AppendBasicTypeValueDataAsVariant(&writer, kDoubleValue); | 429 AppendBasicTypeValueDataAsVariant(&writer, kDoubleValue); |
437 AppendBasicTypeValueDataAsVariant(&writer, kStringValue); | 430 AppendBasicTypeValueDataAsVariant(&writer, kStringValue); |
438 | 431 |
439 MessageReader reader(response.get()); | 432 MessageReader reader(response.get()); |
440 std::unique_ptr<base::Value> value; | 433 std::unique_ptr<base::Value> value; |
441 value = PopDataAsValue(&reader); | 434 value = PopDataAsValue(&reader); |
442 ASSERT_TRUE(value.get() != NULL); | 435 ASSERT_TRUE(value.get() != NULL); |
443 EXPECT_TRUE(value->Equals(&kBoolValue)); | 436 EXPECT_TRUE(value->Equals(&kBoolValue)); |
444 value = PopDataAsValue(&reader); | 437 value = PopDataAsValue(&reader); |
445 ASSERT_TRUE(value.get() != NULL); | 438 ASSERT_TRUE(value.get() != NULL); |
446 EXPECT_TRUE(value->Equals(&kIntegerValue)); | 439 EXPECT_TRUE(value->Equals(&kIntegerValue)); |
447 value = PopDataAsValue(&reader); | 440 value = PopDataAsValue(&reader); |
448 ASSERT_TRUE(value.get() != NULL); | 441 ASSERT_TRUE(value.get() != NULL); |
449 EXPECT_TRUE(value->Equals(&kDoubleValue)); | 442 EXPECT_TRUE(value->Equals(&kDoubleValue)); |
450 value = PopDataAsValue(&reader); | 443 value = PopDataAsValue(&reader); |
451 ASSERT_TRUE(value.get() != NULL); | 444 ASSERT_TRUE(value.get() != NULL); |
452 EXPECT_TRUE(value->Equals(&kStringValue)); | 445 EXPECT_TRUE(value->Equals(&kStringValue)); |
453 } | 446 } |
454 | 447 |
455 TEST(ValuesUtilTest, AppendValueDataBasicTypes) { | 448 TEST(ValuesUtilTest, AppendValueDataBasicTypes) { |
456 const base::FundamentalValue kBoolValue(false); | 449 const base::Value kBoolValue(false); |
457 const base::FundamentalValue kIntegerValue(42); | 450 const base::Value kIntegerValue(42); |
458 const base::FundamentalValue kDoubleValue(4.2); | 451 const base::Value kDoubleValue(4.2); |
459 const base::StringValue kStringValue("string"); | 452 const base::StringValue kStringValue("string"); |
460 | 453 |
461 std::unique_ptr<Response> response(Response::CreateEmpty()); | 454 std::unique_ptr<Response> response(Response::CreateEmpty()); |
462 MessageWriter writer(response.get()); | 455 MessageWriter writer(response.get()); |
463 AppendValueData(&writer, kBoolValue); | 456 AppendValueData(&writer, kBoolValue); |
464 AppendValueData(&writer, kIntegerValue); | 457 AppendValueData(&writer, kIntegerValue); |
465 AppendValueData(&writer, kDoubleValue); | 458 AppendValueData(&writer, kDoubleValue); |
466 AppendValueData(&writer, kStringValue); | 459 AppendValueData(&writer, kStringValue); |
467 | 460 |
468 MessageReader reader(response.get()); | 461 MessageReader reader(response.get()); |
469 std::unique_ptr<base::Value> value; | 462 std::unique_ptr<base::Value> value; |
470 value = PopDataAsValue(&reader); | 463 value = PopDataAsValue(&reader); |
471 ASSERT_TRUE(value.get() != NULL); | 464 ASSERT_TRUE(value.get() != NULL); |
472 EXPECT_TRUE(value->Equals(&kBoolValue)); | 465 EXPECT_TRUE(value->Equals(&kBoolValue)); |
473 value = PopDataAsValue(&reader); | 466 value = PopDataAsValue(&reader); |
474 ASSERT_TRUE(value.get() != NULL); | 467 ASSERT_TRUE(value.get() != NULL); |
475 EXPECT_TRUE(value->Equals(&kIntegerValue)); | 468 EXPECT_TRUE(value->Equals(&kIntegerValue)); |
476 value = PopDataAsValue(&reader); | 469 value = PopDataAsValue(&reader); |
477 ASSERT_TRUE(value.get() != NULL); | 470 ASSERT_TRUE(value.get() != NULL); |
478 EXPECT_TRUE(value->Equals(&kDoubleValue)); | 471 EXPECT_TRUE(value->Equals(&kDoubleValue)); |
479 value = PopDataAsValue(&reader); | 472 value = PopDataAsValue(&reader); |
480 ASSERT_TRUE(value.get() != NULL); | 473 ASSERT_TRUE(value.get() != NULL); |
481 EXPECT_TRUE(value->Equals(&kStringValue)); | 474 EXPECT_TRUE(value->Equals(&kStringValue)); |
482 } | 475 } |
483 | 476 |
484 TEST(ValuesUtilTest, AppendValueDataAsVariantBasicTypes) { | 477 TEST(ValuesUtilTest, AppendValueDataAsVariantBasicTypes) { |
485 const base::FundamentalValue kBoolValue(false); | 478 const base::Value kBoolValue(false); |
486 const base::FundamentalValue kIntegerValue(42); | 479 const base::Value kIntegerValue(42); |
487 const base::FundamentalValue kDoubleValue(4.2); | 480 const base::Value kDoubleValue(4.2); |
488 const base::StringValue kStringValue("string"); | 481 const base::StringValue kStringValue("string"); |
489 | 482 |
490 std::unique_ptr<Response> response(Response::CreateEmpty()); | 483 std::unique_ptr<Response> response(Response::CreateEmpty()); |
491 MessageWriter writer(response.get()); | 484 MessageWriter writer(response.get()); |
492 AppendValueDataAsVariant(&writer, kBoolValue); | 485 AppendValueDataAsVariant(&writer, kBoolValue); |
493 AppendValueDataAsVariant(&writer, kIntegerValue); | 486 AppendValueDataAsVariant(&writer, kIntegerValue); |
494 AppendValueDataAsVariant(&writer, kDoubleValue); | 487 AppendValueDataAsVariant(&writer, kDoubleValue); |
495 AppendValueDataAsVariant(&writer, kStringValue); | 488 AppendValueDataAsVariant(&writer, kStringValue); |
496 | 489 |
497 MessageReader reader(response.get()); | 490 MessageReader reader(response.get()); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
536 test_dictionary.SetBoolean(kKey1, kBoolValue); | 529 test_dictionary.SetBoolean(kKey1, kBoolValue); |
537 test_dictionary.SetInteger(kKey2, kInt32Value); | 530 test_dictionary.SetInteger(kKey2, kInt32Value); |
538 test_dictionary.SetDouble(kKey3, kDoubleValue); | 531 test_dictionary.SetDouble(kKey3, kDoubleValue); |
539 test_dictionary.SetString(kKey4, kStringValue); | 532 test_dictionary.SetString(kKey4, kStringValue); |
540 test_dictionary.Set(kKey5, list_value); // takes ownership | 533 test_dictionary.Set(kKey5, list_value); // takes ownership |
541 test_dictionary.Set(kKey6, dictionary_value); // takes ownership | 534 test_dictionary.Set(kKey6, dictionary_value); // takes ownership |
542 | 535 |
543 std::unique_ptr<Response> response(Response::CreateEmpty()); | 536 std::unique_ptr<Response> response(Response::CreateEmpty()); |
544 MessageWriter writer(response.get()); | 537 MessageWriter writer(response.get()); |
545 AppendValueData(&writer, test_dictionary); | 538 AppendValueData(&writer, test_dictionary); |
546 base::FundamentalValue int_value(kInt32Value); | 539 base::Value int_value(kInt32Value); |
547 AppendValueData(&writer, int_value); | 540 AppendValueData(&writer, int_value); |
548 | 541 |
549 // Read the data. | 542 // Read the data. |
550 MessageReader reader(response.get()); | 543 MessageReader reader(response.get()); |
551 std::unique_ptr<base::Value> value; | 544 std::unique_ptr<base::Value> value; |
552 value = PopDataAsValue(&reader); | 545 value = PopDataAsValue(&reader); |
553 ASSERT_TRUE(value.get() != NULL); | 546 ASSERT_TRUE(value.get() != NULL); |
554 EXPECT_TRUE(value->Equals(&test_dictionary)); | 547 EXPECT_TRUE(value->Equals(&test_dictionary)); |
555 value = PopDataAsValue(&reader); | 548 value = PopDataAsValue(&reader); |
556 ASSERT_TRUE(value.get() != NULL); | 549 ASSERT_TRUE(value.get() != NULL); |
(...skipping 26 matching lines...) Expand all Loading... |
583 test_dictionary.SetBoolean(kKey1, kBoolValue); | 576 test_dictionary.SetBoolean(kKey1, kBoolValue); |
584 test_dictionary.SetInteger(kKey2, kInt32Value); | 577 test_dictionary.SetInteger(kKey2, kInt32Value); |
585 test_dictionary.SetDouble(kKey3, kDoubleValue); | 578 test_dictionary.SetDouble(kKey3, kDoubleValue); |
586 test_dictionary.SetString(kKey4, kStringValue); | 579 test_dictionary.SetString(kKey4, kStringValue); |
587 test_dictionary.Set(kKey5, list_value); // takes ownership | 580 test_dictionary.Set(kKey5, list_value); // takes ownership |
588 test_dictionary.Set(kKey6, dictionary_value); // takes ownership | 581 test_dictionary.Set(kKey6, dictionary_value); // takes ownership |
589 | 582 |
590 std::unique_ptr<Response> response(Response::CreateEmpty()); | 583 std::unique_ptr<Response> response(Response::CreateEmpty()); |
591 MessageWriter writer(response.get()); | 584 MessageWriter writer(response.get()); |
592 AppendValueDataAsVariant(&writer, test_dictionary); | 585 AppendValueDataAsVariant(&writer, test_dictionary); |
593 base::FundamentalValue int_value(kInt32Value); | 586 base::Value int_value(kInt32Value); |
594 AppendValueData(&writer, int_value); | 587 AppendValueData(&writer, int_value); |
595 | 588 |
596 // Read the data. | 589 // Read the data. |
597 MessageReader reader(response.get()); | 590 MessageReader reader(response.get()); |
598 std::unique_ptr<base::Value> value; | 591 std::unique_ptr<base::Value> value; |
599 value = PopDataAsValue(&reader); | 592 value = PopDataAsValue(&reader); |
600 ASSERT_TRUE(value.get() != NULL); | 593 ASSERT_TRUE(value.get() != NULL); |
601 EXPECT_TRUE(value->Equals(&test_dictionary)); | 594 EXPECT_TRUE(value->Equals(&test_dictionary)); |
602 value = PopDataAsValue(&reader); | 595 value = PopDataAsValue(&reader); |
603 ASSERT_TRUE(value.get() != NULL); | 596 ASSERT_TRUE(value.get() != NULL); |
(...skipping 23 matching lines...) Expand all Loading... |
627 test_list.AppendBoolean(kBoolValue); | 620 test_list.AppendBoolean(kBoolValue); |
628 test_list.AppendInteger(kInt32Value); | 621 test_list.AppendInteger(kInt32Value); |
629 test_list.AppendDouble(kDoubleValue); | 622 test_list.AppendDouble(kDoubleValue); |
630 test_list.AppendString(kStringValue); | 623 test_list.AppendString(kStringValue); |
631 test_list.Append(std::move(list_value)); | 624 test_list.Append(std::move(list_value)); |
632 test_list.Append(std::move(dictionary_value)); | 625 test_list.Append(std::move(dictionary_value)); |
633 | 626 |
634 std::unique_ptr<Response> response(Response::CreateEmpty()); | 627 std::unique_ptr<Response> response(Response::CreateEmpty()); |
635 MessageWriter writer(response.get()); | 628 MessageWriter writer(response.get()); |
636 AppendValueData(&writer, test_list); | 629 AppendValueData(&writer, test_list); |
637 base::FundamentalValue int_value(kInt32Value); | 630 base::Value int_value(kInt32Value); |
638 AppendValueData(&writer, int_value); | 631 AppendValueData(&writer, int_value); |
639 | 632 |
640 // Read the data. | 633 // Read the data. |
641 MessageReader reader(response.get()); | 634 MessageReader reader(response.get()); |
642 std::unique_ptr<base::Value> value; | 635 std::unique_ptr<base::Value> value; |
643 value = PopDataAsValue(&reader); | 636 value = PopDataAsValue(&reader); |
644 ASSERT_TRUE(value.get() != NULL); | 637 ASSERT_TRUE(value.get() != NULL); |
645 EXPECT_TRUE(value->Equals(&test_list)); | 638 EXPECT_TRUE(value->Equals(&test_list)); |
646 value = PopDataAsValue(&reader); | 639 value = PopDataAsValue(&reader); |
647 ASSERT_TRUE(value.get() != NULL); | 640 ASSERT_TRUE(value.get() != NULL); |
(...skipping 23 matching lines...) Expand all Loading... |
671 test_list.AppendBoolean(kBoolValue); | 664 test_list.AppendBoolean(kBoolValue); |
672 test_list.AppendInteger(kInt32Value); | 665 test_list.AppendInteger(kInt32Value); |
673 test_list.AppendDouble(kDoubleValue); | 666 test_list.AppendDouble(kDoubleValue); |
674 test_list.AppendString(kStringValue); | 667 test_list.AppendString(kStringValue); |
675 test_list.Append(std::move(list_value)); | 668 test_list.Append(std::move(list_value)); |
676 test_list.Append(std::move(dictionary_value)); | 669 test_list.Append(std::move(dictionary_value)); |
677 | 670 |
678 std::unique_ptr<Response> response(Response::CreateEmpty()); | 671 std::unique_ptr<Response> response(Response::CreateEmpty()); |
679 MessageWriter writer(response.get()); | 672 MessageWriter writer(response.get()); |
680 AppendValueDataAsVariant(&writer, test_list); | 673 AppendValueDataAsVariant(&writer, test_list); |
681 base::FundamentalValue int_value(kInt32Value); | 674 base::Value int_value(kInt32Value); |
682 AppendValueData(&writer, int_value); | 675 AppendValueData(&writer, int_value); |
683 | 676 |
684 // Read the data. | 677 // Read the data. |
685 MessageReader reader(response.get()); | 678 MessageReader reader(response.get()); |
686 std::unique_ptr<base::Value> value; | 679 std::unique_ptr<base::Value> value; |
687 value = PopDataAsValue(&reader); | 680 value = PopDataAsValue(&reader); |
688 ASSERT_TRUE(value.get() != NULL); | 681 ASSERT_TRUE(value.get() != NULL); |
689 EXPECT_TRUE(value->Equals(&test_list)); | 682 EXPECT_TRUE(value->Equals(&test_list)); |
690 value = PopDataAsValue(&reader); | 683 value = PopDataAsValue(&reader); |
691 ASSERT_TRUE(value.get() != NULL); | 684 ASSERT_TRUE(value.get() != NULL); |
692 EXPECT_TRUE(value->Equals(&int_value)); | 685 EXPECT_TRUE(value->Equals(&int_value)); |
693 } | 686 } |
694 | 687 |
695 } // namespace dbus | 688 } // namespace dbus |
OLD | NEW |