hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 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 "dbus/values_util.h" |
| 6 | |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 7 | #include <stddef.h> |
| 8 | #include <stdint.h> |
| 9 | |
Hans Wennborg | acb4c7e | 2015-04-25 06:38:04 +0900 | [diff] [blame] | 10 | #include <cmath> |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 11 | #include <memory> |
dcheng | 7219b06 | 2016-06-11 12:41:48 +0900 | [diff] [blame] | 12 | #include <utility> |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 13 | #include <vector> |
| 14 | |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 15 | #include "base/json/json_writer.h" |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 16 | #include "base/macros.h" |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 17 | #include "base/values.h" |
| 18 | #include "dbus/message.h" |
| 19 | #include "testing/gtest/include/gtest/gtest.h" |
| 20 | |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 21 | namespace dbus { |
| 22 | |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 23 | TEST(ValuesUtilTest, PopBasicTypes) { |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 24 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 25 | // Append basic type values. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 26 | MessageWriter writer(response.get()); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 27 | const uint8_t kByteValue = 42; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 28 | writer.AppendByte(kByteValue); |
| 29 | const bool kBoolValue = true; |
| 30 | writer.AppendBool(kBoolValue); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 31 | const int16_t kInt16Value = -43; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 32 | writer.AppendInt16(kInt16Value); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 33 | const uint16_t kUint16Value = 44; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 34 | writer.AppendUint16(kUint16Value); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 35 | const int32_t kInt32Value = -45; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 36 | writer.AppendInt32(kInt32Value); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 37 | const uint32_t kUint32Value = 46; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 38 | writer.AppendUint32(kUint32Value); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 39 | const int64_t kInt64Value = -47; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 40 | writer.AppendInt64(kInt64Value); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 41 | const uint64_t kUint64Value = 48; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 42 | writer.AppendUint64(kUint64Value); |
| 43 | const double kDoubleValue = 4.9; |
| 44 | writer.AppendDouble(kDoubleValue); |
| 45 | const std::string kStringValue = "fifty"; |
| 46 | writer.AppendString(kStringValue); |
| 47 | const std::string kEmptyStringValue; |
| 48 | writer.AppendString(kEmptyStringValue); |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 49 | const ObjectPath kObjectPathValue("/ObjectPath"); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 50 | writer.AppendObjectPath(kObjectPathValue); |
| 51 | |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 52 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 53 | std::unique_ptr<base::Value> value; |
| 54 | std::unique_ptr<base::Value> expected_value; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 55 | // Pop a byte. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 56 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 57 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 58 | expected_value.reset(new base::Value(kByteValue)); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 59 | EXPECT_TRUE(value->Equals(expected_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 60 | // Pop a bool. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 61 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 62 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 63 | expected_value.reset(new base::Value(kBoolValue)); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 64 | EXPECT_TRUE(value->Equals(expected_value.get())); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 65 | // Pop an int16_t. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 66 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 67 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 68 | expected_value.reset(new base::Value(kInt16Value)); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 69 | EXPECT_TRUE(value->Equals(expected_value.get())); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 70 | // Pop a uint16_t. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 71 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 72 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 73 | expected_value.reset(new base::Value(kUint16Value)); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 74 | EXPECT_TRUE(value->Equals(expected_value.get())); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 75 | // Pop an int32_t. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 76 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 77 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 78 | expected_value.reset(new base::Value(kInt32Value)); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 79 | EXPECT_TRUE(value->Equals(expected_value.get())); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 80 | // Pop a uint32_t. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 81 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 82 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 83 | expected_value.reset(new base::Value(static_cast<double>(kUint32Value))); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 84 | EXPECT_TRUE(value->Equals(expected_value.get())); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 85 | // Pop an int64_t. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 86 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 87 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 88 | expected_value.reset(new base::Value(static_cast<double>(kInt64Value))); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 89 | EXPECT_TRUE(value->Equals(expected_value.get())); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 90 | // Pop a uint64_t. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 91 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 92 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 93 | expected_value.reset(new base::Value(static_cast<double>(kUint64Value))); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 94 | EXPECT_TRUE(value->Equals(expected_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 95 | // Pop a double. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 96 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 97 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 98 | expected_value.reset(new base::Value(kDoubleValue)); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 99 | EXPECT_TRUE(value->Equals(expected_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 100 | // Pop a string. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 101 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 102 | ASSERT_NE(nullptr, value); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 103 | expected_value.reset(new base::Value(kStringValue)); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 104 | EXPECT_TRUE(value->Equals(expected_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 105 | // Pop an empty string. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 106 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 107 | ASSERT_NE(nullptr, value); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 108 | expected_value.reset(new base::Value(kEmptyStringValue)); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 109 | EXPECT_TRUE(value->Equals(expected_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 110 | // Pop an object path. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 111 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 112 | ASSERT_NE(nullptr, value); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 113 | expected_value.reset(new base::Value(kObjectPathValue.value())); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 114 | EXPECT_TRUE(value->Equals(expected_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 115 | } |
| 116 | |
| 117 | TEST(ValuesUtilTest, PopVariant) { |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 118 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 119 | // Append variant values. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 120 | MessageWriter writer(response.get()); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 121 | const bool kBoolValue = true; |
| 122 | writer.AppendVariantOfBool(kBoolValue); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 123 | const int32_t kInt32Value = -45; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 124 | writer.AppendVariantOfInt32(kInt32Value); |
| 125 | const double kDoubleValue = 4.9; |
| 126 | writer.AppendVariantOfDouble(kDoubleValue); |
| 127 | const std::string kStringValue = "fifty"; |
| 128 | writer.AppendVariantOfString(kStringValue); |
| 129 | |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 130 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 131 | std::unique_ptr<base::Value> value; |
| 132 | std::unique_ptr<base::Value> expected_value; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 133 | // Pop a bool. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 134 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 135 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 136 | expected_value.reset(new base::Value(kBoolValue)); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 137 | EXPECT_TRUE(value->Equals(expected_value.get())); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 138 | // Pop an int32_t. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 139 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 140 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 141 | expected_value.reset(new base::Value(kInt32Value)); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 142 | EXPECT_TRUE(value->Equals(expected_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 143 | // Pop a double. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 144 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 145 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 146 | expected_value.reset(new base::Value(kDoubleValue)); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 147 | EXPECT_TRUE(value->Equals(expected_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 148 | // Pop a string. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 149 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 150 | ASSERT_NE(nullptr, value); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 151 | expected_value.reset(new base::Value(kStringValue)); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 152 | EXPECT_TRUE(value->Equals(expected_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 153 | } |
| 154 | |
| 155 | // Pop extremely large integers which cannot be precisely represented in |
| 156 | // double. |
| 157 | TEST(ValuesUtilTest, PopExtremelyLargeIntegers) { |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 158 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 159 | // Append large integers. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 160 | MessageWriter writer(response.get()); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 161 | const int64_t kInt64Value = -123456789012345689LL; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 162 | writer.AppendInt64(kInt64Value); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 163 | const uint64_t kUint64Value = 9876543210987654321ULL; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 164 | writer.AppendUint64(kUint64Value); |
| 165 | |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 166 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 167 | std::unique_ptr<base::Value> value; |
| 168 | std::unique_ptr<base::Value> expected_value; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 169 | double double_value = 0; |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 170 | // Pop an int64_t. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 171 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 172 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 173 | expected_value.reset(new base::Value(static_cast<double>(kInt64Value))); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 174 | EXPECT_TRUE(value->Equals(expected_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 175 | ASSERT_TRUE(value->GetAsDouble(&double_value)); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 176 | EXPECT_NE(kInt64Value, static_cast<int64_t>(double_value)); |
| 177 | // Pop a uint64_t. |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 178 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 179 | ASSERT_NE(nullptr, value); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 180 | expected_value.reset(new base::Value(static_cast<double>(kUint64Value))); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 181 | EXPECT_TRUE(value->Equals(expected_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 182 | ASSERT_TRUE(value->GetAsDouble(&double_value)); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 183 | EXPECT_NE(kUint64Value, static_cast<uint64_t>(double_value)); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 184 | } |
| 185 | |
| 186 | TEST(ValuesUtilTest, PopIntArray) { |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 187 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 188 | // Append an int32_t array. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 189 | MessageWriter writer(response.get()); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 190 | MessageWriter sub_writer(nullptr); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 191 | std::vector<int32_t> data; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 192 | data.push_back(0); |
| 193 | data.push_back(1); |
| 194 | data.push_back(2); |
| 195 | writer.OpenArray("i", &sub_writer); |
| 196 | for (size_t i = 0; i != data.size(); ++i) |
| 197 | sub_writer.AppendInt32(data[i]); |
| 198 | writer.CloseContainer(&sub_writer); |
| 199 | |
| 200 | // Create the expected value. |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 201 | std::unique_ptr<base::ListValue> list_value(new base::ListValue); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 202 | for (size_t i = 0; i != data.size(); ++i) |
dcheng | ef1ad82 | 2016-06-07 14:05:14 +0900 | [diff] [blame] | 203 | list_value->AppendInteger(data[i]); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 204 | |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 205 | // Pop an int32_t array. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 206 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 207 | std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 208 | ASSERT_NE(nullptr, value); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 209 | EXPECT_TRUE(value->Equals(list_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 210 | } |
| 211 | |
| 212 | TEST(ValuesUtilTest, PopStringArray) { |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 213 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 214 | // Append a string array. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 215 | MessageWriter writer(response.get()); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 216 | MessageWriter sub_writer(nullptr); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 217 | std::vector<std::string> data; |
| 218 | data.push_back("Dreamlifter"); |
| 219 | data.push_back("Beluga"); |
| 220 | data.push_back("Mriya"); |
| 221 | writer.AppendArrayOfStrings(data); |
| 222 | |
| 223 | // Create the expected value. |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 224 | std::unique_ptr<base::ListValue> list_value(new base::ListValue); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 225 | for (size_t i = 0; i != data.size(); ++i) |
dcheng | ef1ad82 | 2016-06-07 14:05:14 +0900 | [diff] [blame] | 226 | list_value->AppendString(data[i]); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 227 | |
| 228 | // Pop a string array. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 229 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 230 | std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 231 | ASSERT_NE(nullptr, value); |
satorux@chromium.org | 5e612da | 2012-05-31 15:55:53 +0900 | [diff] [blame] | 232 | EXPECT_TRUE(value->Equals(list_value.get())); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 233 | } |
| 234 | |
| 235 | TEST(ValuesUtilTest, PopStruct) { |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 236 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 237 | // Append a struct. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 238 | MessageWriter writer(response.get()); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 239 | MessageWriter sub_writer(nullptr); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 240 | writer.OpenStruct(&sub_writer); |
| 241 | const bool kBoolValue = true; |
| 242 | sub_writer.AppendBool(kBoolValue); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 243 | const int32_t kInt32Value = -123; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 244 | sub_writer.AppendInt32(kInt32Value); |
| 245 | const double kDoubleValue = 1.23; |
| 246 | sub_writer.AppendDouble(kDoubleValue); |
| 247 | const std::string kStringValue = "one two three"; |
| 248 | sub_writer.AppendString(kStringValue); |
| 249 | writer.CloseContainer(&sub_writer); |
| 250 | |
| 251 | // Create the expected value. |
thestig@chromium.org | e1acdf8 | 2013-02-13 05:06:15 +0900 | [diff] [blame] | 252 | base::ListValue list_value; |
dcheng | ef1ad82 | 2016-06-07 14:05:14 +0900 | [diff] [blame] | 253 | list_value.AppendBoolean(kBoolValue); |
| 254 | list_value.AppendInteger(kInt32Value); |
| 255 | list_value.AppendDouble(kDoubleValue); |
| 256 | list_value.AppendString(kStringValue); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 257 | |
| 258 | // Pop a struct. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 259 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 260 | std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 261 | ASSERT_NE(nullptr, value); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 262 | EXPECT_TRUE(value->Equals(&list_value)); |
| 263 | } |
| 264 | |
| 265 | TEST(ValuesUtilTest, PopStringToVariantDictionary) { |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 266 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 267 | // Append a dictionary. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 268 | MessageWriter writer(response.get()); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 269 | MessageWriter sub_writer(nullptr); |
| 270 | MessageWriter entry_writer(nullptr); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 271 | writer.OpenArray("{sv}", &sub_writer); |
| 272 | sub_writer.OpenDictEntry(&entry_writer); |
| 273 | const std::string kKey1 = "one"; |
| 274 | entry_writer.AppendString(kKey1); |
| 275 | const bool kBoolValue = true; |
| 276 | entry_writer.AppendVariantOfBool(kBoolValue); |
| 277 | sub_writer.CloseContainer(&entry_writer); |
| 278 | sub_writer.OpenDictEntry(&entry_writer); |
| 279 | const std::string kKey2 = "two"; |
| 280 | entry_writer.AppendString(kKey2); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 281 | const int32_t kInt32Value = -45; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 282 | entry_writer.AppendVariantOfInt32(kInt32Value); |
| 283 | sub_writer.CloseContainer(&entry_writer); |
| 284 | sub_writer.OpenDictEntry(&entry_writer); |
| 285 | const std::string kKey3 = "three"; |
| 286 | entry_writer.AppendString(kKey3); |
| 287 | const double kDoubleValue = 4.9; |
| 288 | entry_writer.AppendVariantOfDouble(kDoubleValue); |
| 289 | sub_writer.CloseContainer(&entry_writer); |
| 290 | sub_writer.OpenDictEntry(&entry_writer); |
| 291 | const std::string kKey4 = "four"; |
| 292 | entry_writer.AppendString(kKey4); |
| 293 | const std::string kStringValue = "fifty"; |
| 294 | entry_writer.AppendVariantOfString(kStringValue); |
| 295 | sub_writer.CloseContainer(&entry_writer); |
| 296 | writer.CloseContainer(&sub_writer); |
| 297 | |
| 298 | // Create the expected value. |
thestig@chromium.org | e1acdf8 | 2013-02-13 05:06:15 +0900 | [diff] [blame] | 299 | base::DictionaryValue dictionary_value; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 300 | dictionary_value.SetBoolean(kKey1, kBoolValue); |
| 301 | dictionary_value.SetInteger(kKey2, kInt32Value); |
| 302 | dictionary_value.SetDouble(kKey3, kDoubleValue); |
| 303 | dictionary_value.SetString(kKey4, kStringValue); |
| 304 | |
| 305 | // Pop a dictinoary. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 306 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 307 | std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 308 | ASSERT_NE(nullptr, value); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 309 | EXPECT_TRUE(value->Equals(&dictionary_value)); |
| 310 | } |
| 311 | |
hashimoto@chromium.org | 9a576b0 | 2012-03-21 03:18:57 +0900 | [diff] [blame] | 312 | TEST(ValuesUtilTest, PopDictionaryWithDottedStringKey) { |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 313 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
hashimoto@chromium.org | 9a576b0 | 2012-03-21 03:18:57 +0900 | [diff] [blame] | 314 | // Append a dictionary. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 315 | MessageWriter writer(response.get()); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 316 | MessageWriter sub_writer(nullptr); |
| 317 | MessageWriter entry_writer(nullptr); |
hashimoto@chromium.org | 9a576b0 | 2012-03-21 03:18:57 +0900 | [diff] [blame] | 318 | writer.OpenArray("{sv}", &sub_writer); |
| 319 | sub_writer.OpenDictEntry(&entry_writer); |
| 320 | const std::string kKey1 = "www.example.com"; // String including dots. |
| 321 | entry_writer.AppendString(kKey1); |
| 322 | const bool kBoolValue = true; |
| 323 | entry_writer.AppendVariantOfBool(kBoolValue); |
| 324 | sub_writer.CloseContainer(&entry_writer); |
| 325 | sub_writer.OpenDictEntry(&entry_writer); |
| 326 | const std::string kKey2 = ".example"; // String starting with a dot. |
| 327 | entry_writer.AppendString(kKey2); |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 328 | const int32_t kInt32Value = -45; |
hashimoto@chromium.org | 9a576b0 | 2012-03-21 03:18:57 +0900 | [diff] [blame] | 329 | entry_writer.AppendVariantOfInt32(kInt32Value); |
| 330 | sub_writer.CloseContainer(&entry_writer); |
| 331 | sub_writer.OpenDictEntry(&entry_writer); |
| 332 | const std::string kKey3 = "example."; // String ending with a dot. |
| 333 | entry_writer.AppendString(kKey3); |
| 334 | const double kDoubleValue = 4.9; |
| 335 | entry_writer.AppendVariantOfDouble(kDoubleValue); |
| 336 | sub_writer.CloseContainer(&entry_writer); |
| 337 | writer.CloseContainer(&sub_writer); |
| 338 | |
| 339 | // Create the expected value. |
thestig@chromium.org | e1acdf8 | 2013-02-13 05:06:15 +0900 | [diff] [blame] | 340 | base::DictionaryValue dictionary_value; |
jdoerrie | 45c13a7 | 2017-08-03 08:25:52 +0900 | [diff] [blame] | 341 | dictionary_value.SetKey(kKey1, base::Value(kBoolValue)); |
jdoerrie | c6b8178 | 2017-08-05 11:21:55 +0900 | [diff] [blame] | 342 | dictionary_value.SetKey(kKey2, base::Value(kInt32Value)); |
jdoerrie | 2c0ad2e | 2017-08-17 03:43:23 +0900 | [diff] [blame] | 343 | dictionary_value.SetKey(kKey3, base::Value(kDoubleValue)); |
hashimoto@chromium.org | 9a576b0 | 2012-03-21 03:18:57 +0900 | [diff] [blame] | 344 | |
| 345 | // Pop a dictinoary. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 346 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 347 | std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 348 | ASSERT_NE(nullptr, value); |
hashimoto@chromium.org | 9a576b0 | 2012-03-21 03:18:57 +0900 | [diff] [blame] | 349 | EXPECT_TRUE(value->Equals(&dictionary_value)); |
| 350 | } |
| 351 | |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 352 | TEST(ValuesUtilTest, PopDoubleToIntDictionary) { |
| 353 | // Create test data. |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 354 | const int32_t kValues[] = {0, 1, 1, 2, 3, 5, 8, 13, 21}; |
| 355 | const std::vector<int32_t> values(kValues, kValues + arraysize(kValues)); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 356 | std::vector<double> keys(values.size()); |
| 357 | for (size_t i = 0; i != values.size(); ++i) |
Hans Wennborg | acb4c7e | 2015-04-25 06:38:04 +0900 | [diff] [blame] | 358 | keys[i] = std::sqrt(values[i]); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 359 | |
| 360 | // Append a dictionary. |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 361 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 362 | MessageWriter writer(response.get()); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 363 | MessageWriter sub_writer(nullptr); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 364 | writer.OpenArray("{di}", &sub_writer); |
| 365 | for (size_t i = 0; i != values.size(); ++i) { |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 366 | MessageWriter entry_writer(nullptr); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 367 | sub_writer.OpenDictEntry(&entry_writer); |
| 368 | entry_writer.AppendDouble(keys[i]); |
| 369 | entry_writer.AppendInt32(values[i]); |
| 370 | sub_writer.CloseContainer(&entry_writer); |
| 371 | } |
| 372 | writer.CloseContainer(&sub_writer); |
| 373 | |
| 374 | // Create the expected value. |
thestig@chromium.org | e1acdf8 | 2013-02-13 05:06:15 +0900 | [diff] [blame] | 375 | base::DictionaryValue dictionary_value; |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 376 | for (size_t i = 0; i != values.size(); ++i) { |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 377 | std::string key_string; |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 378 | base::JSONWriter::Write(base::Value(keys[i]), &key_string); |
jdoerrie | c6b8178 | 2017-08-05 11:21:55 +0900 | [diff] [blame] | 379 | dictionary_value.SetKey(key_string, base::Value(values[i])); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 380 | } |
| 381 | |
| 382 | // Pop a dictionary. |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 383 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 384 | std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 385 | ASSERT_NE(nullptr, value); |
hashimoto@chromium.org | 8fb5a2b | 2012-03-17 08:08:42 +0900 | [diff] [blame] | 386 | EXPECT_TRUE(value->Equals(&dictionary_value)); |
| 387 | } |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 388 | |
| 389 | TEST(ValuesUtilTest, AppendBasicTypes) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 390 | const base::Value kBoolValue(false); |
| 391 | const base::Value kIntegerValue(42); |
| 392 | const base::Value kDoubleValue(4.2); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 393 | const base::Value kStringValue("string"); |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 394 | |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 395 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 396 | MessageWriter writer(response.get()); |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 397 | AppendBasicTypeValueData(&writer, kBoolValue); |
| 398 | AppendBasicTypeValueData(&writer, kIntegerValue); |
| 399 | AppendBasicTypeValueData(&writer, kDoubleValue); |
| 400 | AppendBasicTypeValueData(&writer, kStringValue); |
| 401 | |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 402 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 403 | std::unique_ptr<base::Value> value; |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 404 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 405 | ASSERT_NE(nullptr, value); |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 406 | EXPECT_TRUE(value->Equals(&kBoolValue)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 407 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 408 | ASSERT_NE(nullptr, value); |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 409 | EXPECT_TRUE(value->Equals(&kIntegerValue)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 410 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 411 | ASSERT_NE(nullptr, value); |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 412 | EXPECT_TRUE(value->Equals(&kDoubleValue)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 413 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 414 | ASSERT_NE(nullptr, value); |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 415 | EXPECT_TRUE(value->Equals(&kStringValue)); |
| 416 | } |
| 417 | |
| 418 | TEST(ValuesUtilTest, AppendBasicTypesAsVariant) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 419 | const base::Value kBoolValue(false); |
| 420 | const base::Value kIntegerValue(42); |
| 421 | const base::Value kDoubleValue(4.2); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 422 | const base::Value kStringValue("string"); |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 423 | |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 424 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 425 | MessageWriter writer(response.get()); |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 426 | AppendBasicTypeValueDataAsVariant(&writer, kBoolValue); |
| 427 | AppendBasicTypeValueDataAsVariant(&writer, kIntegerValue); |
| 428 | AppendBasicTypeValueDataAsVariant(&writer, kDoubleValue); |
| 429 | AppendBasicTypeValueDataAsVariant(&writer, kStringValue); |
| 430 | |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 431 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 432 | std::unique_ptr<base::Value> value; |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 433 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 434 | ASSERT_NE(nullptr, value); |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 435 | EXPECT_TRUE(value->Equals(&kBoolValue)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 436 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 437 | ASSERT_NE(nullptr, value); |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 438 | EXPECT_TRUE(value->Equals(&kIntegerValue)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 439 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 440 | ASSERT_NE(nullptr, value); |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 441 | EXPECT_TRUE(value->Equals(&kDoubleValue)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 442 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 443 | ASSERT_NE(nullptr, value); |
hashimoto@chromium.org | ea59982 | 2012-03-25 05:37:18 +0900 | [diff] [blame] | 444 | EXPECT_TRUE(value->Equals(&kStringValue)); |
| 445 | } |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 446 | |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 447 | TEST(ValuesUtilTest, AppendValueDataBasicTypes) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 448 | const base::Value kBoolValue(false); |
| 449 | const base::Value kIntegerValue(42); |
| 450 | const base::Value kDoubleValue(4.2); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 451 | const base::Value kStringValue("string"); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 452 | |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 453 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 454 | MessageWriter writer(response.get()); |
| 455 | AppendValueData(&writer, kBoolValue); |
| 456 | AppendValueData(&writer, kIntegerValue); |
| 457 | AppendValueData(&writer, kDoubleValue); |
| 458 | AppendValueData(&writer, kStringValue); |
| 459 | |
| 460 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 461 | std::unique_ptr<base::Value> value; |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 462 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 463 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 464 | EXPECT_TRUE(value->Equals(&kBoolValue)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 465 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 466 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 467 | EXPECT_TRUE(value->Equals(&kIntegerValue)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 468 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 469 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 470 | EXPECT_TRUE(value->Equals(&kDoubleValue)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 471 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 472 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 473 | EXPECT_TRUE(value->Equals(&kStringValue)); |
| 474 | } |
| 475 | |
| 476 | TEST(ValuesUtilTest, AppendValueDataAsVariantBasicTypes) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 477 | const base::Value kBoolValue(false); |
| 478 | const base::Value kIntegerValue(42); |
| 479 | const base::Value kDoubleValue(4.2); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 480 | const base::Value kStringValue("string"); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 481 | |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 482 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 483 | MessageWriter writer(response.get()); |
| 484 | AppendValueDataAsVariant(&writer, kBoolValue); |
| 485 | AppendValueDataAsVariant(&writer, kIntegerValue); |
| 486 | AppendValueDataAsVariant(&writer, kDoubleValue); |
| 487 | AppendValueDataAsVariant(&writer, kStringValue); |
| 488 | |
| 489 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 490 | std::unique_ptr<base::Value> value; |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 491 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 492 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 493 | EXPECT_TRUE(value->Equals(&kBoolValue)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 494 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 495 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 496 | EXPECT_TRUE(value->Equals(&kIntegerValue)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 497 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 498 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 499 | EXPECT_TRUE(value->Equals(&kDoubleValue)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 500 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 501 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 502 | EXPECT_TRUE(value->Equals(&kStringValue)); |
| 503 | } |
| 504 | |
| 505 | TEST(ValuesUtilTest, AppendDictionary) { |
| 506 | // Set up the input dictionary. |
| 507 | const std::string kKey1 = "one"; |
| 508 | const std::string kKey2 = "two"; |
| 509 | const std::string kKey3 = "three"; |
| 510 | const std::string kKey4 = "four"; |
| 511 | const std::string kKey5 = "five"; |
| 512 | const std::string kKey6 = "six"; |
| 513 | |
| 514 | const bool kBoolValue = true; |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 515 | const int32_t kInt32Value = -45; |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 516 | const double kDoubleValue = 4.9; |
| 517 | const std::string kStringValue = "fifty"; |
| 518 | |
Ben Chan | 2e74917 | 2017-10-13 06:49:57 +0900 | [diff] [blame] | 519 | auto list_value = std::make_unique<base::ListValue>(); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 520 | list_value->AppendBoolean(kBoolValue); |
| 521 | list_value->AppendInteger(kInt32Value); |
| 522 | |
Ben Chan | 2e74917 | 2017-10-13 06:49:57 +0900 | [diff] [blame] | 523 | auto dictionary_value = std::make_unique<base::DictionaryValue>(); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 524 | dictionary_value->SetBoolean(kKey1, kBoolValue); |
| 525 | dictionary_value->SetInteger(kKey2, kDoubleValue); |
| 526 | |
| 527 | base::DictionaryValue test_dictionary; |
| 528 | test_dictionary.SetBoolean(kKey1, kBoolValue); |
| 529 | test_dictionary.SetInteger(kKey2, kInt32Value); |
| 530 | test_dictionary.SetDouble(kKey3, kDoubleValue); |
| 531 | test_dictionary.SetString(kKey4, kStringValue); |
jdoerrie | be3a2ae | 2017-06-09 01:16:44 +0900 | [diff] [blame] | 532 | test_dictionary.Set(kKey5, std::move(list_value)); |
| 533 | test_dictionary.Set(kKey6, std::move(dictionary_value)); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 534 | |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 535 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 536 | MessageWriter writer(response.get()); |
| 537 | AppendValueData(&writer, test_dictionary); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 538 | base::Value int_value(kInt32Value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 539 | AppendValueData(&writer, int_value); |
| 540 | |
| 541 | // Read the data. |
| 542 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 543 | std::unique_ptr<base::Value> value; |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 544 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 545 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 546 | EXPECT_TRUE(value->Equals(&test_dictionary)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 547 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 548 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 549 | EXPECT_TRUE(value->Equals(&int_value)); |
| 550 | } |
| 551 | |
| 552 | TEST(ValuesUtilTest, AppendDictionaryAsVariant) { |
| 553 | // Set up the input dictionary. |
| 554 | const std::string kKey1 = "one"; |
| 555 | const std::string kKey2 = "two"; |
| 556 | const std::string kKey3 = "three"; |
| 557 | const std::string kKey4 = "four"; |
| 558 | const std::string kKey5 = "five"; |
| 559 | const std::string kKey6 = "six"; |
| 560 | |
| 561 | const bool kBoolValue = true; |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 562 | const int32_t kInt32Value = -45; |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 563 | const double kDoubleValue = 4.9; |
| 564 | const std::string kStringValue = "fifty"; |
| 565 | |
Ben Chan | 2e74917 | 2017-10-13 06:49:57 +0900 | [diff] [blame] | 566 | auto list_value = std::make_unique<base::ListValue>(); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 567 | list_value->AppendBoolean(kBoolValue); |
| 568 | list_value->AppendInteger(kInt32Value); |
| 569 | |
Ben Chan | 2e74917 | 2017-10-13 06:49:57 +0900 | [diff] [blame] | 570 | auto dictionary_value = std::make_unique<base::DictionaryValue>(); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 571 | dictionary_value->SetBoolean(kKey1, kBoolValue); |
| 572 | dictionary_value->SetInteger(kKey2, kDoubleValue); |
| 573 | |
| 574 | base::DictionaryValue test_dictionary; |
| 575 | test_dictionary.SetBoolean(kKey1, kBoolValue); |
| 576 | test_dictionary.SetInteger(kKey2, kInt32Value); |
| 577 | test_dictionary.SetDouble(kKey3, kDoubleValue); |
| 578 | test_dictionary.SetString(kKey4, kStringValue); |
jdoerrie | be3a2ae | 2017-06-09 01:16:44 +0900 | [diff] [blame] | 579 | test_dictionary.Set(kKey5, std::move(list_value)); |
| 580 | test_dictionary.Set(kKey6, std::move(dictionary_value)); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 581 | |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 582 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 583 | MessageWriter writer(response.get()); |
| 584 | AppendValueDataAsVariant(&writer, test_dictionary); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 585 | base::Value int_value(kInt32Value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 586 | AppendValueData(&writer, int_value); |
| 587 | |
| 588 | // Read the data. |
| 589 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 590 | std::unique_ptr<base::Value> value; |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 591 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 592 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 593 | EXPECT_TRUE(value->Equals(&test_dictionary)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 594 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 595 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 596 | EXPECT_TRUE(value->Equals(&int_value)); |
| 597 | } |
| 598 | |
| 599 | TEST(ValuesUtilTest, AppendList) { |
| 600 | // Set up the input list. |
| 601 | const std::string kKey1 = "one"; |
| 602 | const std::string kKey2 = "two"; |
| 603 | |
| 604 | const bool kBoolValue = true; |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 605 | const int32_t kInt32Value = -45; |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 606 | const double kDoubleValue = 4.9; |
| 607 | const std::string kStringValue = "fifty"; |
| 608 | |
dcheng | 7219b06 | 2016-06-11 12:41:48 +0900 | [diff] [blame] | 609 | std::unique_ptr<base::ListValue> list_value(new base::ListValue()); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 610 | list_value->AppendBoolean(kBoolValue); |
| 611 | list_value->AppendInteger(kInt32Value); |
| 612 | |
dcheng | 7219b06 | 2016-06-11 12:41:48 +0900 | [diff] [blame] | 613 | std::unique_ptr<base::DictionaryValue> dictionary_value( |
| 614 | new base::DictionaryValue()); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 615 | dictionary_value->SetBoolean(kKey1, kBoolValue); |
| 616 | dictionary_value->SetInteger(kKey2, kDoubleValue); |
| 617 | |
| 618 | base::ListValue test_list; |
| 619 | test_list.AppendBoolean(kBoolValue); |
| 620 | test_list.AppendInteger(kInt32Value); |
| 621 | test_list.AppendDouble(kDoubleValue); |
| 622 | test_list.AppendString(kStringValue); |
dcheng | 7219b06 | 2016-06-11 12:41:48 +0900 | [diff] [blame] | 623 | test_list.Append(std::move(list_value)); |
| 624 | test_list.Append(std::move(dictionary_value)); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 625 | |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 626 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 627 | MessageWriter writer(response.get()); |
| 628 | AppendValueData(&writer, test_list); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 629 | base::Value int_value(kInt32Value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 630 | AppendValueData(&writer, int_value); |
| 631 | |
| 632 | // Read the data. |
| 633 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 634 | std::unique_ptr<base::Value> value; |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 635 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 636 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 637 | EXPECT_TRUE(value->Equals(&test_list)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 638 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 639 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 640 | EXPECT_TRUE(value->Equals(&int_value)); |
| 641 | } |
| 642 | |
| 643 | TEST(ValuesUtilTest, AppendListAsVariant) { |
| 644 | // Set up the input list. |
| 645 | const std::string kKey1 = "one"; |
| 646 | const std::string kKey2 = "two"; |
| 647 | |
| 648 | const bool kBoolValue = true; |
avi | 0ad0ce0 | 2015-12-23 03:12:45 +0900 | [diff] [blame] | 649 | const int32_t kInt32Value = -45; |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 650 | const double kDoubleValue = 4.9; |
| 651 | const std::string kStringValue = "fifty"; |
| 652 | |
dcheng | 7219b06 | 2016-06-11 12:41:48 +0900 | [diff] [blame] | 653 | std::unique_ptr<base::ListValue> list_value(new base::ListValue()); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 654 | list_value->AppendBoolean(kBoolValue); |
| 655 | list_value->AppendInteger(kInt32Value); |
| 656 | |
dcheng | 7219b06 | 2016-06-11 12:41:48 +0900 | [diff] [blame] | 657 | std::unique_ptr<base::DictionaryValue> dictionary_value( |
| 658 | new base::DictionaryValue()); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 659 | dictionary_value->SetBoolean(kKey1, kBoolValue); |
| 660 | dictionary_value->SetInteger(kKey2, kDoubleValue); |
| 661 | |
| 662 | base::ListValue test_list; |
| 663 | test_list.AppendBoolean(kBoolValue); |
| 664 | test_list.AppendInteger(kInt32Value); |
| 665 | test_list.AppendDouble(kDoubleValue); |
| 666 | test_list.AppendString(kStringValue); |
dcheng | 7219b06 | 2016-06-11 12:41:48 +0900 | [diff] [blame] | 667 | test_list.Append(std::move(list_value)); |
| 668 | test_list.Append(std::move(dictionary_value)); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 669 | |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 670 | std::unique_ptr<Response> response(Response::CreateEmpty()); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 671 | MessageWriter writer(response.get()); |
| 672 | AppendValueDataAsVariant(&writer, test_list); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 673 | base::Value int_value(kInt32Value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 674 | AppendValueData(&writer, int_value); |
| 675 | |
| 676 | // Read the data. |
| 677 | MessageReader reader(response.get()); |
dcheng | 30c5a17 | 2016-04-09 07:55:04 +0900 | [diff] [blame] | 678 | std::unique_ptr<base::Value> value; |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 679 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 680 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 681 | EXPECT_TRUE(value->Equals(&test_list)); |
dcheng | 6ad83f3 | 2016-05-30 15:33:58 +0900 | [diff] [blame] | 682 | value = PopDataAsValue(&reader); |
Ben Chan | 333256c | 2017-11-10 05:20:16 +0900 | [diff] [blame] | 683 | ASSERT_NE(nullptr, value); |
armansito@chromium.org | 39d51b9 | 2014-05-22 20:52:55 +0900 | [diff] [blame] | 684 | EXPECT_TRUE(value->Equals(&int_value)); |
| 685 | } |
| 686 | |
thestig@chromium.org | f0b7eac | 2013-06-13 15:37:19 +0900 | [diff] [blame] | 687 | } // namespace dbus |