1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "dbus/message.h" 6 7 #include "base/basictypes.h" 8 #include "base/logging.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "base/posix/eintr_wrapper.h" 11 #include "dbus/object_path.h" 12 #include "dbus/test_proto.pb.h" 13 #include "testing/gtest/include/gtest/gtest.h" 14 15 namespace dbus { 16 17 // Test that a byte can be properly written and read. We only have this 18 // test for byte, as repeating this for other basic types is too redundant. 19 TEST(MessageTest, AppendAndPopByte) { 20 scoped_ptr<Response> message(Response::CreateEmpty()); 21 MessageWriter writer(message.get()); 22 writer.AppendByte(123); // The input is 123. 23 24 MessageReader reader(message.get()); 25 ASSERT_TRUE(reader.HasMoreData()); // Should have data to read. 26 ASSERT_EQ(Message::BYTE, reader.GetDataType()); 27 ASSERT_EQ("y", reader.GetDataSignature()); 28 29 bool bool_value = false; 30 // Should fail as the type is not bool here. 31 ASSERT_FALSE(reader.PopBool(&bool_value)); 32 33 uint8 byte_value = 0; 34 ASSERT_TRUE(reader.PopByte(&byte_value)); 35 EXPECT_EQ(123, byte_value); // Should match with the input. 36 ASSERT_FALSE(reader.HasMoreData()); // Should not have more data to read. 37 38 // Try to get another byte. Should fail. 39 ASSERT_FALSE(reader.PopByte(&byte_value)); 40 } 41 42 // Check all basic types can be properly written and read. 43 TEST(MessageTest, AppendAndPopBasicDataTypes) { 44 scoped_ptr<Response> message(Response::CreateEmpty()); 45 MessageWriter writer(message.get()); 46 47 // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path". 48 writer.AppendByte(0); 49 writer.AppendBool(true); 50 writer.AppendInt16(2); 51 writer.AppendUint16(3); 52 writer.AppendInt32(4); 53 writer.AppendUint32(5); 54 writer.AppendInt64(6); 55 writer.AppendUint64(7); 56 writer.AppendDouble(8.0); 57 writer.AppendString("string"); 58 writer.AppendObjectPath(ObjectPath("/object/path")); 59 60 uint8 byte_value = 0; 61 bool bool_value = false; 62 int16 int16_value = 0; 63 uint16 uint16_value = 0; 64 int32 int32_value = 0; 65 uint32 uint32_value = 0; 66 int64 int64_value = 0; 67 uint64 uint64_value = 0; 68 double double_value = 0; 69 std::string string_value; 70 ObjectPath object_path_value; 71 72 MessageReader reader(message.get()); 73 ASSERT_TRUE(reader.HasMoreData()); 74 ASSERT_EQ("y", reader.GetDataSignature()); 75 ASSERT_TRUE(reader.PopByte(&byte_value)); 76 ASSERT_EQ("b", reader.GetDataSignature()); 77 ASSERT_TRUE(reader.PopBool(&bool_value)); 78 ASSERT_EQ("n", reader.GetDataSignature()); 79 ASSERT_TRUE(reader.PopInt16(&int16_value)); 80 ASSERT_EQ("q", reader.GetDataSignature()); 81 ASSERT_TRUE(reader.PopUint16(&uint16_value)); 82 ASSERT_EQ("i", reader.GetDataSignature()); 83 ASSERT_TRUE(reader.PopInt32(&int32_value)); 84 ASSERT_EQ("u", reader.GetDataSignature()); 85 ASSERT_TRUE(reader.PopUint32(&uint32_value)); 86 ASSERT_EQ("x", reader.GetDataSignature()); 87 ASSERT_TRUE(reader.PopInt64(&int64_value)); 88 ASSERT_EQ("t", reader.GetDataSignature()); 89 ASSERT_TRUE(reader.PopUint64(&uint64_value)); 90 ASSERT_EQ("d", reader.GetDataSignature()); 91 ASSERT_TRUE(reader.PopDouble(&double_value)); 92 ASSERT_EQ("s", reader.GetDataSignature()); 93 ASSERT_TRUE(reader.PopString(&string_value)); 94 ASSERT_EQ("o", reader.GetDataSignature()); 95 ASSERT_TRUE(reader.PopObjectPath(&object_path_value)); 96 ASSERT_EQ("", reader.GetDataSignature()); 97 ASSERT_FALSE(reader.HasMoreData()); 98 99 // 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path" should be returned. 100 EXPECT_EQ(0, byte_value); 101 EXPECT_EQ(true, bool_value); 102 EXPECT_EQ(2, int16_value); 103 EXPECT_EQ(3U, uint16_value); 104 EXPECT_EQ(4, int32_value); 105 EXPECT_EQ(5U, uint32_value); 106 EXPECT_EQ(6, int64_value); 107 EXPECT_EQ(7U, uint64_value); 108 EXPECT_DOUBLE_EQ(8.0, double_value); 109 EXPECT_EQ("string", string_value); 110 EXPECT_EQ(ObjectPath("/object/path"), object_path_value); 111 } 112 113 // Check all basic types can be properly written and read. 114 TEST(MessageTest, AppendAndPopFileDescriptor) { 115 if (!IsDBusTypeUnixFdSupported()) { 116 LOG(WARNING) << "FD passing is not supported"; 117 return; 118 } 119 120 scoped_ptr<Response> message(Response::CreateEmpty()); 121 MessageWriter writer(message.get()); 122 123 // Append stdout. 124 FileDescriptor temp(1); 125 // Descriptor should not be valid until checked. 126 ASSERT_FALSE(temp.is_valid()); 127 // NB: thread IO requirements not relevant for unit tests. 128 temp.CheckValidity(); 129 ASSERT_TRUE(temp.is_valid()); 130 writer.AppendFileDescriptor(temp); 131 132 FileDescriptor fd_value; 133 134 MessageReader reader(message.get()); 135 ASSERT_TRUE(reader.HasMoreData()); 136 ASSERT_EQ(Message::UNIX_FD, reader.GetDataType()); 137 ASSERT_EQ("h", reader.GetDataSignature()); 138 ASSERT_TRUE(reader.PopFileDescriptor(&fd_value)); 139 ASSERT_FALSE(reader.HasMoreData()); 140 // Descriptor is not valid until explicitly checked. 141 ASSERT_FALSE(fd_value.is_valid()); 142 fd_value.CheckValidity(); 143 ASSERT_TRUE(fd_value.is_valid()); 144 145 // Stdout should be returned but we cannot check the descriptor 146 // value because stdout will be dup'd. Instead check st_rdev 147 // which should be identical. 148 struct stat sb_stdout; 149 int status_stdout = HANDLE_EINTR(fstat(1, &sb_stdout)); 150 ASSERT_GE(status_stdout, 0); 151 struct stat sb_fd; 152 int status_fd = HANDLE_EINTR(fstat(fd_value.value(), &sb_fd)); 153 ASSERT_GE(status_fd, 0); 154 EXPECT_EQ(sb_stdout.st_rdev, sb_fd.st_rdev); 155 } 156 157 // Check all variant types can be properly written and read. 158 TEST(MessageTest, AppendAndPopVariantDataTypes) { 159 scoped_ptr<Response> message(Response::CreateEmpty()); 160 MessageWriter writer(message.get()); 161 162 // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path". 163 writer.AppendVariantOfByte(0); 164 writer.AppendVariantOfBool(true); 165 writer.AppendVariantOfInt16(2); 166 writer.AppendVariantOfUint16(3); 167 writer.AppendVariantOfInt32(4); 168 writer.AppendVariantOfUint32(5); 169 writer.AppendVariantOfInt64(6); 170 writer.AppendVariantOfUint64(7); 171 writer.AppendVariantOfDouble(8.0); 172 writer.AppendVariantOfString("string"); 173 writer.AppendVariantOfObjectPath(ObjectPath("/object/path")); 174 175 uint8 byte_value = 0; 176 bool bool_value = false; 177 int16 int16_value = 0; 178 uint16 uint16_value = 0; 179 int32 int32_value = 0; 180 uint32 uint32_value = 0; 181 int64 int64_value = 0; 182 uint64 uint64_value = 0; 183 double double_value = 0; 184 std::string string_value; 185 ObjectPath object_path_value; 186 187 MessageReader reader(message.get()); 188 ASSERT_TRUE(reader.HasMoreData()); 189 ASSERT_EQ("v", reader.GetDataSignature()); 190 ASSERT_TRUE(reader.PopVariantOfByte(&byte_value)); 191 ASSERT_EQ("v", reader.GetDataSignature()); 192 ASSERT_TRUE(reader.PopVariantOfBool(&bool_value)); 193 ASSERT_EQ("v", reader.GetDataSignature()); 194 ASSERT_TRUE(reader.PopVariantOfInt16(&int16_value)); 195 ASSERT_EQ("v", reader.GetDataSignature()); 196 ASSERT_TRUE(reader.PopVariantOfUint16(&uint16_value)); 197 ASSERT_EQ("v", reader.GetDataSignature()); 198 ASSERT_TRUE(reader.PopVariantOfInt32(&int32_value)); 199 ASSERT_EQ("v", reader.GetDataSignature()); 200 ASSERT_TRUE(reader.PopVariantOfUint32(&uint32_value)); 201 ASSERT_EQ("v", reader.GetDataSignature()); 202 ASSERT_TRUE(reader.PopVariantOfInt64(&int64_value)); 203 ASSERT_EQ("v", reader.GetDataSignature()); 204 ASSERT_TRUE(reader.PopVariantOfUint64(&uint64_value)); 205 ASSERT_EQ("v", reader.GetDataSignature()); 206 ASSERT_TRUE(reader.PopVariantOfDouble(&double_value)); 207 ASSERT_EQ("v", reader.GetDataSignature()); 208 ASSERT_TRUE(reader.PopVariantOfString(&string_value)); 209 ASSERT_EQ("v", reader.GetDataSignature()); 210 ASSERT_TRUE(reader.PopVariantOfObjectPath(&object_path_value)); 211 ASSERT_EQ("", reader.GetDataSignature()); 212 ASSERT_FALSE(reader.HasMoreData()); 213 214 // 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path" should be returned. 215 EXPECT_EQ(0, byte_value); 216 EXPECT_EQ(true, bool_value); 217 EXPECT_EQ(2, int16_value); 218 EXPECT_EQ(3U, uint16_value); 219 EXPECT_EQ(4, int32_value); 220 EXPECT_EQ(5U, uint32_value); 221 EXPECT_EQ(6, int64_value); 222 EXPECT_EQ(7U, uint64_value); 223 EXPECT_DOUBLE_EQ(8.0, double_value); 224 EXPECT_EQ("string", string_value); 225 EXPECT_EQ(ObjectPath("/object/path"), object_path_value); 226 } 227 228 TEST(MessageTest, ArrayOfBytes) { 229 scoped_ptr<Response> message(Response::CreateEmpty()); 230 MessageWriter writer(message.get()); 231 std::vector<uint8> bytes; 232 bytes.push_back(1); 233 bytes.push_back(2); 234 bytes.push_back(3); 235 writer.AppendArrayOfBytes(bytes.data(), bytes.size()); 236 237 MessageReader reader(message.get()); 238 const uint8* output_bytes = NULL; 239 size_t length = 0; 240 ASSERT_EQ("ay", reader.GetDataSignature()); 241 ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length)); 242 ASSERT_FALSE(reader.HasMoreData()); 243 ASSERT_EQ(3U, length); 244 EXPECT_EQ(1, output_bytes[0]); 245 EXPECT_EQ(2, output_bytes[1]); 246 EXPECT_EQ(3, output_bytes[2]); 247 } 248 249 TEST(MessageTest, ArrayOfBytes_Empty) { 250 scoped_ptr<Response> message(Response::CreateEmpty()); 251 MessageWriter writer(message.get()); 252 std::vector<uint8> bytes; 253 writer.AppendArrayOfBytes(bytes.data(), bytes.size()); 254 255 MessageReader reader(message.get()); 256 const uint8* output_bytes = NULL; 257 size_t length = 0; 258 ASSERT_EQ("ay", reader.GetDataSignature()); 259 ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length)); 260 ASSERT_FALSE(reader.HasMoreData()); 261 ASSERT_EQ(0U, length); 262 EXPECT_EQ(NULL, output_bytes); 263 } 264 265 TEST(MessageTest, ArrayOfStrings) { 266 scoped_ptr<Response> message(Response::CreateEmpty()); 267 MessageWriter writer(message.get()); 268 std::vector<std::string> strings; 269 strings.push_back("fee"); 270 strings.push_back("fie"); 271 strings.push_back("foe"); 272 strings.push_back("fum"); 273 writer.AppendArrayOfStrings(strings); 274 275 MessageReader reader(message.get()); 276 std::vector<std::string> output_strings; 277 ASSERT_EQ("as", reader.GetDataSignature()); 278 ASSERT_TRUE(reader.PopArrayOfStrings(&output_strings)); 279 ASSERT_FALSE(reader.HasMoreData()); 280 ASSERT_EQ(4U, output_strings.size()); 281 EXPECT_EQ("fee", output_strings[0]); 282 EXPECT_EQ("fie", output_strings[1]); 283 EXPECT_EQ("foe", output_strings[2]); 284 EXPECT_EQ("fum", output_strings[3]); 285 } 286 287 TEST(MessageTest, ArrayOfObjectPaths) { 288 scoped_ptr<Response> message(Response::CreateEmpty()); 289 MessageWriter writer(message.get()); 290 std::vector<ObjectPath> object_paths; 291 object_paths.push_back(ObjectPath("/object/path/1")); 292 object_paths.push_back(ObjectPath("/object/path/2")); 293 object_paths.push_back(ObjectPath("/object/path/3")); 294 writer.AppendArrayOfObjectPaths(object_paths); 295 296 MessageReader reader(message.get()); 297 std::vector<ObjectPath> output_object_paths; 298 ASSERT_EQ("ao", reader.GetDataSignature()); 299 ASSERT_TRUE(reader.PopArrayOfObjectPaths(&output_object_paths)); 300 ASSERT_FALSE(reader.HasMoreData()); 301 ASSERT_EQ(3U, output_object_paths.size()); 302 EXPECT_EQ(ObjectPath("/object/path/1"), output_object_paths[0]); 303 EXPECT_EQ(ObjectPath("/object/path/2"), output_object_paths[1]); 304 EXPECT_EQ(ObjectPath("/object/path/3"), output_object_paths[2]); 305 } 306 307 TEST(MessageTest, ProtoBuf) { 308 scoped_ptr<Response> message(Response::CreateEmpty()); 309 MessageWriter writer(message.get()); 310 TestProto send_message; 311 send_message.set_text("testing"); 312 send_message.set_number(123); 313 writer.AppendProtoAsArrayOfBytes(send_message); 314 315 MessageReader reader(message.get()); 316 TestProto receive_message; 317 ASSERT_EQ("ay", reader.GetDataSignature()); 318 ASSERT_TRUE(reader.PopArrayOfBytesAsProto(&receive_message)); 319 EXPECT_EQ(receive_message.text(), send_message.text()); 320 EXPECT_EQ(receive_message.number(), send_message.number()); 321 } 322 323 324 // Test that an array can be properly written and read. We only have this 325 // test for array, as repeating this for other container types is too 326 // redundant. 327 TEST(MessageTest, OpenArrayAndPopArray) { 328 scoped_ptr<Response> message(Response::CreateEmpty()); 329 MessageWriter writer(message.get()); 330 MessageWriter array_writer(NULL); 331 writer.OpenArray("s", &array_writer); // Open an array of strings. 332 array_writer.AppendString("foo"); 333 array_writer.AppendString("bar"); 334 array_writer.AppendString("baz"); 335 writer.CloseContainer(&array_writer); 336 337 MessageReader reader(message.get()); 338 ASSERT_EQ(Message::ARRAY, reader.GetDataType()); 339 ASSERT_EQ("as", reader.GetDataSignature()); 340 MessageReader array_reader(NULL); 341 ASSERT_TRUE(reader.PopArray(&array_reader)); 342 ASSERT_FALSE(reader.HasMoreData()); // Should not have more data to read. 343 344 std::string string_value; 345 ASSERT_TRUE(array_reader.PopString(&string_value)); 346 EXPECT_EQ("foo", string_value); 347 ASSERT_TRUE(array_reader.PopString(&string_value)); 348 EXPECT_EQ("bar", string_value); 349 ASSERT_TRUE(array_reader.PopString(&string_value)); 350 EXPECT_EQ("baz", string_value); 351 // Should not have more data to read. 352 ASSERT_FALSE(array_reader.HasMoreData()); 353 } 354 355 // Create a complex message using array, struct, variant, dict entry, and 356 // make sure it can be read properly. 357 TEST(MessageTest, CreateComplexMessageAndReadIt) { 358 scoped_ptr<Response> message(Response::CreateEmpty()); 359 MessageWriter writer(message.get()); 360 { 361 MessageWriter array_writer(NULL); 362 // Open an array of variants. 363 writer.OpenArray("v", &array_writer); 364 { 365 // The first value in the array. 366 { 367 MessageWriter variant_writer(NULL); 368 // Open a variant of a boolean. 369 array_writer.OpenVariant("b", &variant_writer); 370 variant_writer.AppendBool(true); 371 array_writer.CloseContainer(&variant_writer); 372 } 373 374 // The second value in the array. 375 { 376 MessageWriter variant_writer(NULL); 377 // Open a variant of a struct that contains a string and an int32. 378 array_writer.OpenVariant("(si)", &variant_writer); 379 { 380 MessageWriter struct_writer(NULL); 381 variant_writer.OpenStruct(&struct_writer); 382 struct_writer.AppendString("string"); 383 struct_writer.AppendInt32(123); 384 variant_writer.CloseContainer(&struct_writer); 385 } 386 array_writer.CloseContainer(&variant_writer); 387 } 388 389 // The third value in the array. 390 { 391 MessageWriter variant_writer(NULL); 392 // Open a variant of an array of string-to-int64 dict entries. 393 array_writer.OpenVariant("a{sx}", &variant_writer); 394 { 395 // Opens an array of string-to-int64 dict entries. 396 MessageWriter dict_array_writer(NULL); 397 variant_writer.OpenArray("{sx}", &dict_array_writer); 398 { 399 // Opens a string-to-int64 dict entries. 400 MessageWriter dict_entry_writer(NULL); 401 dict_array_writer.OpenDictEntry(&dict_entry_writer); 402 dict_entry_writer.AppendString("foo"); 403 dict_entry_writer.AppendInt64(GG_INT64_C(1234567890123456789)); 404 dict_array_writer.CloseContainer(&dict_entry_writer); 405 } 406 variant_writer.CloseContainer(&dict_array_writer); 407 } 408 array_writer.CloseContainer(&variant_writer); 409 } 410 } 411 writer.CloseContainer(&array_writer); 412 } 413 // What we have created looks like this: 414 EXPECT_EQ("message_type: MESSAGE_METHOD_RETURN\n" 415 "signature: av\n" 416 "\n" 417 "array [\n" 418 " variant bool true\n" 419 " variant struct {\n" 420 " string \"string\"\n" 421 " int32 123\n" 422 " }\n" 423 " variant array [\n" 424 " dict entry {\n" 425 " string \"foo\"\n" 426 " int64 1234567890123456789\n" 427 " }\n" 428 " ]\n" 429 "]\n", 430 message->ToString()); 431 432 MessageReader reader(message.get()); 433 ASSERT_EQ("av", reader.GetDataSignature()); 434 MessageReader array_reader(NULL); 435 ASSERT_TRUE(reader.PopArray(&array_reader)); 436 437 // The first value in the array. 438 bool bool_value = false; 439 ASSERT_EQ("v", array_reader.GetDataSignature()); 440 ASSERT_TRUE(array_reader.PopVariantOfBool(&bool_value)); 441 EXPECT_EQ(true, bool_value); 442 443 // The second value in the array. 444 { 445 MessageReader variant_reader(NULL); 446 ASSERT_TRUE(array_reader.PopVariant(&variant_reader)); 447 { 448 MessageReader struct_reader(NULL); 449 ASSERT_EQ("(si)", variant_reader.GetDataSignature()); 450 ASSERT_TRUE(variant_reader.PopStruct(&struct_reader)); 451 std::string string_value; 452 ASSERT_TRUE(struct_reader.PopString(&string_value)); 453 EXPECT_EQ("string", string_value); 454 int32 int32_value = 0; 455 ASSERT_TRUE(struct_reader.PopInt32(&int32_value)); 456 EXPECT_EQ(123, int32_value); 457 ASSERT_FALSE(struct_reader.HasMoreData()); 458 } 459 ASSERT_FALSE(variant_reader.HasMoreData()); 460 } 461 462 // The third value in the array. 463 { 464 MessageReader variant_reader(NULL); 465 ASSERT_TRUE(array_reader.PopVariant(&variant_reader)); 466 { 467 MessageReader dict_array_reader(NULL); 468 ASSERT_EQ("a{sx}", variant_reader.GetDataSignature()); 469 ASSERT_TRUE(variant_reader.PopArray(&dict_array_reader)); 470 { 471 MessageReader dict_entry_reader(NULL); 472 ASSERT_TRUE(dict_array_reader.PopDictEntry(&dict_entry_reader)); 473 std::string string_value; 474 ASSERT_TRUE(dict_entry_reader.PopString(&string_value)); 475 EXPECT_EQ("foo", string_value); 476 int64 int64_value = 0; 477 ASSERT_TRUE(dict_entry_reader.PopInt64(&int64_value)); 478 EXPECT_EQ(GG_INT64_C(1234567890123456789), int64_value); 479 } 480 ASSERT_FALSE(dict_array_reader.HasMoreData()); 481 } 482 ASSERT_FALSE(variant_reader.HasMoreData()); 483 } 484 ASSERT_FALSE(array_reader.HasMoreData()); 485 ASSERT_FALSE(reader.HasMoreData()); 486 } 487 488 TEST(MessageTest, MethodCall) { 489 MethodCall method_call("com.example.Interface", "SomeMethod"); 490 EXPECT_TRUE(method_call.raw_message() != NULL); 491 EXPECT_EQ(Message::MESSAGE_METHOD_CALL, method_call.GetMessageType()); 492 EXPECT_EQ("MESSAGE_METHOD_CALL", method_call.GetMessageTypeAsString()); 493 method_call.SetDestination("com.example.Service"); 494 method_call.SetPath(ObjectPath("/com/example/Object")); 495 496 MessageWriter writer(&method_call); 497 writer.AppendString("payload"); 498 499 EXPECT_EQ("message_type: MESSAGE_METHOD_CALL\n" 500 "destination: com.example.Service\n" 501 "path: /com/example/Object\n" 502 "interface: com.example.Interface\n" 503 "member: SomeMethod\n" 504 "signature: s\n" 505 "\n" 506 "string \"payload\"\n", 507 method_call.ToString()); 508 } 509 510 TEST(MessageTest, MethodCall_FromRawMessage) { 511 DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL); 512 dbus_message_set_interface(raw_message, "com.example.Interface"); 513 dbus_message_set_member(raw_message, "SomeMethod"); 514 515 scoped_ptr<MethodCall> method_call(MethodCall::FromRawMessage(raw_message)); 516 EXPECT_EQ("com.example.Interface", method_call->GetInterface()); 517 EXPECT_EQ("SomeMethod", method_call->GetMember()); 518 } 519 520 TEST(MessageTest, Signal) { 521 Signal signal("com.example.Interface", "SomeSignal"); 522 EXPECT_TRUE(signal.raw_message() != NULL); 523 EXPECT_EQ(Message::MESSAGE_SIGNAL, signal.GetMessageType()); 524 EXPECT_EQ("MESSAGE_SIGNAL", signal.GetMessageTypeAsString()); 525 signal.SetPath(ObjectPath("/com/example/Object")); 526 527 MessageWriter writer(&signal); 528 writer.AppendString("payload"); 529 530 EXPECT_EQ("message_type: MESSAGE_SIGNAL\n" 531 "path: /com/example/Object\n" 532 "interface: com.example.Interface\n" 533 "member: SomeSignal\n" 534 "signature: s\n" 535 "\n" 536 "string \"payload\"\n", 537 signal.ToString()); 538 } 539 540 TEST(MessageTest, Signal_FromRawMessage) { 541 DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL); 542 dbus_message_set_interface(raw_message, "com.example.Interface"); 543 dbus_message_set_member(raw_message, "SomeSignal"); 544 545 scoped_ptr<Signal> signal(Signal::FromRawMessage(raw_message)); 546 EXPECT_EQ("com.example.Interface", signal->GetInterface()); 547 EXPECT_EQ("SomeSignal", signal->GetMember()); 548 } 549 550 TEST(MessageTest, Response) { 551 scoped_ptr<Response> response(Response::CreateEmpty()); 552 EXPECT_TRUE(response->raw_message()); 553 EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType()); 554 EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString()); 555 } 556 557 TEST(MessageTest, Response_FromMethodCall) { 558 const uint32 kSerial = 123; 559 MethodCall method_call("com.example.Interface", "SomeMethod"); 560 method_call.SetSerial(kSerial); 561 562 scoped_ptr<Response> response( 563 Response::FromMethodCall(&method_call)); 564 EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType()); 565 EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString()); 566 // The serial should be copied to the reply serial. 567 EXPECT_EQ(kSerial, response->GetReplySerial()); 568 } 569 570 TEST(MessageTest, ErrorResponse_FromMethodCall) { 571 const uint32 kSerial = 123; 572 const char kErrorMessage[] = "error message"; 573 574 MethodCall method_call("com.example.Interface", "SomeMethod"); 575 method_call.SetSerial(kSerial); 576 577 scoped_ptr<ErrorResponse> error_response( 578 ErrorResponse::FromMethodCall(&method_call, 579 DBUS_ERROR_FAILED, 580 kErrorMessage)); 581 EXPECT_EQ(Message::MESSAGE_ERROR, error_response->GetMessageType()); 582 EXPECT_EQ("MESSAGE_ERROR", error_response->GetMessageTypeAsString()); 583 // The serial should be copied to the reply serial. 584 EXPECT_EQ(kSerial, error_response->GetReplySerial()); 585 586 // Error message should be added to the payload. 587 MessageReader reader(error_response.get()); 588 std::string error_message; 589 ASSERT_TRUE(reader.PopString(&error_message)); 590 EXPECT_EQ(kErrorMessage, error_message); 591 } 592 593 TEST(MessageTest, GetAndSetHeaders) { 594 scoped_ptr<Response> message(Response::CreateEmpty()); 595 596 EXPECT_EQ("", message->GetDestination()); 597 EXPECT_EQ(ObjectPath(std::string()), message->GetPath()); 598 EXPECT_EQ("", message->GetInterface()); 599 EXPECT_EQ("", message->GetMember()); 600 EXPECT_EQ("", message->GetErrorName()); 601 EXPECT_EQ("", message->GetSender()); 602 EXPECT_EQ(0U, message->GetSerial()); 603 EXPECT_EQ(0U, message->GetReplySerial()); 604 605 EXPECT_TRUE(message->SetDestination("org.chromium.destination")); 606 EXPECT_TRUE(message->SetPath(ObjectPath("/org/chromium/path"))); 607 EXPECT_TRUE(message->SetInterface("org.chromium.interface")); 608 EXPECT_TRUE(message->SetMember("member")); 609 EXPECT_TRUE(message->SetErrorName("org.chromium.error")); 610 EXPECT_TRUE(message->SetSender(":1.2")); 611 message->SetSerial(123); 612 message->SetReplySerial(456); 613 614 EXPECT_EQ("org.chromium.destination", message->GetDestination()); 615 EXPECT_EQ(ObjectPath("/org/chromium/path"), message->GetPath()); 616 EXPECT_EQ("org.chromium.interface", message->GetInterface()); 617 EXPECT_EQ("member", message->GetMember()); 618 EXPECT_EQ("org.chromium.error", message->GetErrorName()); 619 EXPECT_EQ(":1.2", message->GetSender()); 620 EXPECT_EQ(123U, message->GetSerial()); 621 EXPECT_EQ(456U, message->GetReplySerial()); 622 } 623 624 TEST(MessageTest, SetInvalidHeaders) { 625 scoped_ptr<Response> message(Response::CreateEmpty()); 626 EXPECT_EQ("", message->GetDestination()); 627 EXPECT_EQ(ObjectPath(std::string()), message->GetPath()); 628 EXPECT_EQ("", message->GetInterface()); 629 EXPECT_EQ("", message->GetMember()); 630 EXPECT_EQ("", message->GetErrorName()); 631 EXPECT_EQ("", message->GetSender()); 632 633 // Empty element between periods. 634 EXPECT_FALSE(message->SetDestination("org..chromium")); 635 // Trailing '/' is only allowed for the root path. 636 EXPECT_FALSE(message->SetPath(ObjectPath("/org/chromium/"))); 637 // Interface name cannot contain '/'. 638 EXPECT_FALSE(message->SetInterface("org/chromium/interface")); 639 // Member name cannot begin with a digit. 640 EXPECT_FALSE(message->SetMember("1member")); 641 // Error name cannot begin with a period. 642 EXPECT_FALSE(message->SetErrorName(".org.chromium.error")); 643 // Disallowed characters. 644 EXPECT_FALSE(message->SetSender("?!#*")); 645 646 EXPECT_EQ("", message->GetDestination()); 647 EXPECT_EQ(ObjectPath(std::string()), message->GetPath()); 648 EXPECT_EQ("", message->GetInterface()); 649 EXPECT_EQ("", message->GetMember()); 650 EXPECT_EQ("", message->GetErrorName()); 651 EXPECT_EQ("", message->GetSender()); 652 } 653 654 TEST(MessageTest, ToString_LongString) { 655 const std::string kLongString(1000, 'o'); 656 657 scoped_ptr<Response> message(Response::CreateEmpty()); 658 MessageWriter writer(message.get()); 659 writer.AppendString(kLongString); 660 661 ASSERT_EQ("message_type: MESSAGE_METHOD_RETURN\n" 662 "signature: s\n\n" 663 "string \"oooooooooooooooooooooooooooooooooooooooooooooooo" 664 "oooooooooooooooooooooooooooooooooooooooooooooooooooo... " 665 "(1000 bytes in total)\"\n", 666 message->ToString()); 667 } 668 669 } // namespace dbus 670
