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/message.h" | 5 #include "dbus/message.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
| 10 #include <memory> |
| 11 |
10 #include "base/logging.h" | 12 #include "base/logging.h" |
11 #include "base/memory/scoped_ptr.h" | |
12 #include "base/posix/eintr_wrapper.h" | 13 #include "base/posix/eintr_wrapper.h" |
13 #include "dbus/object_path.h" | 14 #include "dbus/object_path.h" |
14 #include "dbus/test_proto.pb.h" | 15 #include "dbus/test_proto.pb.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
16 | 17 |
17 namespace dbus { | 18 namespace dbus { |
18 | 19 |
19 // Test that a byte can be properly written and read. We only have this | 20 // Test that a byte can be properly written and read. We only have this |
20 // test for byte, as repeating this for other basic types is too redundant. | 21 // test for byte, as repeating this for other basic types is too redundant. |
21 TEST(MessageTest, AppendAndPopByte) { | 22 TEST(MessageTest, AppendAndPopByte) { |
22 scoped_ptr<Response> message(Response::CreateEmpty()); | 23 std::unique_ptr<Response> message(Response::CreateEmpty()); |
23 MessageWriter writer(message.get()); | 24 MessageWriter writer(message.get()); |
24 writer.AppendByte(123); // The input is 123. | 25 writer.AppendByte(123); // The input is 123. |
25 | 26 |
26 MessageReader reader(message.get()); | 27 MessageReader reader(message.get()); |
27 ASSERT_TRUE(reader.HasMoreData()); // Should have data to read. | 28 ASSERT_TRUE(reader.HasMoreData()); // Should have data to read. |
28 ASSERT_EQ(Message::BYTE, reader.GetDataType()); | 29 ASSERT_EQ(Message::BYTE, reader.GetDataType()); |
29 ASSERT_EQ("y", reader.GetDataSignature()); | 30 ASSERT_EQ("y", reader.GetDataSignature()); |
30 | 31 |
31 bool bool_value = false; | 32 bool bool_value = false; |
32 // Should fail as the type is not bool here. | 33 // Should fail as the type is not bool here. |
33 ASSERT_FALSE(reader.PopBool(&bool_value)); | 34 ASSERT_FALSE(reader.PopBool(&bool_value)); |
34 | 35 |
35 uint8_t byte_value = 0; | 36 uint8_t byte_value = 0; |
36 ASSERT_TRUE(reader.PopByte(&byte_value)); | 37 ASSERT_TRUE(reader.PopByte(&byte_value)); |
37 EXPECT_EQ(123, byte_value); // Should match with the input. | 38 EXPECT_EQ(123, byte_value); // Should match with the input. |
38 ASSERT_FALSE(reader.HasMoreData()); // Should not have more data to read. | 39 ASSERT_FALSE(reader.HasMoreData()); // Should not have more data to read. |
39 | 40 |
40 // Try to get another byte. Should fail. | 41 // Try to get another byte. Should fail. |
41 ASSERT_FALSE(reader.PopByte(&byte_value)); | 42 ASSERT_FALSE(reader.PopByte(&byte_value)); |
42 } | 43 } |
43 | 44 |
44 // Check all basic types can be properly written and read. | 45 // Check all basic types can be properly written and read. |
45 TEST(MessageTest, AppendAndPopBasicDataTypes) { | 46 TEST(MessageTest, AppendAndPopBasicDataTypes) { |
46 scoped_ptr<Response> message(Response::CreateEmpty()); | 47 std::unique_ptr<Response> message(Response::CreateEmpty()); |
47 MessageWriter writer(message.get()); | 48 MessageWriter writer(message.get()); |
48 | 49 |
49 // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path". | 50 // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path". |
50 writer.AppendByte(0); | 51 writer.AppendByte(0); |
51 writer.AppendBool(true); | 52 writer.AppendBool(true); |
52 writer.AppendInt16(2); | 53 writer.AppendInt16(2); |
53 writer.AppendUint16(3); | 54 writer.AppendUint16(3); |
54 writer.AppendInt32(4); | 55 writer.AppendInt32(4); |
55 writer.AppendUint32(5); | 56 writer.AppendUint32(5); |
56 writer.AppendInt64(6); | 57 writer.AppendInt64(6); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
112 EXPECT_EQ(ObjectPath("/object/path"), object_path_value); | 113 EXPECT_EQ(ObjectPath("/object/path"), object_path_value); |
113 } | 114 } |
114 | 115 |
115 // Check all basic types can be properly written and read. | 116 // Check all basic types can be properly written and read. |
116 TEST(MessageTest, AppendAndPopFileDescriptor) { | 117 TEST(MessageTest, AppendAndPopFileDescriptor) { |
117 if (!IsDBusTypeUnixFdSupported()) { | 118 if (!IsDBusTypeUnixFdSupported()) { |
118 LOG(WARNING) << "FD passing is not supported"; | 119 LOG(WARNING) << "FD passing is not supported"; |
119 return; | 120 return; |
120 } | 121 } |
121 | 122 |
122 scoped_ptr<Response> message(Response::CreateEmpty()); | 123 std::unique_ptr<Response> message(Response::CreateEmpty()); |
123 MessageWriter writer(message.get()); | 124 MessageWriter writer(message.get()); |
124 | 125 |
125 // Append stdout. | 126 // Append stdout. |
126 FileDescriptor temp(1); | 127 FileDescriptor temp(1); |
127 // Descriptor should not be valid until checked. | 128 // Descriptor should not be valid until checked. |
128 ASSERT_FALSE(temp.is_valid()); | 129 ASSERT_FALSE(temp.is_valid()); |
129 // NB: thread IO requirements not relevant for unit tests. | 130 // NB: thread IO requirements not relevant for unit tests. |
130 temp.CheckValidity(); | 131 temp.CheckValidity(); |
131 ASSERT_TRUE(temp.is_valid()); | 132 ASSERT_TRUE(temp.is_valid()); |
132 writer.AppendFileDescriptor(temp); | 133 writer.AppendFileDescriptor(temp); |
(...skipping 18 matching lines...) Expand all Loading... |
151 int status_stdout = HANDLE_EINTR(fstat(1, &sb_stdout)); | 152 int status_stdout = HANDLE_EINTR(fstat(1, &sb_stdout)); |
152 ASSERT_GE(status_stdout, 0); | 153 ASSERT_GE(status_stdout, 0); |
153 struct stat sb_fd; | 154 struct stat sb_fd; |
154 int status_fd = HANDLE_EINTR(fstat(fd_value.value(), &sb_fd)); | 155 int status_fd = HANDLE_EINTR(fstat(fd_value.value(), &sb_fd)); |
155 ASSERT_GE(status_fd, 0); | 156 ASSERT_GE(status_fd, 0); |
156 EXPECT_EQ(sb_stdout.st_rdev, sb_fd.st_rdev); | 157 EXPECT_EQ(sb_stdout.st_rdev, sb_fd.st_rdev); |
157 } | 158 } |
158 | 159 |
159 // Check all variant types can be properly written and read. | 160 // Check all variant types can be properly written and read. |
160 TEST(MessageTest, AppendAndPopVariantDataTypes) { | 161 TEST(MessageTest, AppendAndPopVariantDataTypes) { |
161 scoped_ptr<Response> message(Response::CreateEmpty()); | 162 std::unique_ptr<Response> message(Response::CreateEmpty()); |
162 MessageWriter writer(message.get()); | 163 MessageWriter writer(message.get()); |
163 | 164 |
164 // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path". | 165 // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path". |
165 writer.AppendVariantOfByte(0); | 166 writer.AppendVariantOfByte(0); |
166 writer.AppendVariantOfBool(true); | 167 writer.AppendVariantOfBool(true); |
167 writer.AppendVariantOfInt16(2); | 168 writer.AppendVariantOfInt16(2); |
168 writer.AppendVariantOfUint16(3); | 169 writer.AppendVariantOfUint16(3); |
169 writer.AppendVariantOfInt32(4); | 170 writer.AppendVariantOfInt32(4); |
170 writer.AppendVariantOfUint32(5); | 171 writer.AppendVariantOfUint32(5); |
171 writer.AppendVariantOfInt64(6); | 172 writer.AppendVariantOfInt64(6); |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
221 EXPECT_EQ(4, int32_value); | 222 EXPECT_EQ(4, int32_value); |
222 EXPECT_EQ(5U, uint32_value); | 223 EXPECT_EQ(5U, uint32_value); |
223 EXPECT_EQ(6, int64_value); | 224 EXPECT_EQ(6, int64_value); |
224 EXPECT_EQ(7U, uint64_value); | 225 EXPECT_EQ(7U, uint64_value); |
225 EXPECT_DOUBLE_EQ(8.0, double_value); | 226 EXPECT_DOUBLE_EQ(8.0, double_value); |
226 EXPECT_EQ("string", string_value); | 227 EXPECT_EQ("string", string_value); |
227 EXPECT_EQ(ObjectPath("/object/path"), object_path_value); | 228 EXPECT_EQ(ObjectPath("/object/path"), object_path_value); |
228 } | 229 } |
229 | 230 |
230 TEST(MessageTest, ArrayOfBytes) { | 231 TEST(MessageTest, ArrayOfBytes) { |
231 scoped_ptr<Response> message(Response::CreateEmpty()); | 232 std::unique_ptr<Response> message(Response::CreateEmpty()); |
232 MessageWriter writer(message.get()); | 233 MessageWriter writer(message.get()); |
233 std::vector<uint8_t> bytes; | 234 std::vector<uint8_t> bytes; |
234 bytes.push_back(1); | 235 bytes.push_back(1); |
235 bytes.push_back(2); | 236 bytes.push_back(2); |
236 bytes.push_back(3); | 237 bytes.push_back(3); |
237 writer.AppendArrayOfBytes(bytes.data(), bytes.size()); | 238 writer.AppendArrayOfBytes(bytes.data(), bytes.size()); |
238 | 239 |
239 MessageReader reader(message.get()); | 240 MessageReader reader(message.get()); |
240 const uint8_t* output_bytes = NULL; | 241 const uint8_t* output_bytes = NULL; |
241 size_t length = 0; | 242 size_t length = 0; |
242 ASSERT_EQ("ay", reader.GetDataSignature()); | 243 ASSERT_EQ("ay", reader.GetDataSignature()); |
243 ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length)); | 244 ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length)); |
244 ASSERT_FALSE(reader.HasMoreData()); | 245 ASSERT_FALSE(reader.HasMoreData()); |
245 ASSERT_EQ(3U, length); | 246 ASSERT_EQ(3U, length); |
246 EXPECT_EQ(1, output_bytes[0]); | 247 EXPECT_EQ(1, output_bytes[0]); |
247 EXPECT_EQ(2, output_bytes[1]); | 248 EXPECT_EQ(2, output_bytes[1]); |
248 EXPECT_EQ(3, output_bytes[2]); | 249 EXPECT_EQ(3, output_bytes[2]); |
249 } | 250 } |
250 | 251 |
251 TEST(MessageTest, ArrayOfDoubles) { | 252 TEST(MessageTest, ArrayOfDoubles) { |
252 scoped_ptr<Response> message(Response::CreateEmpty()); | 253 std::unique_ptr<Response> message(Response::CreateEmpty()); |
253 MessageWriter writer(message.get()); | 254 MessageWriter writer(message.get()); |
254 std::vector<double> doubles; | 255 std::vector<double> doubles; |
255 doubles.push_back(0.2); | 256 doubles.push_back(0.2); |
256 doubles.push_back(0.5); | 257 doubles.push_back(0.5); |
257 doubles.push_back(1); | 258 doubles.push_back(1); |
258 writer.AppendArrayOfDoubles(doubles.data(), doubles.size()); | 259 writer.AppendArrayOfDoubles(doubles.data(), doubles.size()); |
259 | 260 |
260 MessageReader reader(message.get()); | 261 MessageReader reader(message.get()); |
261 const double* output_doubles = NULL; | 262 const double* output_doubles = NULL; |
262 size_t length = 0; | 263 size_t length = 0; |
263 ASSERT_EQ("ad", reader.GetDataSignature()); | 264 ASSERT_EQ("ad", reader.GetDataSignature()); |
264 ASSERT_TRUE(reader.PopArrayOfDoubles(&output_doubles, &length)); | 265 ASSERT_TRUE(reader.PopArrayOfDoubles(&output_doubles, &length)); |
265 ASSERT_FALSE(reader.HasMoreData()); | 266 ASSERT_FALSE(reader.HasMoreData()); |
266 ASSERT_EQ(3U, length); | 267 ASSERT_EQ(3U, length); |
267 EXPECT_EQ(0.2, output_doubles[0]); | 268 EXPECT_EQ(0.2, output_doubles[0]); |
268 EXPECT_EQ(0.5, output_doubles[1]); | 269 EXPECT_EQ(0.5, output_doubles[1]); |
269 EXPECT_EQ(1, output_doubles[2]); | 270 EXPECT_EQ(1, output_doubles[2]); |
270 } | 271 } |
271 | 272 |
272 TEST(MessageTest, ArrayOfBytes_Empty) { | 273 TEST(MessageTest, ArrayOfBytes_Empty) { |
273 scoped_ptr<Response> message(Response::CreateEmpty()); | 274 std::unique_ptr<Response> message(Response::CreateEmpty()); |
274 MessageWriter writer(message.get()); | 275 MessageWriter writer(message.get()); |
275 std::vector<uint8_t> bytes; | 276 std::vector<uint8_t> bytes; |
276 writer.AppendArrayOfBytes(bytes.data(), bytes.size()); | 277 writer.AppendArrayOfBytes(bytes.data(), bytes.size()); |
277 | 278 |
278 MessageReader reader(message.get()); | 279 MessageReader reader(message.get()); |
279 const uint8_t* output_bytes = NULL; | 280 const uint8_t* output_bytes = NULL; |
280 size_t length = 0; | 281 size_t length = 0; |
281 ASSERT_EQ("ay", reader.GetDataSignature()); | 282 ASSERT_EQ("ay", reader.GetDataSignature()); |
282 ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length)); | 283 ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length)); |
283 ASSERT_FALSE(reader.HasMoreData()); | 284 ASSERT_FALSE(reader.HasMoreData()); |
284 ASSERT_EQ(0U, length); | 285 ASSERT_EQ(0U, length); |
285 EXPECT_EQ(NULL, output_bytes); | 286 EXPECT_EQ(NULL, output_bytes); |
286 } | 287 } |
287 | 288 |
288 TEST(MessageTest, ArrayOfStrings) { | 289 TEST(MessageTest, ArrayOfStrings) { |
289 scoped_ptr<Response> message(Response::CreateEmpty()); | 290 std::unique_ptr<Response> message(Response::CreateEmpty()); |
290 MessageWriter writer(message.get()); | 291 MessageWriter writer(message.get()); |
291 std::vector<std::string> strings; | 292 std::vector<std::string> strings; |
292 strings.push_back("fee"); | 293 strings.push_back("fee"); |
293 strings.push_back("fie"); | 294 strings.push_back("fie"); |
294 strings.push_back("foe"); | 295 strings.push_back("foe"); |
295 strings.push_back("fum"); | 296 strings.push_back("fum"); |
296 writer.AppendArrayOfStrings(strings); | 297 writer.AppendArrayOfStrings(strings); |
297 | 298 |
298 MessageReader reader(message.get()); | 299 MessageReader reader(message.get()); |
299 std::vector<std::string> output_strings; | 300 std::vector<std::string> output_strings; |
300 ASSERT_EQ("as", reader.GetDataSignature()); | 301 ASSERT_EQ("as", reader.GetDataSignature()); |
301 ASSERT_TRUE(reader.PopArrayOfStrings(&output_strings)); | 302 ASSERT_TRUE(reader.PopArrayOfStrings(&output_strings)); |
302 ASSERT_FALSE(reader.HasMoreData()); | 303 ASSERT_FALSE(reader.HasMoreData()); |
303 ASSERT_EQ(4U, output_strings.size()); | 304 ASSERT_EQ(4U, output_strings.size()); |
304 EXPECT_EQ("fee", output_strings[0]); | 305 EXPECT_EQ("fee", output_strings[0]); |
305 EXPECT_EQ("fie", output_strings[1]); | 306 EXPECT_EQ("fie", output_strings[1]); |
306 EXPECT_EQ("foe", output_strings[2]); | 307 EXPECT_EQ("foe", output_strings[2]); |
307 EXPECT_EQ("fum", output_strings[3]); | 308 EXPECT_EQ("fum", output_strings[3]); |
308 } | 309 } |
309 | 310 |
310 TEST(MessageTest, ArrayOfObjectPaths) { | 311 TEST(MessageTest, ArrayOfObjectPaths) { |
311 scoped_ptr<Response> message(Response::CreateEmpty()); | 312 std::unique_ptr<Response> message(Response::CreateEmpty()); |
312 MessageWriter writer(message.get()); | 313 MessageWriter writer(message.get()); |
313 std::vector<ObjectPath> object_paths; | 314 std::vector<ObjectPath> object_paths; |
314 object_paths.push_back(ObjectPath("/object/path/1")); | 315 object_paths.push_back(ObjectPath("/object/path/1")); |
315 object_paths.push_back(ObjectPath("/object/path/2")); | 316 object_paths.push_back(ObjectPath("/object/path/2")); |
316 object_paths.push_back(ObjectPath("/object/path/3")); | 317 object_paths.push_back(ObjectPath("/object/path/3")); |
317 writer.AppendArrayOfObjectPaths(object_paths); | 318 writer.AppendArrayOfObjectPaths(object_paths); |
318 | 319 |
319 MessageReader reader(message.get()); | 320 MessageReader reader(message.get()); |
320 std::vector<ObjectPath> output_object_paths; | 321 std::vector<ObjectPath> output_object_paths; |
321 ASSERT_EQ("ao", reader.GetDataSignature()); | 322 ASSERT_EQ("ao", reader.GetDataSignature()); |
322 ASSERT_TRUE(reader.PopArrayOfObjectPaths(&output_object_paths)); | 323 ASSERT_TRUE(reader.PopArrayOfObjectPaths(&output_object_paths)); |
323 ASSERT_FALSE(reader.HasMoreData()); | 324 ASSERT_FALSE(reader.HasMoreData()); |
324 ASSERT_EQ(3U, output_object_paths.size()); | 325 ASSERT_EQ(3U, output_object_paths.size()); |
325 EXPECT_EQ(ObjectPath("/object/path/1"), output_object_paths[0]); | 326 EXPECT_EQ(ObjectPath("/object/path/1"), output_object_paths[0]); |
326 EXPECT_EQ(ObjectPath("/object/path/2"), output_object_paths[1]); | 327 EXPECT_EQ(ObjectPath("/object/path/2"), output_object_paths[1]); |
327 EXPECT_EQ(ObjectPath("/object/path/3"), output_object_paths[2]); | 328 EXPECT_EQ(ObjectPath("/object/path/3"), output_object_paths[2]); |
328 } | 329 } |
329 | 330 |
330 TEST(MessageTest, ProtoBuf) { | 331 TEST(MessageTest, ProtoBuf) { |
331 scoped_ptr<Response> message(Response::CreateEmpty()); | 332 std::unique_ptr<Response> message(Response::CreateEmpty()); |
332 MessageWriter writer(message.get()); | 333 MessageWriter writer(message.get()); |
333 TestProto send_message; | 334 TestProto send_message; |
334 send_message.set_text("testing"); | 335 send_message.set_text("testing"); |
335 send_message.set_number(123); | 336 send_message.set_number(123); |
336 writer.AppendProtoAsArrayOfBytes(send_message); | 337 writer.AppendProtoAsArrayOfBytes(send_message); |
337 | 338 |
338 MessageReader reader(message.get()); | 339 MessageReader reader(message.get()); |
339 TestProto receive_message; | 340 TestProto receive_message; |
340 ASSERT_EQ("ay", reader.GetDataSignature()); | 341 ASSERT_EQ("ay", reader.GetDataSignature()); |
341 ASSERT_TRUE(reader.PopArrayOfBytesAsProto(&receive_message)); | 342 ASSERT_TRUE(reader.PopArrayOfBytesAsProto(&receive_message)); |
342 EXPECT_EQ(receive_message.text(), send_message.text()); | 343 EXPECT_EQ(receive_message.text(), send_message.text()); |
343 EXPECT_EQ(receive_message.number(), send_message.number()); | 344 EXPECT_EQ(receive_message.number(), send_message.number()); |
344 } | 345 } |
345 | 346 |
346 | 347 |
347 // Test that an array can be properly written and read. We only have this | 348 // Test that an array can be properly written and read. We only have this |
348 // test for array, as repeating this for other container types is too | 349 // test for array, as repeating this for other container types is too |
349 // redundant. | 350 // redundant. |
350 TEST(MessageTest, OpenArrayAndPopArray) { | 351 TEST(MessageTest, OpenArrayAndPopArray) { |
351 scoped_ptr<Response> message(Response::CreateEmpty()); | 352 std::unique_ptr<Response> message(Response::CreateEmpty()); |
352 MessageWriter writer(message.get()); | 353 MessageWriter writer(message.get()); |
353 MessageWriter array_writer(NULL); | 354 MessageWriter array_writer(NULL); |
354 writer.OpenArray("s", &array_writer); // Open an array of strings. | 355 writer.OpenArray("s", &array_writer); // Open an array of strings. |
355 array_writer.AppendString("foo"); | 356 array_writer.AppendString("foo"); |
356 array_writer.AppendString("bar"); | 357 array_writer.AppendString("bar"); |
357 array_writer.AppendString("baz"); | 358 array_writer.AppendString("baz"); |
358 writer.CloseContainer(&array_writer); | 359 writer.CloseContainer(&array_writer); |
359 | 360 |
360 MessageReader reader(message.get()); | 361 MessageReader reader(message.get()); |
361 ASSERT_EQ(Message::ARRAY, reader.GetDataType()); | 362 ASSERT_EQ(Message::ARRAY, reader.GetDataType()); |
362 ASSERT_EQ("as", reader.GetDataSignature()); | 363 ASSERT_EQ("as", reader.GetDataSignature()); |
363 MessageReader array_reader(NULL); | 364 MessageReader array_reader(NULL); |
364 ASSERT_TRUE(reader.PopArray(&array_reader)); | 365 ASSERT_TRUE(reader.PopArray(&array_reader)); |
365 ASSERT_FALSE(reader.HasMoreData()); // Should not have more data to read. | 366 ASSERT_FALSE(reader.HasMoreData()); // Should not have more data to read. |
366 | 367 |
367 std::string string_value; | 368 std::string string_value; |
368 ASSERT_TRUE(array_reader.PopString(&string_value)); | 369 ASSERT_TRUE(array_reader.PopString(&string_value)); |
369 EXPECT_EQ("foo", string_value); | 370 EXPECT_EQ("foo", string_value); |
370 ASSERT_TRUE(array_reader.PopString(&string_value)); | 371 ASSERT_TRUE(array_reader.PopString(&string_value)); |
371 EXPECT_EQ("bar", string_value); | 372 EXPECT_EQ("bar", string_value); |
372 ASSERT_TRUE(array_reader.PopString(&string_value)); | 373 ASSERT_TRUE(array_reader.PopString(&string_value)); |
373 EXPECT_EQ("baz", string_value); | 374 EXPECT_EQ("baz", string_value); |
374 // Should not have more data to read. | 375 // Should not have more data to read. |
375 ASSERT_FALSE(array_reader.HasMoreData()); | 376 ASSERT_FALSE(array_reader.HasMoreData()); |
376 } | 377 } |
377 | 378 |
378 // Create a complex message using array, struct, variant, dict entry, and | 379 // Create a complex message using array, struct, variant, dict entry, and |
379 // make sure it can be read properly. | 380 // make sure it can be read properly. |
380 TEST(MessageTest, CreateComplexMessageAndReadIt) { | 381 TEST(MessageTest, CreateComplexMessageAndReadIt) { |
381 scoped_ptr<Response> message(Response::CreateEmpty()); | 382 std::unique_ptr<Response> message(Response::CreateEmpty()); |
382 MessageWriter writer(message.get()); | 383 MessageWriter writer(message.get()); |
383 { | 384 { |
384 MessageWriter array_writer(NULL); | 385 MessageWriter array_writer(NULL); |
385 // Open an array of variants. | 386 // Open an array of variants. |
386 writer.OpenArray("v", &array_writer); | 387 writer.OpenArray("v", &array_writer); |
387 { | 388 { |
388 // The first value in the array. | 389 // The first value in the array. |
389 { | 390 { |
390 MessageWriter variant_writer(NULL); | 391 MessageWriter variant_writer(NULL); |
391 // Open a variant of a boolean. | 392 // Open a variant of a boolean. |
(...skipping 137 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
529 "\n" | 530 "\n" |
530 "string \"payload\"\n", | 531 "string \"payload\"\n", |
531 method_call.ToString()); | 532 method_call.ToString()); |
532 } | 533 } |
533 | 534 |
534 TEST(MessageTest, MethodCall_FromRawMessage) { | 535 TEST(MessageTest, MethodCall_FromRawMessage) { |
535 DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL); | 536 DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL); |
536 dbus_message_set_interface(raw_message, "com.example.Interface"); | 537 dbus_message_set_interface(raw_message, "com.example.Interface"); |
537 dbus_message_set_member(raw_message, "SomeMethod"); | 538 dbus_message_set_member(raw_message, "SomeMethod"); |
538 | 539 |
539 scoped_ptr<MethodCall> method_call(MethodCall::FromRawMessage(raw_message)); | 540 std::unique_ptr<MethodCall> method_call( |
| 541 MethodCall::FromRawMessage(raw_message)); |
540 EXPECT_EQ("com.example.Interface", method_call->GetInterface()); | 542 EXPECT_EQ("com.example.Interface", method_call->GetInterface()); |
541 EXPECT_EQ("SomeMethod", method_call->GetMember()); | 543 EXPECT_EQ("SomeMethod", method_call->GetMember()); |
542 } | 544 } |
543 | 545 |
544 TEST(MessageTest, Signal) { | 546 TEST(MessageTest, Signal) { |
545 Signal signal("com.example.Interface", "SomeSignal"); | 547 Signal signal("com.example.Interface", "SomeSignal"); |
546 EXPECT_TRUE(signal.raw_message() != NULL); | 548 EXPECT_TRUE(signal.raw_message() != NULL); |
547 EXPECT_EQ(Message::MESSAGE_SIGNAL, signal.GetMessageType()); | 549 EXPECT_EQ(Message::MESSAGE_SIGNAL, signal.GetMessageType()); |
548 EXPECT_EQ("MESSAGE_SIGNAL", signal.GetMessageTypeAsString()); | 550 EXPECT_EQ("MESSAGE_SIGNAL", signal.GetMessageTypeAsString()); |
549 signal.SetPath(ObjectPath("/com/example/Object")); | 551 signal.SetPath(ObjectPath("/com/example/Object")); |
550 | 552 |
551 MessageWriter writer(&signal); | 553 MessageWriter writer(&signal); |
552 writer.AppendString("payload"); | 554 writer.AppendString("payload"); |
553 | 555 |
554 EXPECT_EQ("message_type: MESSAGE_SIGNAL\n" | 556 EXPECT_EQ("message_type: MESSAGE_SIGNAL\n" |
555 "path: /com/example/Object\n" | 557 "path: /com/example/Object\n" |
556 "interface: com.example.Interface\n" | 558 "interface: com.example.Interface\n" |
557 "member: SomeSignal\n" | 559 "member: SomeSignal\n" |
558 "signature: s\n" | 560 "signature: s\n" |
559 "\n" | 561 "\n" |
560 "string \"payload\"\n", | 562 "string \"payload\"\n", |
561 signal.ToString()); | 563 signal.ToString()); |
562 } | 564 } |
563 | 565 |
564 TEST(MessageTest, Signal_FromRawMessage) { | 566 TEST(MessageTest, Signal_FromRawMessage) { |
565 DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL); | 567 DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL); |
566 dbus_message_set_interface(raw_message, "com.example.Interface"); | 568 dbus_message_set_interface(raw_message, "com.example.Interface"); |
567 dbus_message_set_member(raw_message, "SomeSignal"); | 569 dbus_message_set_member(raw_message, "SomeSignal"); |
568 | 570 |
569 scoped_ptr<Signal> signal(Signal::FromRawMessage(raw_message)); | 571 std::unique_ptr<Signal> signal(Signal::FromRawMessage(raw_message)); |
570 EXPECT_EQ("com.example.Interface", signal->GetInterface()); | 572 EXPECT_EQ("com.example.Interface", signal->GetInterface()); |
571 EXPECT_EQ("SomeSignal", signal->GetMember()); | 573 EXPECT_EQ("SomeSignal", signal->GetMember()); |
572 } | 574 } |
573 | 575 |
574 TEST(MessageTest, Response) { | 576 TEST(MessageTest, Response) { |
575 scoped_ptr<Response> response(Response::CreateEmpty()); | 577 std::unique_ptr<Response> response(Response::CreateEmpty()); |
576 EXPECT_TRUE(response->raw_message()); | 578 EXPECT_TRUE(response->raw_message()); |
577 EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType()); | 579 EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType()); |
578 EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString()); | 580 EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString()); |
579 } | 581 } |
580 | 582 |
581 TEST(MessageTest, Response_FromMethodCall) { | 583 TEST(MessageTest, Response_FromMethodCall) { |
582 const uint32_t kSerial = 123; | 584 const uint32_t kSerial = 123; |
583 MethodCall method_call("com.example.Interface", "SomeMethod"); | 585 MethodCall method_call("com.example.Interface", "SomeMethod"); |
584 method_call.SetSerial(kSerial); | 586 method_call.SetSerial(kSerial); |
585 | 587 |
586 scoped_ptr<Response> response( | 588 std::unique_ptr<Response> response(Response::FromMethodCall(&method_call)); |
587 Response::FromMethodCall(&method_call)); | |
588 EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType()); | 589 EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType()); |
589 EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString()); | 590 EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString()); |
590 // The serial should be copied to the reply serial. | 591 // The serial should be copied to the reply serial. |
591 EXPECT_EQ(kSerial, response->GetReplySerial()); | 592 EXPECT_EQ(kSerial, response->GetReplySerial()); |
592 } | 593 } |
593 | 594 |
594 TEST(MessageTest, ErrorResponse_FromMethodCall) { | 595 TEST(MessageTest, ErrorResponse_FromMethodCall) { |
595 const uint32_t kSerial = 123; | 596 const uint32_t kSerial = 123; |
596 const char kErrorMessage[] = "error message"; | 597 const char kErrorMessage[] = "error message"; |
597 | 598 |
598 MethodCall method_call("com.example.Interface", "SomeMethod"); | 599 MethodCall method_call("com.example.Interface", "SomeMethod"); |
599 method_call.SetSerial(kSerial); | 600 method_call.SetSerial(kSerial); |
600 | 601 |
601 scoped_ptr<ErrorResponse> error_response( | 602 std::unique_ptr<ErrorResponse> error_response(ErrorResponse::FromMethodCall( |
602 ErrorResponse::FromMethodCall(&method_call, | 603 &method_call, DBUS_ERROR_FAILED, kErrorMessage)); |
603 DBUS_ERROR_FAILED, | |
604 kErrorMessage)); | |
605 EXPECT_EQ(Message::MESSAGE_ERROR, error_response->GetMessageType()); | 604 EXPECT_EQ(Message::MESSAGE_ERROR, error_response->GetMessageType()); |
606 EXPECT_EQ("MESSAGE_ERROR", error_response->GetMessageTypeAsString()); | 605 EXPECT_EQ("MESSAGE_ERROR", error_response->GetMessageTypeAsString()); |
607 // The serial should be copied to the reply serial. | 606 // The serial should be copied to the reply serial. |
608 EXPECT_EQ(kSerial, error_response->GetReplySerial()); | 607 EXPECT_EQ(kSerial, error_response->GetReplySerial()); |
609 | 608 |
610 // Error message should be added to the payload. | 609 // Error message should be added to the payload. |
611 MessageReader reader(error_response.get()); | 610 MessageReader reader(error_response.get()); |
612 std::string error_message; | 611 std::string error_message; |
613 ASSERT_TRUE(reader.PopString(&error_message)); | 612 ASSERT_TRUE(reader.PopString(&error_message)); |
614 EXPECT_EQ(kErrorMessage, error_message); | 613 EXPECT_EQ(kErrorMessage, error_message); |
615 } | 614 } |
616 | 615 |
617 TEST(MessageTest, GetAndSetHeaders) { | 616 TEST(MessageTest, GetAndSetHeaders) { |
618 scoped_ptr<Response> message(Response::CreateEmpty()); | 617 std::unique_ptr<Response> message(Response::CreateEmpty()); |
619 | 618 |
620 EXPECT_EQ("", message->GetDestination()); | 619 EXPECT_EQ("", message->GetDestination()); |
621 EXPECT_EQ(ObjectPath(std::string()), message->GetPath()); | 620 EXPECT_EQ(ObjectPath(std::string()), message->GetPath()); |
622 EXPECT_EQ("", message->GetInterface()); | 621 EXPECT_EQ("", message->GetInterface()); |
623 EXPECT_EQ("", message->GetMember()); | 622 EXPECT_EQ("", message->GetMember()); |
624 EXPECT_EQ("", message->GetErrorName()); | 623 EXPECT_EQ("", message->GetErrorName()); |
625 EXPECT_EQ("", message->GetSender()); | 624 EXPECT_EQ("", message->GetSender()); |
626 EXPECT_EQ(0U, message->GetSerial()); | 625 EXPECT_EQ(0U, message->GetSerial()); |
627 EXPECT_EQ(0U, message->GetReplySerial()); | 626 EXPECT_EQ(0U, message->GetReplySerial()); |
628 | 627 |
(...skipping 10 matching lines...) Expand all Loading... |
639 EXPECT_EQ(ObjectPath("/org/chromium/path"), message->GetPath()); | 638 EXPECT_EQ(ObjectPath("/org/chromium/path"), message->GetPath()); |
640 EXPECT_EQ("org.chromium.interface", message->GetInterface()); | 639 EXPECT_EQ("org.chromium.interface", message->GetInterface()); |
641 EXPECT_EQ("member", message->GetMember()); | 640 EXPECT_EQ("member", message->GetMember()); |
642 EXPECT_EQ("org.chromium.error", message->GetErrorName()); | 641 EXPECT_EQ("org.chromium.error", message->GetErrorName()); |
643 EXPECT_EQ(":1.2", message->GetSender()); | 642 EXPECT_EQ(":1.2", message->GetSender()); |
644 EXPECT_EQ(123U, message->GetSerial()); | 643 EXPECT_EQ(123U, message->GetSerial()); |
645 EXPECT_EQ(456U, message->GetReplySerial()); | 644 EXPECT_EQ(456U, message->GetReplySerial()); |
646 } | 645 } |
647 | 646 |
648 TEST(MessageTest, SetInvalidHeaders) { | 647 TEST(MessageTest, SetInvalidHeaders) { |
649 scoped_ptr<Response> message(Response::CreateEmpty()); | 648 std::unique_ptr<Response> message(Response::CreateEmpty()); |
650 EXPECT_EQ("", message->GetDestination()); | 649 EXPECT_EQ("", message->GetDestination()); |
651 EXPECT_EQ(ObjectPath(std::string()), message->GetPath()); | 650 EXPECT_EQ(ObjectPath(std::string()), message->GetPath()); |
652 EXPECT_EQ("", message->GetInterface()); | 651 EXPECT_EQ("", message->GetInterface()); |
653 EXPECT_EQ("", message->GetMember()); | 652 EXPECT_EQ("", message->GetMember()); |
654 EXPECT_EQ("", message->GetErrorName()); | 653 EXPECT_EQ("", message->GetErrorName()); |
655 EXPECT_EQ("", message->GetSender()); | 654 EXPECT_EQ("", message->GetSender()); |
656 | 655 |
657 // Empty element between periods. | 656 // Empty element between periods. |
658 EXPECT_FALSE(message->SetDestination("org..chromium")); | 657 EXPECT_FALSE(message->SetDestination("org..chromium")); |
659 // Trailing '/' is only allowed for the root path. | 658 // Trailing '/' is only allowed for the root path. |
(...skipping 11 matching lines...) Expand all Loading... |
671 EXPECT_EQ(ObjectPath(std::string()), message->GetPath()); | 670 EXPECT_EQ(ObjectPath(std::string()), message->GetPath()); |
672 EXPECT_EQ("", message->GetInterface()); | 671 EXPECT_EQ("", message->GetInterface()); |
673 EXPECT_EQ("", message->GetMember()); | 672 EXPECT_EQ("", message->GetMember()); |
674 EXPECT_EQ("", message->GetErrorName()); | 673 EXPECT_EQ("", message->GetErrorName()); |
675 EXPECT_EQ("", message->GetSender()); | 674 EXPECT_EQ("", message->GetSender()); |
676 } | 675 } |
677 | 676 |
678 TEST(MessageTest, ToString_LongString) { | 677 TEST(MessageTest, ToString_LongString) { |
679 const std::string kLongString(1000, 'o'); | 678 const std::string kLongString(1000, 'o'); |
680 | 679 |
681 scoped_ptr<Response> message(Response::CreateEmpty()); | 680 std::unique_ptr<Response> message(Response::CreateEmpty()); |
682 MessageWriter writer(message.get()); | 681 MessageWriter writer(message.get()); |
683 writer.AppendString(kLongString); | 682 writer.AppendString(kLongString); |
684 | 683 |
685 ASSERT_EQ("message_type: MESSAGE_METHOD_RETURN\n" | 684 ASSERT_EQ("message_type: MESSAGE_METHOD_RETURN\n" |
686 "signature: s\n\n" | 685 "signature: s\n\n" |
687 "string \"oooooooooooooooooooooooooooooooooooooooooooooooo" | 686 "string \"oooooooooooooooooooooooooooooooooooooooooooooooo" |
688 "oooooooooooooooooooooooooooooooooooooooooooooooooooo... " | 687 "oooooooooooooooooooooooooooooooooooooooooooooooooooo... " |
689 "(1000 bytes in total)\"\n", | 688 "(1000 bytes in total)\"\n", |
690 message->ToString()); | 689 message->ToString()); |
691 } | 690 } |
692 | 691 |
693 } // namespace dbus | 692 } // namespace dbus |
OLD | NEW |