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> |
| 11 #include <memory> |
11 #include <vector> | 12 #include <vector> |
12 | 13 |
13 #include "base/json/json_writer.h" | 14 #include "base/json/json_writer.h" |
14 #include "base/macros.h" | 15 #include "base/macros.h" |
15 #include "base/memory/scoped_ptr.h" | |
16 #include "base/values.h" | 16 #include "base/values.h" |
17 #include "dbus/message.h" | 17 #include "dbus/message.h" |
18 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
19 | 19 |
20 namespace dbus { | 20 namespace dbus { |
21 | 21 |
22 TEST(ValuesUtilTest, PopBasicTypes) { | 22 TEST(ValuesUtilTest, PopBasicTypes) { |
23 scoped_ptr<Response> response(Response::CreateEmpty()); | 23 std::unique_ptr<Response> response(Response::CreateEmpty()); |
24 // Append basic type values. | 24 // Append basic type values. |
25 MessageWriter writer(response.get()); | 25 MessageWriter writer(response.get()); |
26 const uint8_t kByteValue = 42; | 26 const uint8_t kByteValue = 42; |
27 writer.AppendByte(kByteValue); | 27 writer.AppendByte(kByteValue); |
28 const bool kBoolValue = true; | 28 const bool kBoolValue = true; |
29 writer.AppendBool(kBoolValue); | 29 writer.AppendBool(kBoolValue); |
30 const int16_t kInt16Value = -43; | 30 const int16_t kInt16Value = -43; |
31 writer.AppendInt16(kInt16Value); | 31 writer.AppendInt16(kInt16Value); |
32 const uint16_t kUint16Value = 44; | 32 const uint16_t kUint16Value = 44; |
33 writer.AppendUint16(kUint16Value); | 33 writer.AppendUint16(kUint16Value); |
34 const int32_t kInt32Value = -45; | 34 const int32_t kInt32Value = -45; |
35 writer.AppendInt32(kInt32Value); | 35 writer.AppendInt32(kInt32Value); |
36 const uint32_t kUint32Value = 46; | 36 const uint32_t kUint32Value = 46; |
37 writer.AppendUint32(kUint32Value); | 37 writer.AppendUint32(kUint32Value); |
38 const int64_t kInt64Value = -47; | 38 const int64_t kInt64Value = -47; |
39 writer.AppendInt64(kInt64Value); | 39 writer.AppendInt64(kInt64Value); |
40 const uint64_t kUint64Value = 48; | 40 const uint64_t kUint64Value = 48; |
41 writer.AppendUint64(kUint64Value); | 41 writer.AppendUint64(kUint64Value); |
42 const double kDoubleValue = 4.9; | 42 const double kDoubleValue = 4.9; |
43 writer.AppendDouble(kDoubleValue); | 43 writer.AppendDouble(kDoubleValue); |
44 const std::string kStringValue = "fifty"; | 44 const std::string kStringValue = "fifty"; |
45 writer.AppendString(kStringValue); | 45 writer.AppendString(kStringValue); |
46 const std::string kEmptyStringValue; | 46 const std::string kEmptyStringValue; |
47 writer.AppendString(kEmptyStringValue); | 47 writer.AppendString(kEmptyStringValue); |
48 const ObjectPath kObjectPathValue("/ObjectPath"); | 48 const ObjectPath kObjectPathValue("/ObjectPath"); |
49 writer.AppendObjectPath(kObjectPathValue); | 49 writer.AppendObjectPath(kObjectPathValue); |
50 | 50 |
51 MessageReader reader(response.get()); | 51 MessageReader reader(response.get()); |
52 scoped_ptr<base::Value> value; | 52 std::unique_ptr<base::Value> value; |
53 scoped_ptr<base::Value> expected_value; | 53 std::unique_ptr<base::Value> expected_value; |
54 // Pop a byte. | 54 // Pop a byte. |
55 value.reset(PopDataAsValue(&reader)); | 55 value.reset(PopDataAsValue(&reader)); |
56 ASSERT_TRUE(value.get() != NULL); | 56 ASSERT_TRUE(value.get() != NULL); |
57 expected_value.reset(new base::FundamentalValue(kByteValue)); | 57 expected_value.reset(new base::FundamentalValue(kByteValue)); |
58 EXPECT_TRUE(value->Equals(expected_value.get())); | 58 EXPECT_TRUE(value->Equals(expected_value.get())); |
59 // Pop a bool. | 59 // Pop a bool. |
60 value.reset(PopDataAsValue(&reader)); | 60 value.reset(PopDataAsValue(&reader)); |
61 ASSERT_TRUE(value.get() != NULL); | 61 ASSERT_TRUE(value.get() != NULL); |
62 expected_value.reset(new base::FundamentalValue(kBoolValue)); | 62 expected_value.reset(new base::FundamentalValue(kBoolValue)); |
63 EXPECT_TRUE(value->Equals(expected_value.get())); | 63 EXPECT_TRUE(value->Equals(expected_value.get())); |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
110 expected_value.reset(new base::StringValue(kEmptyStringValue)); | 110 expected_value.reset(new base::StringValue(kEmptyStringValue)); |
111 EXPECT_TRUE(value->Equals(expected_value.get())); | 111 EXPECT_TRUE(value->Equals(expected_value.get())); |
112 // Pop an object path. | 112 // Pop an object path. |
113 value.reset(PopDataAsValue(&reader)); | 113 value.reset(PopDataAsValue(&reader)); |
114 ASSERT_TRUE(value.get() != NULL); | 114 ASSERT_TRUE(value.get() != NULL); |
115 expected_value.reset(new base::StringValue(kObjectPathValue.value())); | 115 expected_value.reset(new base::StringValue(kObjectPathValue.value())); |
116 EXPECT_TRUE(value->Equals(expected_value.get())); | 116 EXPECT_TRUE(value->Equals(expected_value.get())); |
117 } | 117 } |
118 | 118 |
119 TEST(ValuesUtilTest, PopVariant) { | 119 TEST(ValuesUtilTest, PopVariant) { |
120 scoped_ptr<Response> response(Response::CreateEmpty()); | 120 std::unique_ptr<Response> response(Response::CreateEmpty()); |
121 // Append variant values. | 121 // Append variant values. |
122 MessageWriter writer(response.get()); | 122 MessageWriter writer(response.get()); |
123 const bool kBoolValue = true; | 123 const bool kBoolValue = true; |
124 writer.AppendVariantOfBool(kBoolValue); | 124 writer.AppendVariantOfBool(kBoolValue); |
125 const int32_t kInt32Value = -45; | 125 const int32_t kInt32Value = -45; |
126 writer.AppendVariantOfInt32(kInt32Value); | 126 writer.AppendVariantOfInt32(kInt32Value); |
127 const double kDoubleValue = 4.9; | 127 const double kDoubleValue = 4.9; |
128 writer.AppendVariantOfDouble(kDoubleValue); | 128 writer.AppendVariantOfDouble(kDoubleValue); |
129 const std::string kStringValue = "fifty"; | 129 const std::string kStringValue = "fifty"; |
130 writer.AppendVariantOfString(kStringValue); | 130 writer.AppendVariantOfString(kStringValue); |
131 | 131 |
132 MessageReader reader(response.get()); | 132 MessageReader reader(response.get()); |
133 scoped_ptr<base::Value> value; | 133 std::unique_ptr<base::Value> value; |
134 scoped_ptr<base::Value> expected_value; | 134 std::unique_ptr<base::Value> expected_value; |
135 // Pop a bool. | 135 // Pop a bool. |
136 value.reset(PopDataAsValue(&reader)); | 136 value.reset(PopDataAsValue(&reader)); |
137 ASSERT_TRUE(value.get() != NULL); | 137 ASSERT_TRUE(value.get() != NULL); |
138 expected_value.reset(new base::FundamentalValue(kBoolValue)); | 138 expected_value.reset(new base::FundamentalValue(kBoolValue)); |
139 EXPECT_TRUE(value->Equals(expected_value.get())); | 139 EXPECT_TRUE(value->Equals(expected_value.get())); |
140 // Pop an int32_t. | 140 // Pop an int32_t. |
141 value.reset(PopDataAsValue(&reader)); | 141 value.reset(PopDataAsValue(&reader)); |
142 ASSERT_TRUE(value.get() != NULL); | 142 ASSERT_TRUE(value.get() != NULL); |
143 expected_value.reset(new base::FundamentalValue(kInt32Value)); | 143 expected_value.reset(new base::FundamentalValue(kInt32Value)); |
144 EXPECT_TRUE(value->Equals(expected_value.get())); | 144 EXPECT_TRUE(value->Equals(expected_value.get())); |
145 // Pop a double. | 145 // Pop a double. |
146 value.reset(PopDataAsValue(&reader)); | 146 value.reset(PopDataAsValue(&reader)); |
147 ASSERT_TRUE(value.get() != NULL); | 147 ASSERT_TRUE(value.get() != NULL); |
148 expected_value.reset(new base::FundamentalValue(kDoubleValue)); | 148 expected_value.reset(new base::FundamentalValue(kDoubleValue)); |
149 EXPECT_TRUE(value->Equals(expected_value.get())); | 149 EXPECT_TRUE(value->Equals(expected_value.get())); |
150 // Pop a string. | 150 // Pop a string. |
151 value.reset(PopDataAsValue(&reader)); | 151 value.reset(PopDataAsValue(&reader)); |
152 ASSERT_TRUE(value.get() != NULL); | 152 ASSERT_TRUE(value.get() != NULL); |
153 expected_value.reset(new base::StringValue(kStringValue)); | 153 expected_value.reset(new base::StringValue(kStringValue)); |
154 EXPECT_TRUE(value->Equals(expected_value.get())); | 154 EXPECT_TRUE(value->Equals(expected_value.get())); |
155 } | 155 } |
156 | 156 |
157 // Pop extremely large integers which cannot be precisely represented in | 157 // Pop extremely large integers which cannot be precisely represented in |
158 // double. | 158 // double. |
159 TEST(ValuesUtilTest, PopExtremelyLargeIntegers) { | 159 TEST(ValuesUtilTest, PopExtremelyLargeIntegers) { |
160 scoped_ptr<Response> response(Response::CreateEmpty()); | 160 std::unique_ptr<Response> response(Response::CreateEmpty()); |
161 // Append large integers. | 161 // Append large integers. |
162 MessageWriter writer(response.get()); | 162 MessageWriter writer(response.get()); |
163 const int64_t kInt64Value = -123456789012345689LL; | 163 const int64_t kInt64Value = -123456789012345689LL; |
164 writer.AppendInt64(kInt64Value); | 164 writer.AppendInt64(kInt64Value); |
165 const uint64_t kUint64Value = 9876543210987654321ULL; | 165 const uint64_t kUint64Value = 9876543210987654321ULL; |
166 writer.AppendUint64(kUint64Value); | 166 writer.AppendUint64(kUint64Value); |
167 | 167 |
168 MessageReader reader(response.get()); | 168 MessageReader reader(response.get()); |
169 scoped_ptr<base::Value> value; | 169 std::unique_ptr<base::Value> value; |
170 scoped_ptr<base::Value> expected_value; | 170 std::unique_ptr<base::Value> expected_value; |
171 double double_value = 0; | 171 double double_value = 0; |
172 // Pop an int64_t. | 172 // Pop an int64_t. |
173 value.reset(PopDataAsValue(&reader)); | 173 value.reset(PopDataAsValue(&reader)); |
174 ASSERT_TRUE(value.get() != NULL); | 174 ASSERT_TRUE(value.get() != NULL); |
175 expected_value.reset( | 175 expected_value.reset( |
176 new base::FundamentalValue(static_cast<double>(kInt64Value))); | 176 new base::FundamentalValue(static_cast<double>(kInt64Value))); |
177 EXPECT_TRUE(value->Equals(expected_value.get())); | 177 EXPECT_TRUE(value->Equals(expected_value.get())); |
178 ASSERT_TRUE(value->GetAsDouble(&double_value)); | 178 ASSERT_TRUE(value->GetAsDouble(&double_value)); |
179 EXPECT_NE(kInt64Value, static_cast<int64_t>(double_value)); | 179 EXPECT_NE(kInt64Value, static_cast<int64_t>(double_value)); |
180 // Pop a uint64_t. | 180 // Pop a uint64_t. |
181 value.reset(PopDataAsValue(&reader)); | 181 value.reset(PopDataAsValue(&reader)); |
182 ASSERT_TRUE(value.get() != NULL); | 182 ASSERT_TRUE(value.get() != NULL); |
183 expected_value.reset( | 183 expected_value.reset( |
184 new base::FundamentalValue(static_cast<double>(kUint64Value))); | 184 new base::FundamentalValue(static_cast<double>(kUint64Value))); |
185 EXPECT_TRUE(value->Equals(expected_value.get())); | 185 EXPECT_TRUE(value->Equals(expected_value.get())); |
186 ASSERT_TRUE(value->GetAsDouble(&double_value)); | 186 ASSERT_TRUE(value->GetAsDouble(&double_value)); |
187 EXPECT_NE(kUint64Value, static_cast<uint64_t>(double_value)); | 187 EXPECT_NE(kUint64Value, static_cast<uint64_t>(double_value)); |
188 } | 188 } |
189 | 189 |
190 TEST(ValuesUtilTest, PopIntArray) { | 190 TEST(ValuesUtilTest, PopIntArray) { |
191 scoped_ptr<Response> response(Response::CreateEmpty()); | 191 std::unique_ptr<Response> response(Response::CreateEmpty()); |
192 // Append an int32_t array. | 192 // Append an int32_t array. |
193 MessageWriter writer(response.get()); | 193 MessageWriter writer(response.get()); |
194 MessageWriter sub_writer(NULL); | 194 MessageWriter sub_writer(NULL); |
195 std::vector<int32_t> data; | 195 std::vector<int32_t> data; |
196 data.push_back(0); | 196 data.push_back(0); |
197 data.push_back(1); | 197 data.push_back(1); |
198 data.push_back(2); | 198 data.push_back(2); |
199 writer.OpenArray("i", &sub_writer); | 199 writer.OpenArray("i", &sub_writer); |
200 for (size_t i = 0; i != data.size(); ++i) | 200 for (size_t i = 0; i != data.size(); ++i) |
201 sub_writer.AppendInt32(data[i]); | 201 sub_writer.AppendInt32(data[i]); |
202 writer.CloseContainer(&sub_writer); | 202 writer.CloseContainer(&sub_writer); |
203 | 203 |
204 // Create the expected value. | 204 // Create the expected value. |
205 scoped_ptr<base::ListValue> list_value(new base::ListValue); | 205 std::unique_ptr<base::ListValue> list_value(new base::ListValue); |
206 for (size_t i = 0; i != data.size(); ++i) | 206 for (size_t i = 0; i != data.size(); ++i) |
207 list_value->Append(new base::FundamentalValue(data[i])); | 207 list_value->Append(new base::FundamentalValue(data[i])); |
208 | 208 |
209 // Pop an int32_t array. | 209 // Pop an int32_t array. |
210 MessageReader reader(response.get()); | 210 MessageReader reader(response.get()); |
211 scoped_ptr<base::Value> value(PopDataAsValue(&reader)); | 211 std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
212 ASSERT_TRUE(value.get() != NULL); | 212 ASSERT_TRUE(value.get() != NULL); |
213 EXPECT_TRUE(value->Equals(list_value.get())); | 213 EXPECT_TRUE(value->Equals(list_value.get())); |
214 } | 214 } |
215 | 215 |
216 TEST(ValuesUtilTest, PopStringArray) { | 216 TEST(ValuesUtilTest, PopStringArray) { |
217 scoped_ptr<Response> response(Response::CreateEmpty()); | 217 std::unique_ptr<Response> response(Response::CreateEmpty()); |
218 // Append a string array. | 218 // Append a string array. |
219 MessageWriter writer(response.get()); | 219 MessageWriter writer(response.get()); |
220 MessageWriter sub_writer(NULL); | 220 MessageWriter sub_writer(NULL); |
221 std::vector<std::string> data; | 221 std::vector<std::string> data; |
222 data.push_back("Dreamlifter"); | 222 data.push_back("Dreamlifter"); |
223 data.push_back("Beluga"); | 223 data.push_back("Beluga"); |
224 data.push_back("Mriya"); | 224 data.push_back("Mriya"); |
225 writer.AppendArrayOfStrings(data); | 225 writer.AppendArrayOfStrings(data); |
226 | 226 |
227 // Create the expected value. | 227 // Create the expected value. |
228 scoped_ptr<base::ListValue> list_value(new base::ListValue); | 228 std::unique_ptr<base::ListValue> list_value(new base::ListValue); |
229 for (size_t i = 0; i != data.size(); ++i) | 229 for (size_t i = 0; i != data.size(); ++i) |
230 list_value->Append(new base::StringValue(data[i])); | 230 list_value->Append(new base::StringValue(data[i])); |
231 | 231 |
232 // Pop a string array. | 232 // Pop a string array. |
233 MessageReader reader(response.get()); | 233 MessageReader reader(response.get()); |
234 scoped_ptr<base::Value> value(PopDataAsValue(&reader)); | 234 std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
235 ASSERT_TRUE(value.get() != NULL); | 235 ASSERT_TRUE(value.get() != NULL); |
236 EXPECT_TRUE(value->Equals(list_value.get())); | 236 EXPECT_TRUE(value->Equals(list_value.get())); |
237 } | 237 } |
238 | 238 |
239 TEST(ValuesUtilTest, PopStruct) { | 239 TEST(ValuesUtilTest, PopStruct) { |
240 scoped_ptr<Response> response(Response::CreateEmpty()); | 240 std::unique_ptr<Response> response(Response::CreateEmpty()); |
241 // Append a struct. | 241 // Append a struct. |
242 MessageWriter writer(response.get()); | 242 MessageWriter writer(response.get()); |
243 MessageWriter sub_writer(NULL); | 243 MessageWriter sub_writer(NULL); |
244 writer.OpenStruct(&sub_writer); | 244 writer.OpenStruct(&sub_writer); |
245 const bool kBoolValue = true; | 245 const bool kBoolValue = true; |
246 sub_writer.AppendBool(kBoolValue); | 246 sub_writer.AppendBool(kBoolValue); |
247 const int32_t kInt32Value = -123; | 247 const int32_t kInt32Value = -123; |
248 sub_writer.AppendInt32(kInt32Value); | 248 sub_writer.AppendInt32(kInt32Value); |
249 const double kDoubleValue = 1.23; | 249 const double kDoubleValue = 1.23; |
250 sub_writer.AppendDouble(kDoubleValue); | 250 sub_writer.AppendDouble(kDoubleValue); |
251 const std::string kStringValue = "one two three"; | 251 const std::string kStringValue = "one two three"; |
252 sub_writer.AppendString(kStringValue); | 252 sub_writer.AppendString(kStringValue); |
253 writer.CloseContainer(&sub_writer); | 253 writer.CloseContainer(&sub_writer); |
254 | 254 |
255 // Create the expected value. | 255 // Create the expected value. |
256 base::ListValue list_value; | 256 base::ListValue list_value; |
257 list_value.Append(new base::FundamentalValue(kBoolValue)); | 257 list_value.Append(new base::FundamentalValue(kBoolValue)); |
258 list_value.Append(new base::FundamentalValue(kInt32Value)); | 258 list_value.Append(new base::FundamentalValue(kInt32Value)); |
259 list_value.Append(new base::FundamentalValue(kDoubleValue)); | 259 list_value.Append(new base::FundamentalValue(kDoubleValue)); |
260 list_value.Append(new base::StringValue(kStringValue)); | 260 list_value.Append(new base::StringValue(kStringValue)); |
261 | 261 |
262 // Pop a struct. | 262 // Pop a struct. |
263 MessageReader reader(response.get()); | 263 MessageReader reader(response.get()); |
264 scoped_ptr<base::Value> value(PopDataAsValue(&reader)); | 264 std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
265 ASSERT_TRUE(value.get() != NULL); | 265 ASSERT_TRUE(value.get() != NULL); |
266 EXPECT_TRUE(value->Equals(&list_value)); | 266 EXPECT_TRUE(value->Equals(&list_value)); |
267 } | 267 } |
268 | 268 |
269 TEST(ValuesUtilTest, PopStringToVariantDictionary) { | 269 TEST(ValuesUtilTest, PopStringToVariantDictionary) { |
270 scoped_ptr<Response> response(Response::CreateEmpty()); | 270 std::unique_ptr<Response> response(Response::CreateEmpty()); |
271 // Append a dictionary. | 271 // Append a dictionary. |
272 MessageWriter writer(response.get()); | 272 MessageWriter writer(response.get()); |
273 MessageWriter sub_writer(NULL); | 273 MessageWriter sub_writer(NULL); |
274 MessageWriter entry_writer(NULL); | 274 MessageWriter entry_writer(NULL); |
275 writer.OpenArray("{sv}", &sub_writer); | 275 writer.OpenArray("{sv}", &sub_writer); |
276 sub_writer.OpenDictEntry(&entry_writer); | 276 sub_writer.OpenDictEntry(&entry_writer); |
277 const std::string kKey1 = "one"; | 277 const std::string kKey1 = "one"; |
278 entry_writer.AppendString(kKey1); | 278 entry_writer.AppendString(kKey1); |
279 const bool kBoolValue = true; | 279 const bool kBoolValue = true; |
280 entry_writer.AppendVariantOfBool(kBoolValue); | 280 entry_writer.AppendVariantOfBool(kBoolValue); |
(...skipping 20 matching lines...) Expand all Loading... |
301 | 301 |
302 // Create the expected value. | 302 // Create the expected value. |
303 base::DictionaryValue dictionary_value; | 303 base::DictionaryValue dictionary_value; |
304 dictionary_value.SetBoolean(kKey1, kBoolValue); | 304 dictionary_value.SetBoolean(kKey1, kBoolValue); |
305 dictionary_value.SetInteger(kKey2, kInt32Value); | 305 dictionary_value.SetInteger(kKey2, kInt32Value); |
306 dictionary_value.SetDouble(kKey3, kDoubleValue); | 306 dictionary_value.SetDouble(kKey3, kDoubleValue); |
307 dictionary_value.SetString(kKey4, kStringValue); | 307 dictionary_value.SetString(kKey4, kStringValue); |
308 | 308 |
309 // Pop a dictinoary. | 309 // Pop a dictinoary. |
310 MessageReader reader(response.get()); | 310 MessageReader reader(response.get()); |
311 scoped_ptr<base::Value> value(PopDataAsValue(&reader)); | 311 std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
312 ASSERT_TRUE(value.get() != NULL); | 312 ASSERT_TRUE(value.get() != NULL); |
313 EXPECT_TRUE(value->Equals(&dictionary_value)); | 313 EXPECT_TRUE(value->Equals(&dictionary_value)); |
314 } | 314 } |
315 | 315 |
316 TEST(ValuesUtilTest, PopDictionaryWithDottedStringKey) { | 316 TEST(ValuesUtilTest, PopDictionaryWithDottedStringKey) { |
317 scoped_ptr<Response> response(Response::CreateEmpty()); | 317 std::unique_ptr<Response> response(Response::CreateEmpty()); |
318 // Append a dictionary. | 318 // Append a dictionary. |
319 MessageWriter writer(response.get()); | 319 MessageWriter writer(response.get()); |
320 MessageWriter sub_writer(NULL); | 320 MessageWriter sub_writer(NULL); |
321 MessageWriter entry_writer(NULL); | 321 MessageWriter entry_writer(NULL); |
322 writer.OpenArray("{sv}", &sub_writer); | 322 writer.OpenArray("{sv}", &sub_writer); |
323 sub_writer.OpenDictEntry(&entry_writer); | 323 sub_writer.OpenDictEntry(&entry_writer); |
324 const std::string kKey1 = "www.example.com"; // String including dots. | 324 const std::string kKey1 = "www.example.com"; // String including dots. |
325 entry_writer.AppendString(kKey1); | 325 entry_writer.AppendString(kKey1); |
326 const bool kBoolValue = true; | 326 const bool kBoolValue = true; |
327 entry_writer.AppendVariantOfBool(kBoolValue); | 327 entry_writer.AppendVariantOfBool(kBoolValue); |
(...skipping 16 matching lines...) Expand all Loading... |
344 base::DictionaryValue dictionary_value; | 344 base::DictionaryValue dictionary_value; |
345 dictionary_value.SetWithoutPathExpansion( | 345 dictionary_value.SetWithoutPathExpansion( |
346 kKey1, new base::FundamentalValue(kBoolValue)); | 346 kKey1, new base::FundamentalValue(kBoolValue)); |
347 dictionary_value.SetWithoutPathExpansion( | 347 dictionary_value.SetWithoutPathExpansion( |
348 kKey2, new base::FundamentalValue(kInt32Value)); | 348 kKey2, new base::FundamentalValue(kInt32Value)); |
349 dictionary_value.SetWithoutPathExpansion( | 349 dictionary_value.SetWithoutPathExpansion( |
350 kKey3, new base::FundamentalValue(kDoubleValue)); | 350 kKey3, new base::FundamentalValue(kDoubleValue)); |
351 | 351 |
352 // Pop a dictinoary. | 352 // Pop a dictinoary. |
353 MessageReader reader(response.get()); | 353 MessageReader reader(response.get()); |
354 scoped_ptr<base::Value> value(PopDataAsValue(&reader)); | 354 std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
355 ASSERT_TRUE(value.get() != NULL); | 355 ASSERT_TRUE(value.get() != NULL); |
356 EXPECT_TRUE(value->Equals(&dictionary_value)); | 356 EXPECT_TRUE(value->Equals(&dictionary_value)); |
357 } | 357 } |
358 | 358 |
359 TEST(ValuesUtilTest, PopDoubleToIntDictionary) { | 359 TEST(ValuesUtilTest, PopDoubleToIntDictionary) { |
360 // Create test data. | 360 // Create test data. |
361 const int32_t kValues[] = {0, 1, 1, 2, 3, 5, 8, 13, 21}; | 361 const int32_t kValues[] = {0, 1, 1, 2, 3, 5, 8, 13, 21}; |
362 const std::vector<int32_t> values(kValues, kValues + arraysize(kValues)); | 362 const std::vector<int32_t> values(kValues, kValues + arraysize(kValues)); |
363 std::vector<double> keys(values.size()); | 363 std::vector<double> keys(values.size()); |
364 for (size_t i = 0; i != values.size(); ++i) | 364 for (size_t i = 0; i != values.size(); ++i) |
365 keys[i] = std::sqrt(values[i]); | 365 keys[i] = std::sqrt(values[i]); |
366 | 366 |
367 // Append a dictionary. | 367 // Append a dictionary. |
368 scoped_ptr<Response> response(Response::CreateEmpty()); | 368 std::unique_ptr<Response> response(Response::CreateEmpty()); |
369 MessageWriter writer(response.get()); | 369 MessageWriter writer(response.get()); |
370 MessageWriter sub_writer(NULL); | 370 MessageWriter sub_writer(NULL); |
371 writer.OpenArray("{di}", &sub_writer); | 371 writer.OpenArray("{di}", &sub_writer); |
372 for (size_t i = 0; i != values.size(); ++i) { | 372 for (size_t i = 0; i != values.size(); ++i) { |
373 MessageWriter entry_writer(NULL); | 373 MessageWriter entry_writer(NULL); |
374 sub_writer.OpenDictEntry(&entry_writer); | 374 sub_writer.OpenDictEntry(&entry_writer); |
375 entry_writer.AppendDouble(keys[i]); | 375 entry_writer.AppendDouble(keys[i]); |
376 entry_writer.AppendInt32(values[i]); | 376 entry_writer.AppendInt32(values[i]); |
377 sub_writer.CloseContainer(&entry_writer); | 377 sub_writer.CloseContainer(&entry_writer); |
378 } | 378 } |
379 writer.CloseContainer(&sub_writer); | 379 writer.CloseContainer(&sub_writer); |
380 | 380 |
381 // Create the expected value. | 381 // Create the expected value. |
382 base::DictionaryValue dictionary_value; | 382 base::DictionaryValue dictionary_value; |
383 for (size_t i = 0; i != values.size(); ++i) { | 383 for (size_t i = 0; i != values.size(); ++i) { |
384 std::string key_string; | 384 std::string key_string; |
385 base::JSONWriter::Write(base::FundamentalValue(keys[i]), &key_string); | 385 base::JSONWriter::Write(base::FundamentalValue(keys[i]), &key_string); |
386 dictionary_value.SetIntegerWithoutPathExpansion(key_string, values[i]); | 386 dictionary_value.SetIntegerWithoutPathExpansion(key_string, values[i]); |
387 } | 387 } |
388 | 388 |
389 // Pop a dictionary. | 389 // Pop a dictionary. |
390 MessageReader reader(response.get()); | 390 MessageReader reader(response.get()); |
391 scoped_ptr<base::Value> value(PopDataAsValue(&reader)); | 391 std::unique_ptr<base::Value> value(PopDataAsValue(&reader)); |
392 ASSERT_TRUE(value.get() != NULL); | 392 ASSERT_TRUE(value.get() != NULL); |
393 EXPECT_TRUE(value->Equals(&dictionary_value)); | 393 EXPECT_TRUE(value->Equals(&dictionary_value)); |
394 } | 394 } |
395 | 395 |
396 TEST(ValuesUtilTest, AppendBasicTypes) { | 396 TEST(ValuesUtilTest, AppendBasicTypes) { |
397 const base::FundamentalValue kBoolValue(false); | 397 const base::FundamentalValue kBoolValue(false); |
398 const base::FundamentalValue kIntegerValue(42); | 398 const base::FundamentalValue kIntegerValue(42); |
399 const base::FundamentalValue kDoubleValue(4.2); | 399 const base::FundamentalValue kDoubleValue(4.2); |
400 const base::StringValue kStringValue("string"); | 400 const base::StringValue kStringValue("string"); |
401 | 401 |
402 scoped_ptr<Response> response(Response::CreateEmpty()); | 402 std::unique_ptr<Response> response(Response::CreateEmpty()); |
403 MessageWriter writer(response.get()); | 403 MessageWriter writer(response.get()); |
404 AppendBasicTypeValueData(&writer, kBoolValue); | 404 AppendBasicTypeValueData(&writer, kBoolValue); |
405 AppendBasicTypeValueData(&writer, kIntegerValue); | 405 AppendBasicTypeValueData(&writer, kIntegerValue); |
406 AppendBasicTypeValueData(&writer, kDoubleValue); | 406 AppendBasicTypeValueData(&writer, kDoubleValue); |
407 AppendBasicTypeValueData(&writer, kStringValue); | 407 AppendBasicTypeValueData(&writer, kStringValue); |
408 | 408 |
409 MessageReader reader(response.get()); | 409 MessageReader reader(response.get()); |
410 scoped_ptr<base::Value> value; | 410 std::unique_ptr<base::Value> value; |
411 value.reset(PopDataAsValue(&reader)); | 411 value.reset(PopDataAsValue(&reader)); |
412 ASSERT_TRUE(value.get() != NULL); | 412 ASSERT_TRUE(value.get() != NULL); |
413 EXPECT_TRUE(value->Equals(&kBoolValue)); | 413 EXPECT_TRUE(value->Equals(&kBoolValue)); |
414 value.reset(PopDataAsValue(&reader)); | 414 value.reset(PopDataAsValue(&reader)); |
415 ASSERT_TRUE(value.get() != NULL); | 415 ASSERT_TRUE(value.get() != NULL); |
416 EXPECT_TRUE(value->Equals(&kIntegerValue)); | 416 EXPECT_TRUE(value->Equals(&kIntegerValue)); |
417 value.reset(PopDataAsValue(&reader)); | 417 value.reset(PopDataAsValue(&reader)); |
418 ASSERT_TRUE(value.get() != NULL); | 418 ASSERT_TRUE(value.get() != NULL); |
419 EXPECT_TRUE(value->Equals(&kDoubleValue)); | 419 EXPECT_TRUE(value->Equals(&kDoubleValue)); |
420 value.reset(PopDataAsValue(&reader)); | 420 value.reset(PopDataAsValue(&reader)); |
421 ASSERT_TRUE(value.get() != NULL); | 421 ASSERT_TRUE(value.get() != NULL); |
422 EXPECT_TRUE(value->Equals(&kStringValue)); | 422 EXPECT_TRUE(value->Equals(&kStringValue)); |
423 } | 423 } |
424 | 424 |
425 TEST(ValuesUtilTest, AppendBasicTypesAsVariant) { | 425 TEST(ValuesUtilTest, AppendBasicTypesAsVariant) { |
426 const base::FundamentalValue kBoolValue(false); | 426 const base::FundamentalValue kBoolValue(false); |
427 const base::FundamentalValue kIntegerValue(42); | 427 const base::FundamentalValue kIntegerValue(42); |
428 const base::FundamentalValue kDoubleValue(4.2); | 428 const base::FundamentalValue kDoubleValue(4.2); |
429 const base::StringValue kStringValue("string"); | 429 const base::StringValue kStringValue("string"); |
430 | 430 |
431 scoped_ptr<Response> response(Response::CreateEmpty()); | 431 std::unique_ptr<Response> response(Response::CreateEmpty()); |
432 MessageWriter writer(response.get()); | 432 MessageWriter writer(response.get()); |
433 AppendBasicTypeValueDataAsVariant(&writer, kBoolValue); | 433 AppendBasicTypeValueDataAsVariant(&writer, kBoolValue); |
434 AppendBasicTypeValueDataAsVariant(&writer, kIntegerValue); | 434 AppendBasicTypeValueDataAsVariant(&writer, kIntegerValue); |
435 AppendBasicTypeValueDataAsVariant(&writer, kDoubleValue); | 435 AppendBasicTypeValueDataAsVariant(&writer, kDoubleValue); |
436 AppendBasicTypeValueDataAsVariant(&writer, kStringValue); | 436 AppendBasicTypeValueDataAsVariant(&writer, kStringValue); |
437 | 437 |
438 MessageReader reader(response.get()); | 438 MessageReader reader(response.get()); |
439 scoped_ptr<base::Value> value; | 439 std::unique_ptr<base::Value> value; |
440 value.reset(PopDataAsValue(&reader)); | 440 value.reset(PopDataAsValue(&reader)); |
441 ASSERT_TRUE(value.get() != NULL); | 441 ASSERT_TRUE(value.get() != NULL); |
442 EXPECT_TRUE(value->Equals(&kBoolValue)); | 442 EXPECT_TRUE(value->Equals(&kBoolValue)); |
443 value.reset(PopDataAsValue(&reader)); | 443 value.reset(PopDataAsValue(&reader)); |
444 ASSERT_TRUE(value.get() != NULL); | 444 ASSERT_TRUE(value.get() != NULL); |
445 EXPECT_TRUE(value->Equals(&kIntegerValue)); | 445 EXPECT_TRUE(value->Equals(&kIntegerValue)); |
446 value.reset(PopDataAsValue(&reader)); | 446 value.reset(PopDataAsValue(&reader)); |
447 ASSERT_TRUE(value.get() != NULL); | 447 ASSERT_TRUE(value.get() != NULL); |
448 EXPECT_TRUE(value->Equals(&kDoubleValue)); | 448 EXPECT_TRUE(value->Equals(&kDoubleValue)); |
449 value.reset(PopDataAsValue(&reader)); | 449 value.reset(PopDataAsValue(&reader)); |
450 ASSERT_TRUE(value.get() != NULL); | 450 ASSERT_TRUE(value.get() != NULL); |
451 EXPECT_TRUE(value->Equals(&kStringValue)); | 451 EXPECT_TRUE(value->Equals(&kStringValue)); |
452 } | 452 } |
453 | 453 |
454 TEST(ValuesUtilTest, AppendValueDataBasicTypes) { | 454 TEST(ValuesUtilTest, AppendValueDataBasicTypes) { |
455 const base::FundamentalValue kBoolValue(false); | 455 const base::FundamentalValue kBoolValue(false); |
456 const base::FundamentalValue kIntegerValue(42); | 456 const base::FundamentalValue kIntegerValue(42); |
457 const base::FundamentalValue kDoubleValue(4.2); | 457 const base::FundamentalValue kDoubleValue(4.2); |
458 const base::StringValue kStringValue("string"); | 458 const base::StringValue kStringValue("string"); |
459 | 459 |
460 scoped_ptr<Response> response(Response::CreateEmpty()); | 460 std::unique_ptr<Response> response(Response::CreateEmpty()); |
461 MessageWriter writer(response.get()); | 461 MessageWriter writer(response.get()); |
462 AppendValueData(&writer, kBoolValue); | 462 AppendValueData(&writer, kBoolValue); |
463 AppendValueData(&writer, kIntegerValue); | 463 AppendValueData(&writer, kIntegerValue); |
464 AppendValueData(&writer, kDoubleValue); | 464 AppendValueData(&writer, kDoubleValue); |
465 AppendValueData(&writer, kStringValue); | 465 AppendValueData(&writer, kStringValue); |
466 | 466 |
467 MessageReader reader(response.get()); | 467 MessageReader reader(response.get()); |
468 scoped_ptr<base::Value> value; | 468 std::unique_ptr<base::Value> value; |
469 value.reset(PopDataAsValue(&reader)); | 469 value.reset(PopDataAsValue(&reader)); |
470 ASSERT_TRUE(value.get() != NULL); | 470 ASSERT_TRUE(value.get() != NULL); |
471 EXPECT_TRUE(value->Equals(&kBoolValue)); | 471 EXPECT_TRUE(value->Equals(&kBoolValue)); |
472 value.reset(PopDataAsValue(&reader)); | 472 value.reset(PopDataAsValue(&reader)); |
473 ASSERT_TRUE(value.get() != NULL); | 473 ASSERT_TRUE(value.get() != NULL); |
474 EXPECT_TRUE(value->Equals(&kIntegerValue)); | 474 EXPECT_TRUE(value->Equals(&kIntegerValue)); |
475 value.reset(PopDataAsValue(&reader)); | 475 value.reset(PopDataAsValue(&reader)); |
476 ASSERT_TRUE(value.get() != NULL); | 476 ASSERT_TRUE(value.get() != NULL); |
477 EXPECT_TRUE(value->Equals(&kDoubleValue)); | 477 EXPECT_TRUE(value->Equals(&kDoubleValue)); |
478 value.reset(PopDataAsValue(&reader)); | 478 value.reset(PopDataAsValue(&reader)); |
479 ASSERT_TRUE(value.get() != NULL); | 479 ASSERT_TRUE(value.get() != NULL); |
480 EXPECT_TRUE(value->Equals(&kStringValue)); | 480 EXPECT_TRUE(value->Equals(&kStringValue)); |
481 } | 481 } |
482 | 482 |
483 TEST(ValuesUtilTest, AppendValueDataAsVariantBasicTypes) { | 483 TEST(ValuesUtilTest, AppendValueDataAsVariantBasicTypes) { |
484 const base::FundamentalValue kBoolValue(false); | 484 const base::FundamentalValue kBoolValue(false); |
485 const base::FundamentalValue kIntegerValue(42); | 485 const base::FundamentalValue kIntegerValue(42); |
486 const base::FundamentalValue kDoubleValue(4.2); | 486 const base::FundamentalValue kDoubleValue(4.2); |
487 const base::StringValue kStringValue("string"); | 487 const base::StringValue kStringValue("string"); |
488 | 488 |
489 scoped_ptr<Response> response(Response::CreateEmpty()); | 489 std::unique_ptr<Response> response(Response::CreateEmpty()); |
490 MessageWriter writer(response.get()); | 490 MessageWriter writer(response.get()); |
491 AppendValueDataAsVariant(&writer, kBoolValue); | 491 AppendValueDataAsVariant(&writer, kBoolValue); |
492 AppendValueDataAsVariant(&writer, kIntegerValue); | 492 AppendValueDataAsVariant(&writer, kIntegerValue); |
493 AppendValueDataAsVariant(&writer, kDoubleValue); | 493 AppendValueDataAsVariant(&writer, kDoubleValue); |
494 AppendValueDataAsVariant(&writer, kStringValue); | 494 AppendValueDataAsVariant(&writer, kStringValue); |
495 | 495 |
496 MessageReader reader(response.get()); | 496 MessageReader reader(response.get()); |
497 scoped_ptr<base::Value> value; | 497 std::unique_ptr<base::Value> value; |
498 value.reset(PopDataAsValue(&reader)); | 498 value.reset(PopDataAsValue(&reader)); |
499 ASSERT_TRUE(value.get() != NULL); | 499 ASSERT_TRUE(value.get() != NULL); |
500 EXPECT_TRUE(value->Equals(&kBoolValue)); | 500 EXPECT_TRUE(value->Equals(&kBoolValue)); |
501 value.reset(PopDataAsValue(&reader)); | 501 value.reset(PopDataAsValue(&reader)); |
502 ASSERT_TRUE(value.get() != NULL); | 502 ASSERT_TRUE(value.get() != NULL); |
503 EXPECT_TRUE(value->Equals(&kIntegerValue)); | 503 EXPECT_TRUE(value->Equals(&kIntegerValue)); |
504 value.reset(PopDataAsValue(&reader)); | 504 value.reset(PopDataAsValue(&reader)); |
505 ASSERT_TRUE(value.get() != NULL); | 505 ASSERT_TRUE(value.get() != NULL); |
506 EXPECT_TRUE(value->Equals(&kDoubleValue)); | 506 EXPECT_TRUE(value->Equals(&kDoubleValue)); |
507 value.reset(PopDataAsValue(&reader)); | 507 value.reset(PopDataAsValue(&reader)); |
(...skipping 24 matching lines...) Expand all Loading... |
532 dictionary_value->SetInteger(kKey2, kDoubleValue); | 532 dictionary_value->SetInteger(kKey2, kDoubleValue); |
533 | 533 |
534 base::DictionaryValue test_dictionary; | 534 base::DictionaryValue test_dictionary; |
535 test_dictionary.SetBoolean(kKey1, kBoolValue); | 535 test_dictionary.SetBoolean(kKey1, kBoolValue); |
536 test_dictionary.SetInteger(kKey2, kInt32Value); | 536 test_dictionary.SetInteger(kKey2, kInt32Value); |
537 test_dictionary.SetDouble(kKey3, kDoubleValue); | 537 test_dictionary.SetDouble(kKey3, kDoubleValue); |
538 test_dictionary.SetString(kKey4, kStringValue); | 538 test_dictionary.SetString(kKey4, kStringValue); |
539 test_dictionary.Set(kKey5, list_value); // takes ownership | 539 test_dictionary.Set(kKey5, list_value); // takes ownership |
540 test_dictionary.Set(kKey6, dictionary_value); // takes ownership | 540 test_dictionary.Set(kKey6, dictionary_value); // takes ownership |
541 | 541 |
542 scoped_ptr<Response> response(Response::CreateEmpty()); | 542 std::unique_ptr<Response> response(Response::CreateEmpty()); |
543 MessageWriter writer(response.get()); | 543 MessageWriter writer(response.get()); |
544 AppendValueData(&writer, test_dictionary); | 544 AppendValueData(&writer, test_dictionary); |
545 base::FundamentalValue int_value(kInt32Value); | 545 base::FundamentalValue int_value(kInt32Value); |
546 AppendValueData(&writer, int_value); | 546 AppendValueData(&writer, int_value); |
547 | 547 |
548 // Read the data. | 548 // Read the data. |
549 MessageReader reader(response.get()); | 549 MessageReader reader(response.get()); |
550 scoped_ptr<base::Value> value; | 550 std::unique_ptr<base::Value> value; |
551 value.reset(PopDataAsValue(&reader)); | 551 value.reset(PopDataAsValue(&reader)); |
552 ASSERT_TRUE(value.get() != NULL); | 552 ASSERT_TRUE(value.get() != NULL); |
553 EXPECT_TRUE(value->Equals(&test_dictionary)); | 553 EXPECT_TRUE(value->Equals(&test_dictionary)); |
554 value.reset(PopDataAsValue(&reader)); | 554 value.reset(PopDataAsValue(&reader)); |
555 ASSERT_TRUE(value.get() != NULL); | 555 ASSERT_TRUE(value.get() != NULL); |
556 EXPECT_TRUE(value->Equals(&int_value)); | 556 EXPECT_TRUE(value->Equals(&int_value)); |
557 } | 557 } |
558 | 558 |
559 TEST(ValuesUtilTest, AppendDictionaryAsVariant) { | 559 TEST(ValuesUtilTest, AppendDictionaryAsVariant) { |
560 // Set up the input dictionary. | 560 // Set up the input dictionary. |
(...skipping 18 matching lines...) Expand all Loading... |
579 dictionary_value->SetInteger(kKey2, kDoubleValue); | 579 dictionary_value->SetInteger(kKey2, kDoubleValue); |
580 | 580 |
581 base::DictionaryValue test_dictionary; | 581 base::DictionaryValue test_dictionary; |
582 test_dictionary.SetBoolean(kKey1, kBoolValue); | 582 test_dictionary.SetBoolean(kKey1, kBoolValue); |
583 test_dictionary.SetInteger(kKey2, kInt32Value); | 583 test_dictionary.SetInteger(kKey2, kInt32Value); |
584 test_dictionary.SetDouble(kKey3, kDoubleValue); | 584 test_dictionary.SetDouble(kKey3, kDoubleValue); |
585 test_dictionary.SetString(kKey4, kStringValue); | 585 test_dictionary.SetString(kKey4, kStringValue); |
586 test_dictionary.Set(kKey5, list_value); // takes ownership | 586 test_dictionary.Set(kKey5, list_value); // takes ownership |
587 test_dictionary.Set(kKey6, dictionary_value); // takes ownership | 587 test_dictionary.Set(kKey6, dictionary_value); // takes ownership |
588 | 588 |
589 scoped_ptr<Response> response(Response::CreateEmpty()); | 589 std::unique_ptr<Response> response(Response::CreateEmpty()); |
590 MessageWriter writer(response.get()); | 590 MessageWriter writer(response.get()); |
591 AppendValueDataAsVariant(&writer, test_dictionary); | 591 AppendValueDataAsVariant(&writer, test_dictionary); |
592 base::FundamentalValue int_value(kInt32Value); | 592 base::FundamentalValue int_value(kInt32Value); |
593 AppendValueData(&writer, int_value); | 593 AppendValueData(&writer, int_value); |
594 | 594 |
595 // Read the data. | 595 // Read the data. |
596 MessageReader reader(response.get()); | 596 MessageReader reader(response.get()); |
597 scoped_ptr<base::Value> value; | 597 std::unique_ptr<base::Value> value; |
598 value.reset(PopDataAsValue(&reader)); | 598 value.reset(PopDataAsValue(&reader)); |
599 ASSERT_TRUE(value.get() != NULL); | 599 ASSERT_TRUE(value.get() != NULL); |
600 EXPECT_TRUE(value->Equals(&test_dictionary)); | 600 EXPECT_TRUE(value->Equals(&test_dictionary)); |
601 value.reset(PopDataAsValue(&reader)); | 601 value.reset(PopDataAsValue(&reader)); |
602 ASSERT_TRUE(value.get() != NULL); | 602 ASSERT_TRUE(value.get() != NULL); |
603 EXPECT_TRUE(value->Equals(&int_value)); | 603 EXPECT_TRUE(value->Equals(&int_value)); |
604 } | 604 } |
605 | 605 |
606 TEST(ValuesUtilTest, AppendList) { | 606 TEST(ValuesUtilTest, AppendList) { |
607 // Set up the input list. | 607 // Set up the input list. |
(...skipping 14 matching lines...) Expand all Loading... |
622 dictionary_value->SetInteger(kKey2, kDoubleValue); | 622 dictionary_value->SetInteger(kKey2, kDoubleValue); |
623 | 623 |
624 base::ListValue test_list; | 624 base::ListValue test_list; |
625 test_list.AppendBoolean(kBoolValue); | 625 test_list.AppendBoolean(kBoolValue); |
626 test_list.AppendInteger(kInt32Value); | 626 test_list.AppendInteger(kInt32Value); |
627 test_list.AppendDouble(kDoubleValue); | 627 test_list.AppendDouble(kDoubleValue); |
628 test_list.AppendString(kStringValue); | 628 test_list.AppendString(kStringValue); |
629 test_list.Append(list_value); // takes ownership | 629 test_list.Append(list_value); // takes ownership |
630 test_list.Append(dictionary_value); // takes ownership | 630 test_list.Append(dictionary_value); // takes ownership |
631 | 631 |
632 scoped_ptr<Response> response(Response::CreateEmpty()); | 632 std::unique_ptr<Response> response(Response::CreateEmpty()); |
633 MessageWriter writer(response.get()); | 633 MessageWriter writer(response.get()); |
634 AppendValueData(&writer, test_list); | 634 AppendValueData(&writer, test_list); |
635 base::FundamentalValue int_value(kInt32Value); | 635 base::FundamentalValue int_value(kInt32Value); |
636 AppendValueData(&writer, int_value); | 636 AppendValueData(&writer, int_value); |
637 | 637 |
638 // Read the data. | 638 // Read the data. |
639 MessageReader reader(response.get()); | 639 MessageReader reader(response.get()); |
640 scoped_ptr<base::Value> value; | 640 std::unique_ptr<base::Value> value; |
641 value.reset(PopDataAsValue(&reader)); | 641 value.reset(PopDataAsValue(&reader)); |
642 ASSERT_TRUE(value.get() != NULL); | 642 ASSERT_TRUE(value.get() != NULL); |
643 EXPECT_TRUE(value->Equals(&test_list)); | 643 EXPECT_TRUE(value->Equals(&test_list)); |
644 value.reset(PopDataAsValue(&reader)); | 644 value.reset(PopDataAsValue(&reader)); |
645 ASSERT_TRUE(value.get() != NULL); | 645 ASSERT_TRUE(value.get() != NULL); |
646 EXPECT_TRUE(value->Equals(&int_value)); | 646 EXPECT_TRUE(value->Equals(&int_value)); |
647 } | 647 } |
648 | 648 |
649 TEST(ValuesUtilTest, AppendListAsVariant) { | 649 TEST(ValuesUtilTest, AppendListAsVariant) { |
650 // Set up the input list. | 650 // Set up the input list. |
(...skipping 14 matching lines...) Expand all Loading... |
665 dictionary_value->SetInteger(kKey2, kDoubleValue); | 665 dictionary_value->SetInteger(kKey2, kDoubleValue); |
666 | 666 |
667 base::ListValue test_list; | 667 base::ListValue test_list; |
668 test_list.AppendBoolean(kBoolValue); | 668 test_list.AppendBoolean(kBoolValue); |
669 test_list.AppendInteger(kInt32Value); | 669 test_list.AppendInteger(kInt32Value); |
670 test_list.AppendDouble(kDoubleValue); | 670 test_list.AppendDouble(kDoubleValue); |
671 test_list.AppendString(kStringValue); | 671 test_list.AppendString(kStringValue); |
672 test_list.Append(list_value); // takes ownership | 672 test_list.Append(list_value); // takes ownership |
673 test_list.Append(dictionary_value); // takes ownership | 673 test_list.Append(dictionary_value); // takes ownership |
674 | 674 |
675 scoped_ptr<Response> response(Response::CreateEmpty()); | 675 std::unique_ptr<Response> response(Response::CreateEmpty()); |
676 MessageWriter writer(response.get()); | 676 MessageWriter writer(response.get()); |
677 AppendValueDataAsVariant(&writer, test_list); | 677 AppendValueDataAsVariant(&writer, test_list); |
678 base::FundamentalValue int_value(kInt32Value); | 678 base::FundamentalValue int_value(kInt32Value); |
679 AppendValueData(&writer, int_value); | 679 AppendValueData(&writer, int_value); |
680 | 680 |
681 // Read the data. | 681 // Read the data. |
682 MessageReader reader(response.get()); | 682 MessageReader reader(response.get()); |
683 scoped_ptr<base::Value> value; | 683 std::unique_ptr<base::Value> value; |
684 value.reset(PopDataAsValue(&reader)); | 684 value.reset(PopDataAsValue(&reader)); |
685 ASSERT_TRUE(value.get() != NULL); | 685 ASSERT_TRUE(value.get() != NULL); |
686 EXPECT_TRUE(value->Equals(&test_list)); | 686 EXPECT_TRUE(value->Equals(&test_list)); |
687 value.reset(PopDataAsValue(&reader)); | 687 value.reset(PopDataAsValue(&reader)); |
688 ASSERT_TRUE(value.get() != NULL); | 688 ASSERT_TRUE(value.get() != NULL); |
689 EXPECT_TRUE(value->Equals(&int_value)); | 689 EXPECT_TRUE(value->Equals(&int_value)); |
690 } | 690 } |
691 | 691 |
692 } // namespace dbus | 692 } // namespace dbus |
OLD | NEW |