1 // Copyright 2012 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "dbus/message.h"
12 #include "base/logging.h"
13 #include "base/posix/eintr_wrapper.h"
14 #include "dbus/object_path.h"
15 #include "dbus/test_proto.pb.h"
16 #include "testing/gtest/include/gtest/gtest.h"
20 // Test that a byte can be properly written and read. We only have this
21 // test for byte, as repeating this for other basic types is too redundant.
22 TEST(MessageTest, AppendAndPopByte) {
23 std::unique_ptr<Response> message(Response::CreateEmpty());
24 MessageWriter writer(message.get());
25 writer.AppendByte(123); // The input is 123.
27 MessageReader reader(message.get());
28 ASSERT_TRUE(reader.HasMoreData()); // Should have data to read.
29 ASSERT_EQ(Message::BYTE, reader.GetDataType());
30 ASSERT_EQ("y", reader.GetDataSignature());
32 bool bool_value = false;
33 // Should fail as the type is not bool here.
34 ASSERT_FALSE(reader.PopBool(&bool_value));
36 uint8_t byte_value = 0;
37 ASSERT_TRUE(reader.PopByte(&byte_value));
38 EXPECT_EQ(123, byte_value); // Should match with the input.
39 ASSERT_FALSE(reader.HasMoreData()); // Should not have more data to read.
41 // Try to get another byte. Should fail.
42 ASSERT_FALSE(reader.PopByte(&byte_value));
45 // Check all basic types can be properly written and read.
46 TEST(MessageTest, AppendAndPopBasicDataTypes) {
47 std::unique_ptr<Response> message(Response::CreateEmpty());
48 MessageWriter writer(message.get());
50 // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path".
52 writer.AppendBool(true);
53 writer.AppendInt16(2);
54 writer.AppendUint16(3);
55 writer.AppendInt32(4);
56 writer.AppendUint32(5);
57 writer.AppendInt64(6);
58 writer.AppendUint64(7);
59 writer.AppendDouble(8.0);
60 writer.AppendString("string");
61 writer.AppendObjectPath(ObjectPath("/object/path"));
63 uint8_t byte_value = 0;
64 bool bool_value = false;
65 int16_t int16_value = 0;
66 uint16_t uint16_value = 0;
67 int32_t int32_value = 0;
68 uint32_t uint32_value = 0;
69 int64_t int64_value = 0;
70 uint64_t uint64_value = 0;
71 double double_value = 0;
72 std::string string_value;
73 ObjectPath object_path_value;
75 MessageReader reader(message.get());
76 ASSERT_TRUE(reader.HasMoreData());
77 ASSERT_EQ("y", reader.GetDataSignature());
78 ASSERT_TRUE(reader.PopByte(&byte_value));
79 ASSERT_EQ("b", reader.GetDataSignature());
80 ASSERT_TRUE(reader.PopBool(&bool_value));
81 ASSERT_EQ("n", reader.GetDataSignature());
82 ASSERT_TRUE(reader.PopInt16(&int16_value));
83 ASSERT_EQ("q", reader.GetDataSignature());
84 ASSERT_TRUE(reader.PopUint16(&uint16_value));
85 ASSERT_EQ("i", reader.GetDataSignature());
86 ASSERT_TRUE(reader.PopInt32(&int32_value));
87 ASSERT_EQ("u", reader.GetDataSignature());
88 ASSERT_TRUE(reader.PopUint32(&uint32_value));
89 ASSERT_EQ("x", reader.GetDataSignature());
90 ASSERT_TRUE(reader.PopInt64(&int64_value));
91 ASSERT_EQ("t", reader.GetDataSignature());
92 ASSERT_TRUE(reader.PopUint64(&uint64_value));
93 ASSERT_EQ("d", reader.GetDataSignature());
94 ASSERT_TRUE(reader.PopDouble(&double_value));
95 ASSERT_EQ("s", reader.GetDataSignature());
96 ASSERT_TRUE(reader.PopString(&string_value));
97 ASSERT_EQ("o", reader.GetDataSignature());
98 ASSERT_TRUE(reader.PopObjectPath(&object_path_value));
99 ASSERT_EQ("", reader.GetDataSignature());
100 ASSERT_FALSE(reader.HasMoreData());
102 // 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path" should be returned.
103 EXPECT_EQ(0, byte_value);
104 EXPECT_EQ(true, bool_value);
105 EXPECT_EQ(2, int16_value);
106 EXPECT_EQ(3U, uint16_value);
107 EXPECT_EQ(4, int32_value);
108 EXPECT_EQ(5U, uint32_value);
109 EXPECT_EQ(6, int64_value);
110 EXPECT_EQ(7U, uint64_value);
111 EXPECT_DOUBLE_EQ(8.0, double_value);
112 EXPECT_EQ("string", string_value);
113 EXPECT_EQ(ObjectPath("/object/path"), object_path_value);
116 // Check all basic types can be properly written and read.
117 TEST(MessageTest, AppendAndPopFileDescriptor) {
118 if (!IsDBusTypeUnixFdSupported()) {
119 LOG(WARNING) << "FD passing is not supported";
123 std::unique_ptr<Response> message(Response::CreateEmpty());
124 MessageWriter writer(message.get());
128 writer.AppendFileDescriptor(fd_in);
130 base::ScopedFD fd_out;
132 MessageReader reader(message.get());
133 ASSERT_TRUE(reader.HasMoreData());
134 ASSERT_EQ(Message::UNIX_FD, reader.GetDataType());
135 ASSERT_EQ("h", reader.GetDataSignature());
136 ASSERT_TRUE(reader.PopFileDescriptor(&fd_out));
137 ASSERT_FALSE(reader.HasMoreData());
139 // Stdout should be returned but we cannot check the descriptor
140 // value because stdout will be dup'd. Instead check st_rdev
141 // which should be identical.
142 struct stat sb_stdout;
143 int status_stdout = HANDLE_EINTR(fstat(fd_in, &sb_stdout));
144 ASSERT_GE(status_stdout, 0);
146 int status_fd = HANDLE_EINTR(fstat(fd_out.get(), &sb_fd));
147 ASSERT_GE(status_fd, 0);
148 EXPECT_EQ(sb_stdout.st_rdev, sb_fd.st_rdev);
151 // Check all variant types can be properly written and read.
152 TEST(MessageTest, AppendAndPopVariantDataTypes) {
153 std::unique_ptr<Response> message(Response::CreateEmpty());
154 MessageWriter writer(message.get());
156 // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path".
157 writer.AppendVariantOfByte(0);
158 writer.AppendVariantOfBool(true);
159 writer.AppendVariantOfInt16(2);
160 writer.AppendVariantOfUint16(3);
161 writer.AppendVariantOfInt32(4);
162 writer.AppendVariantOfUint32(5);
163 writer.AppendVariantOfInt64(6);
164 writer.AppendVariantOfUint64(7);
165 writer.AppendVariantOfDouble(8.0);
166 writer.AppendVariantOfString("string");
167 writer.AppendVariantOfObjectPath(ObjectPath("/object/path"));
169 uint8_t byte_value = 0;
170 bool bool_value = false;
171 int16_t int16_value = 0;
172 uint16_t uint16_value = 0;
173 int32_t int32_value = 0;
174 uint32_t uint32_value = 0;
175 int64_t int64_value = 0;
176 uint64_t uint64_value = 0;
177 double double_value = 0;
178 std::string string_value;
179 ObjectPath object_path_value;
181 MessageReader reader(message.get());
182 ASSERT_TRUE(reader.HasMoreData());
183 ASSERT_EQ("v", reader.GetDataSignature());
184 ASSERT_TRUE(reader.PopVariantOfByte(&byte_value));
185 ASSERT_EQ("v", reader.GetDataSignature());
186 ASSERT_TRUE(reader.PopVariantOfBool(&bool_value));
187 ASSERT_EQ("v", reader.GetDataSignature());
188 ASSERT_TRUE(reader.PopVariantOfInt16(&int16_value));
189 ASSERT_EQ("v", reader.GetDataSignature());
190 ASSERT_TRUE(reader.PopVariantOfUint16(&uint16_value));
191 ASSERT_EQ("v", reader.GetDataSignature());
192 ASSERT_TRUE(reader.PopVariantOfInt32(&int32_value));
193 ASSERT_EQ("v", reader.GetDataSignature());
194 ASSERT_TRUE(reader.PopVariantOfUint32(&uint32_value));
195 ASSERT_EQ("v", reader.GetDataSignature());
196 ASSERT_TRUE(reader.PopVariantOfInt64(&int64_value));
197 ASSERT_EQ("v", reader.GetDataSignature());
198 ASSERT_TRUE(reader.PopVariantOfUint64(&uint64_value));
199 ASSERT_EQ("v", reader.GetDataSignature());
200 ASSERT_TRUE(reader.PopVariantOfDouble(&double_value));
201 ASSERT_EQ("v", reader.GetDataSignature());
202 ASSERT_TRUE(reader.PopVariantOfString(&string_value));
203 ASSERT_EQ("v", reader.GetDataSignature());
204 ASSERT_TRUE(reader.PopVariantOfObjectPath(&object_path_value));
205 ASSERT_EQ("", reader.GetDataSignature());
206 ASSERT_FALSE(reader.HasMoreData());
208 // 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path" should be returned.
209 EXPECT_EQ(0, byte_value);
210 EXPECT_EQ(true, bool_value);
211 EXPECT_EQ(2, int16_value);
212 EXPECT_EQ(3U, uint16_value);
213 EXPECT_EQ(4, int32_value);
214 EXPECT_EQ(5U, uint32_value);
215 EXPECT_EQ(6, int64_value);
216 EXPECT_EQ(7U, uint64_value);
217 EXPECT_DOUBLE_EQ(8.0, double_value);
218 EXPECT_EQ("string", string_value);
219 EXPECT_EQ(ObjectPath("/object/path"), object_path_value);
222 TEST(MessageTest, ArrayOfBytes) {
223 std::unique_ptr<Response> message(Response::CreateEmpty());
224 MessageWriter writer(message.get());
225 std::vector<uint8_t> bytes;
229 writer.AppendArrayOfBytes(bytes.data(), bytes.size());
231 MessageReader reader(message.get());
232 const uint8_t* output_bytes = nullptr;
234 ASSERT_EQ("ay", reader.GetDataSignature());
235 ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length));
236 ASSERT_FALSE(reader.HasMoreData());
237 ASSERT_EQ(3U, length);
238 EXPECT_EQ(1, output_bytes[0]);
239 EXPECT_EQ(2, output_bytes[1]);
240 EXPECT_EQ(3, output_bytes[2]);
243 TEST(MessageTest, ArrayOfInt32s) {
244 std::unique_ptr<Response> message(Response::CreateEmpty());
245 MessageWriter writer(message.get());
246 std::vector<int32_t> int32s;
250 writer.AppendArrayOfInt32s(int32s.data(), int32s.size());
252 MessageReader reader(message.get());
253 const int32_t* output_int32s = nullptr;
255 ASSERT_EQ("ai", reader.GetDataSignature());
256 ASSERT_TRUE(reader.PopArrayOfInt32s(&output_int32s, &length));
257 ASSERT_FALSE(reader.HasMoreData());
258 ASSERT_EQ(3U, length);
259 EXPECT_EQ(1, output_int32s[0]);
260 EXPECT_EQ(2, output_int32s[1]);
261 EXPECT_EQ(3, output_int32s[2]);
264 TEST(MessageTest, ArrayOfUint32s) {
265 std::unique_ptr<Response> message(Response::CreateEmpty());
266 MessageWriter writer(message.get());
267 std::vector<uint32_t> uint32s;
268 uint32s.push_back(1);
269 uint32s.push_back(2);
270 uint32s.push_back(3);
271 writer.AppendArrayOfUint32s(uint32s.data(), uint32s.size());
273 MessageReader reader(message.get());
274 const uint32_t* output_uint32s = nullptr;
276 ASSERT_EQ("au", reader.GetDataSignature());
277 ASSERT_TRUE(reader.PopArrayOfUint32s(&output_uint32s, &length));
278 ASSERT_FALSE(reader.HasMoreData());
279 ASSERT_EQ(3U, length);
280 EXPECT_EQ(1U, output_uint32s[0]);
281 EXPECT_EQ(2U, output_uint32s[1]);
282 EXPECT_EQ(3U, output_uint32s[2]);
285 TEST(MessageTest, ArrayOfDoubles) {
286 std::unique_ptr<Response> message(Response::CreateEmpty());
287 MessageWriter writer(message.get());
288 std::vector<double> doubles;
289 doubles.push_back(0.2);
290 doubles.push_back(0.5);
291 doubles.push_back(1);
292 writer.AppendArrayOfDoubles(doubles.data(), doubles.size());
294 MessageReader reader(message.get());
295 const double* output_doubles = nullptr;
297 ASSERT_EQ("ad", reader.GetDataSignature());
298 ASSERT_TRUE(reader.PopArrayOfDoubles(&output_doubles, &length));
299 ASSERT_FALSE(reader.HasMoreData());
300 ASSERT_EQ(3U, length);
301 EXPECT_EQ(0.2, output_doubles[0]);
302 EXPECT_EQ(0.5, output_doubles[1]);
303 EXPECT_EQ(1, output_doubles[2]);
306 TEST(MessageTest, ArrayOfBytes_Empty) {
307 std::unique_ptr<Response> message(Response::CreateEmpty());
308 MessageWriter writer(message.get());
309 std::vector<uint8_t> bytes;
310 writer.AppendArrayOfBytes(bytes.data(), bytes.size());
312 MessageReader reader(message.get());
313 const uint8_t* output_bytes = nullptr;
315 ASSERT_EQ("ay", reader.GetDataSignature());
316 ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length));
317 ASSERT_FALSE(reader.HasMoreData());
318 ASSERT_EQ(0U, length);
319 EXPECT_EQ(nullptr, output_bytes);
322 TEST(MessageTest, ArrayOfStrings) {
323 std::unique_ptr<Response> message(Response::CreateEmpty());
324 MessageWriter writer(message.get());
325 std::vector<std::string> strings;
326 strings.push_back("fee");
327 strings.push_back("fie");
328 strings.push_back("foe");
329 strings.push_back("fum");
330 writer.AppendArrayOfStrings(strings);
332 MessageReader reader(message.get());
333 std::vector<std::string> output_strings;
334 ASSERT_EQ("as", reader.GetDataSignature());
335 ASSERT_TRUE(reader.PopArrayOfStrings(&output_strings));
336 ASSERT_FALSE(reader.HasMoreData());
337 ASSERT_EQ(4U, output_strings.size());
338 EXPECT_EQ("fee", output_strings[0]);
339 EXPECT_EQ("fie", output_strings[1]);
340 EXPECT_EQ("foe", output_strings[2]);
341 EXPECT_EQ("fum", output_strings[3]);
344 TEST(MessageTest, ArrayOfObjectPaths) {
345 std::unique_ptr<Response> message(Response::CreateEmpty());
346 MessageWriter writer(message.get());
347 std::vector<ObjectPath> object_paths;
348 object_paths.push_back(ObjectPath("/object/path/1"));
349 object_paths.push_back(ObjectPath("/object/path/2"));
350 object_paths.push_back(ObjectPath("/object/path/3"));
351 writer.AppendArrayOfObjectPaths(object_paths);
353 MessageReader reader(message.get());
354 std::vector<ObjectPath> output_object_paths;
355 ASSERT_EQ("ao", reader.GetDataSignature());
356 ASSERT_TRUE(reader.PopArrayOfObjectPaths(&output_object_paths));
357 ASSERT_FALSE(reader.HasMoreData());
358 ASSERT_EQ(3U, output_object_paths.size());
359 EXPECT_EQ(ObjectPath("/object/path/1"), output_object_paths[0]);
360 EXPECT_EQ(ObjectPath("/object/path/2"), output_object_paths[1]);
361 EXPECT_EQ(ObjectPath("/object/path/3"), output_object_paths[2]);
364 TEST(MessageTest, ProtoBuf) {
365 std::unique_ptr<Response> message(Response::CreateEmpty());
366 MessageWriter writer(message.get());
367 TestProto send_message;
368 send_message.set_text("testing");
369 send_message.set_number(123);
370 writer.AppendProtoAsArrayOfBytes(send_message);
372 MessageReader reader(message.get());
373 TestProto receive_message;
374 ASSERT_EQ("ay", reader.GetDataSignature());
375 ASSERT_TRUE(reader.PopArrayOfBytesAsProto(&receive_message));
376 EXPECT_EQ(receive_message.text(), send_message.text());
377 EXPECT_EQ(receive_message.number(), send_message.number());
380 // Test that an array can be properly written and read. We only have this
381 // test for array, as repeating this for other container types is too
383 TEST(MessageTest, OpenArrayAndPopArray) {
384 std::unique_ptr<Response> message(Response::CreateEmpty());
385 MessageWriter writer(message.get());
386 MessageWriter array_writer(nullptr);
387 writer.OpenArray("s", &array_writer); // Open an array of strings.
388 array_writer.AppendString("foo");
389 array_writer.AppendString("bar");
390 array_writer.AppendString("baz");
391 writer.CloseContainer(&array_writer);
393 MessageReader reader(message.get());
394 ASSERT_EQ(Message::ARRAY, reader.GetDataType());
395 ASSERT_EQ("as", reader.GetDataSignature());
396 MessageReader array_reader(nullptr);
397 ASSERT_TRUE(reader.PopArray(&array_reader));
398 ASSERT_FALSE(reader.HasMoreData()); // Should not have more data to read.
400 std::string string_value;
401 ASSERT_TRUE(array_reader.PopString(&string_value));
402 EXPECT_EQ("foo", string_value);
403 ASSERT_TRUE(array_reader.PopString(&string_value));
404 EXPECT_EQ("bar", string_value);
405 ASSERT_TRUE(array_reader.PopString(&string_value));
406 EXPECT_EQ("baz", string_value);
407 // Should not have more data to read.
408 ASSERT_FALSE(array_reader.HasMoreData());
411 // Create a complex message using array, struct, variant, dict entry, and
412 // make sure it can be read properly.
413 TEST(MessageTest, CreateComplexMessageAndReadIt) {
414 std::unique_ptr<Response> message(Response::CreateEmpty());
415 MessageWriter writer(message.get());
417 MessageWriter array_writer(nullptr);
418 // Open an array of variants.
419 writer.OpenArray("v", &array_writer);
421 // The first value in the array.
423 MessageWriter variant_writer(nullptr);
424 // Open a variant of a boolean.
425 array_writer.OpenVariant("b", &variant_writer);
426 variant_writer.AppendBool(true);
427 array_writer.CloseContainer(&variant_writer);
430 // The second value in the array.
432 MessageWriter variant_writer(nullptr);
433 // Open a variant of a struct that contains a string and an int32_t.
434 array_writer.OpenVariant("(si)", &variant_writer);
436 MessageWriter struct_writer(nullptr);
437 variant_writer.OpenStruct(&struct_writer);
438 struct_writer.AppendString("string");
439 struct_writer.AppendInt32(123);
440 variant_writer.CloseContainer(&struct_writer);
442 array_writer.CloseContainer(&variant_writer);
445 // The third value in the array.
447 MessageWriter variant_writer(nullptr);
448 // Open a variant of an array of string-to-int64_t dict entries.
449 array_writer.OpenVariant("a{sx}", &variant_writer);
451 // Opens an array of string-to-int64_t dict entries.
452 MessageWriter dict_array_writer(nullptr);
453 variant_writer.OpenArray("{sx}", &dict_array_writer);
455 // Opens a string-to-int64_t dict entries.
456 MessageWriter dict_entry_writer(nullptr);
457 dict_array_writer.OpenDictEntry(&dict_entry_writer);
458 dict_entry_writer.AppendString("foo");
459 dict_entry_writer.AppendInt64(INT64_C(1234567890123456789));
460 dict_array_writer.CloseContainer(&dict_entry_writer);
462 variant_writer.CloseContainer(&dict_array_writer);
464 array_writer.CloseContainer(&variant_writer);
467 writer.CloseContainer(&array_writer);
469 // What we have created looks like this:
471 "message_type: MESSAGE_METHOD_RETURN\n"
475 " variant bool true\n"
476 " variant struct {\n"
477 " string \"string\"\n"
483 " int64_t 1234567890123456789\n"
487 message->ToString());
489 MessageReader reader(message.get());
490 ASSERT_EQ("av", reader.GetDataSignature());
491 MessageReader array_reader(nullptr);
492 ASSERT_TRUE(reader.PopArray(&array_reader));
494 // The first value in the array.
495 bool bool_value = false;
496 ASSERT_EQ("v", array_reader.GetDataSignature());
497 ASSERT_TRUE(array_reader.PopVariantOfBool(&bool_value));
498 EXPECT_EQ(true, bool_value);
500 // The second value in the array.
502 MessageReader variant_reader(nullptr);
503 ASSERT_TRUE(array_reader.PopVariant(&variant_reader));
505 MessageReader struct_reader(nullptr);
506 ASSERT_EQ("(si)", variant_reader.GetDataSignature());
507 ASSERT_TRUE(variant_reader.PopStruct(&struct_reader));
508 std::string string_value;
509 ASSERT_TRUE(struct_reader.PopString(&string_value));
510 EXPECT_EQ("string", string_value);
511 int32_t int32_value = 0;
512 ASSERT_TRUE(struct_reader.PopInt32(&int32_value));
513 EXPECT_EQ(123, int32_value);
514 ASSERT_FALSE(struct_reader.HasMoreData());
516 ASSERT_FALSE(variant_reader.HasMoreData());
519 // The third value in the array.
521 MessageReader variant_reader(nullptr);
522 ASSERT_TRUE(array_reader.PopVariant(&variant_reader));
524 MessageReader dict_array_reader(nullptr);
525 ASSERT_EQ("a{sx}", variant_reader.GetDataSignature());
526 ASSERT_TRUE(variant_reader.PopArray(&dict_array_reader));
528 MessageReader dict_entry_reader(nullptr);
529 ASSERT_TRUE(dict_array_reader.PopDictEntry(&dict_entry_reader));
530 std::string string_value;
531 ASSERT_TRUE(dict_entry_reader.PopString(&string_value));
532 EXPECT_EQ("foo", string_value);
533 int64_t int64_value = 0;
534 ASSERT_TRUE(dict_entry_reader.PopInt64(&int64_value));
535 EXPECT_EQ(INT64_C(1234567890123456789), int64_value);
537 ASSERT_FALSE(dict_array_reader.HasMoreData());
539 ASSERT_FALSE(variant_reader.HasMoreData());
541 ASSERT_FALSE(array_reader.HasMoreData());
542 ASSERT_FALSE(reader.HasMoreData());
545 TEST(MessageTest, MethodCall) {
546 MethodCall method_call("com.example.Interface", "SomeMethod");
547 EXPECT_NE(nullptr, method_call.raw_message());
548 EXPECT_EQ(Message::MESSAGE_METHOD_CALL, method_call.GetMessageType());
549 EXPECT_EQ("MESSAGE_METHOD_CALL", method_call.GetMessageTypeAsString());
550 method_call.SetDestination("com.example.Service");
551 method_call.SetPath(ObjectPath("/com/example/Object"));
553 MessageWriter writer(&method_call);
554 writer.AppendString("payload");
557 "message_type: MESSAGE_METHOD_CALL\n"
558 "destination: com.example.Service\n"
559 "path: /com/example/Object\n"
560 "interface: com.example.Interface\n"
561 "member: SomeMethod\n"
564 "string \"payload\"\n",
565 method_call.ToString());
568 TEST(MessageTest, MethodCall_FromRawMessage) {
569 DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
570 dbus_message_set_interface(raw_message, "com.example.Interface");
571 dbus_message_set_member(raw_message, "SomeMethod");
573 std::unique_ptr<MethodCall> method_call(
574 MethodCall::FromRawMessage(raw_message));
575 EXPECT_EQ("com.example.Interface", method_call->GetInterface());
576 EXPECT_EQ("SomeMethod", method_call->GetMember());
579 TEST(MessageTest, Signal) {
580 Signal signal("com.example.Interface", "SomeSignal");
581 EXPECT_NE(nullptr, signal.raw_message());
582 EXPECT_EQ(Message::MESSAGE_SIGNAL, signal.GetMessageType());
583 EXPECT_EQ("MESSAGE_SIGNAL", signal.GetMessageTypeAsString());
584 signal.SetPath(ObjectPath("/com/example/Object"));
586 MessageWriter writer(&signal);
587 writer.AppendString("payload");
590 "message_type: MESSAGE_SIGNAL\n"
591 "path: /com/example/Object\n"
592 "interface: com.example.Interface\n"
593 "member: SomeSignal\n"
596 "string \"payload\"\n",
600 TEST(MessageTest, Signal_FromRawMessage) {
601 DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL);
602 dbus_message_set_interface(raw_message, "com.example.Interface");
603 dbus_message_set_member(raw_message, "SomeSignal");
605 std::unique_ptr<Signal> signal(Signal::FromRawMessage(raw_message));
606 EXPECT_EQ("com.example.Interface", signal->GetInterface());
607 EXPECT_EQ("SomeSignal", signal->GetMember());
610 TEST(MessageTest, Response) {
611 std::unique_ptr<Response> response(Response::CreateEmpty());
612 EXPECT_TRUE(response->raw_message());
613 EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType());
614 EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString());
617 TEST(MessageTest, Response_FromMethodCall) {
618 const uint32_t kSerial = 123;
619 MethodCall method_call("com.example.Interface", "SomeMethod");
620 method_call.SetSerial(kSerial);
622 std::unique_ptr<Response> response(Response::FromMethodCall(&method_call));
623 EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType());
624 EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString());
625 // The serial should be copied to the reply serial.
626 EXPECT_EQ(kSerial, response->GetReplySerial());
629 TEST(MessageTest, ErrorResponse_FromMethodCall) {
630 const uint32_t kSerial = 123;
631 const char kErrorMessage[] = "error message";
633 MethodCall method_call("com.example.Interface", "SomeMethod");
634 method_call.SetSerial(kSerial);
636 std::unique_ptr<ErrorResponse> error_response(ErrorResponse::FromMethodCall(
637 &method_call, DBUS_ERROR_FAILED, kErrorMessage));
638 EXPECT_EQ(Message::MESSAGE_ERROR, error_response->GetMessageType());
639 EXPECT_EQ("MESSAGE_ERROR", error_response->GetMessageTypeAsString());
640 // The serial should be copied to the reply serial.
641 EXPECT_EQ(kSerial, error_response->GetReplySerial());
643 // Error message should be added to the payload.
644 MessageReader reader(error_response.get());
645 std::string error_message;
646 ASSERT_TRUE(reader.PopString(&error_message));
647 EXPECT_EQ(kErrorMessage, error_message);
650 TEST(MessageTest, GetAndSetHeaders) {
651 std::unique_ptr<Response> message(Response::CreateEmpty());
653 EXPECT_EQ("", message->GetDestination());
654 EXPECT_EQ(ObjectPath(std::string()), message->GetPath());
655 EXPECT_EQ("", message->GetInterface());
656 EXPECT_EQ("", message->GetMember());
657 EXPECT_EQ("", message->GetErrorName());
658 EXPECT_EQ("", message->GetSender());
659 EXPECT_EQ(0U, message->GetSerial());
660 EXPECT_EQ(0U, message->GetReplySerial());
662 EXPECT_TRUE(message->SetDestination("org.chromium.destination"));
663 EXPECT_TRUE(message->SetPath(ObjectPath("/org/chromium/path")));
664 EXPECT_TRUE(message->SetInterface("org.chromium.interface"));
665 EXPECT_TRUE(message->SetMember("member"));
666 EXPECT_TRUE(message->SetErrorName("org.chromium.error"));
667 EXPECT_TRUE(message->SetSender(":1.2"));
668 message->SetSerial(123);
669 message->SetReplySerial(456);
671 EXPECT_EQ("org.chromium.destination", message->GetDestination());
672 EXPECT_EQ(ObjectPath("/org/chromium/path"), message->GetPath());
673 EXPECT_EQ("org.chromium.interface", message->GetInterface());
674 EXPECT_EQ("member", message->GetMember());
675 EXPECT_EQ("org.chromium.error", message->GetErrorName());
676 EXPECT_EQ(":1.2", message->GetSender());
677 EXPECT_EQ(123U, message->GetSerial());
678 EXPECT_EQ(456U, message->GetReplySerial());
681 TEST(MessageTest, SetInvalidHeaders) {
682 std::unique_ptr<Response> message(Response::CreateEmpty());
683 EXPECT_EQ("", message->GetDestination());
684 EXPECT_EQ(ObjectPath(std::string()), message->GetPath());
685 EXPECT_EQ("", message->GetInterface());
686 EXPECT_EQ("", message->GetMember());
687 EXPECT_EQ("", message->GetErrorName());
688 EXPECT_EQ("", message->GetSender());
690 // Empty element between periods.
691 EXPECT_FALSE(message->SetDestination("org..chromium"));
692 // Trailing '/' is only allowed for the root path.
693 EXPECT_FALSE(message->SetPath(ObjectPath("/org/chromium/")));
694 // Interface name cannot contain '/'.
695 EXPECT_FALSE(message->SetInterface("org/chromium/interface"));
696 // Member name cannot begin with a digit.
697 EXPECT_FALSE(message->SetMember("1member"));
698 // Error name cannot begin with a period.
699 EXPECT_FALSE(message->SetErrorName(".org.chromium.error"));
700 // Disallowed characters.
701 EXPECT_FALSE(message->SetSender("?!#*"));
703 EXPECT_EQ("", message->GetDestination());
704 EXPECT_EQ(ObjectPath(std::string()), message->GetPath());
705 EXPECT_EQ("", message->GetInterface());
706 EXPECT_EQ("", message->GetMember());
707 EXPECT_EQ("", message->GetErrorName());
708 EXPECT_EQ("", message->GetSender());
711 TEST(MessageTest, ToString_LongString) {
712 const std::string kLongString(1000, 'o');
714 std::unique_ptr<Response> message(Response::CreateEmpty());
715 MessageWriter writer(message.get());
716 writer.AppendString(kLongString);
719 "message_type: MESSAGE_METHOD_RETURN\n"
721 "string \"oooooooooooooooooooooooooooooooooooooooooooooooo"
722 "oooooooooooooooooooooooooooooooooooooooooooooooooooo... "
723 "(1000 bytes in total)\"\n",
724 message->ToString());