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