dbus/message_unittest.cc

   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.
   4
   5 #include "dbus/message.h"
   6
   7 #include <stddef.h>
   8 #include <stdint.h>
   9
  10 #include <memory>
  11
  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"
  17
  18 namespace dbus {
  19
  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.
  26
  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());
  31
  32   bool bool_value = false;
  33   // Should fail as the type is not bool here.
  34   ASSERT_FALSE(reader.PopBool(&bool_value));
  35
  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.
  40
  41   // Try to get another byte. Should fail.
  42   ASSERT_FALSE(reader.PopByte(&byte_value));
  43 }
  44
  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());
  49
  50   // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path".
  51   writer.AppendByte(0);
  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"));
  62
  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;
  74
  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());
 101
 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);
 114 }
 115
 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";
 120     return;
 121   }
 122
 123   std::unique_ptr<Response> message(Response::CreateEmpty());
 124   MessageWriter writer(message.get());
 125
 126   // Append stdout.
 127   const int fd_in = 1;
 128   writer.AppendFileDescriptor(fd_in);
 129
 130   base::ScopedFD fd_out;
 131
 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());
 138
 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);
 145   struct stat sb_fd;
 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);
 149 }
 150
 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());
 155
 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"));
 168
 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;
 180
 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());
 207
 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);
 220 }
 221
 222 TEST(MessageTest, ArrayOfBytes) {
 223   std::unique_ptr<Response> message(Response::CreateEmpty());
 224   MessageWriter writer(message.get());
 225   std::vector<uint8_t> bytes;
 226   bytes.push_back(1);
 227   bytes.push_back(2);
 228   bytes.push_back(3);
 229   writer.AppendArrayOfBytes(bytes.data(), bytes.size());
 230
 231   MessageReader reader(message.get());
 232   const uint8_t* output_bytes = nullptr;
 233   size_t length = 0;
 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]);
 241 }
 242
 243 TEST(MessageTest, ArrayOfInt32s) {
 244   std::unique_ptr<Response> message(Response::CreateEmpty());
 245   MessageWriter writer(message.get());
 246   std::vector<int32_t> int32s;
 247   int32s.push_back(1);
 248   int32s.push_back(2);
 249   int32s.push_back(3);
 250   writer.AppendArrayOfInt32s(int32s.data(), int32s.size());
 251
 252   MessageReader reader(message.get());
 253   const int32_t* output_int32s = nullptr;
 254   size_t length = 0;
 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]);
 262 }
 263
 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());
 272
 273   MessageReader reader(message.get());
 274   const uint32_t* output_uint32s = nullptr;
 275   size_t length = 0;
 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]);
 283 }
 284
 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());
 293
 294   MessageReader reader(message.get());
 295   const double* output_doubles = nullptr;
 296   size_t length = 0;
 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]);
 304 }
 305
 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());
 311
 312   MessageReader reader(message.get());
 313   const uint8_t* output_bytes = nullptr;
 314   size_t length = 0;
 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);
 320 }
 321
 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);
 331
 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]);
 342 }
 343
 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);
 352
 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]);
 362 }
 363
 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);
 371
 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());
 378 }
 379
 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
 382 // redundant.
 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);
 392
 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.
 399
 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());
 409 }
 410
 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());
 416   {
 417     MessageWriter array_writer(nullptr);
 418     // Open an array of variants.
 419     writer.OpenArray("v", &array_writer);
 420     {
 421       // The first value in the array.
 422       {
 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);
 428       }
 429
 430       // The second value in the array.
 431       {
 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);
 435         {
 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);
 441         }
 442         array_writer.CloseContainer(&variant_writer);
 443       }
 444
 445       // The third value in the array.
 446       {
 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);
 450         {
 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);
 454           {
 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);
 461           }
 462           variant_writer.CloseContainer(&dict_array_writer);
 463         }
 464         array_writer.CloseContainer(&variant_writer);
 465       }
 466     }
 467     writer.CloseContainer(&array_writer);
 468   }
 469   // What we have created looks like this:
 470   EXPECT_EQ(
 471       "message_type: MESSAGE_METHOD_RETURN\n"
 472       "signature: av\n"
 473       "\n"
 474       "array [\n"
 475       "  variant     bool true\n"
 476       "  variant     struct {\n"
 477       "      string \"string\"\n"
 478       "      int32_t 123\n"
 479       "    }\n"
 480       "  variant     array [\n"
 481       "      dict entry {\n"
 482       "        string \"foo\"\n"
 483       "        int64_t 1234567890123456789\n"
 484       "      }\n"
 485       "    ]\n"
 486       "]\n",
 487       message->ToString());
 488
 489   MessageReader reader(message.get());
 490   ASSERT_EQ("av", reader.GetDataSignature());
 491   MessageReader array_reader(nullptr);
 492   ASSERT_TRUE(reader.PopArray(&array_reader));
 493
 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);
 499
 500   // The second value in the array.
 501   {
 502     MessageReader variant_reader(nullptr);
 503     ASSERT_TRUE(array_reader.PopVariant(&variant_reader));
 504     {
 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());
 515     }
 516     ASSERT_FALSE(variant_reader.HasMoreData());
 517   }
 518
 519   // The third value in the array.
 520   {
 521     MessageReader variant_reader(nullptr);
 522     ASSERT_TRUE(array_reader.PopVariant(&variant_reader));
 523     {
 524       MessageReader dict_array_reader(nullptr);
 525       ASSERT_EQ("a{sx}", variant_reader.GetDataSignature());
 526       ASSERT_TRUE(variant_reader.PopArray(&dict_array_reader));
 527       {
 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);
 536       }
 537       ASSERT_FALSE(dict_array_reader.HasMoreData());
 538     }
 539     ASSERT_FALSE(variant_reader.HasMoreData());
 540   }
 541   ASSERT_FALSE(array_reader.HasMoreData());
 542   ASSERT_FALSE(reader.HasMoreData());
 543 }
 544
 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"));
 552
 553   MessageWriter writer(&method_call);
 554   writer.AppendString("payload");
 555
 556   EXPECT_EQ(
 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"
 562       "signature: s\n"
 563       "\n"
 564       "string \"payload\"\n",
 565       method_call.ToString());
 566 }
 567
 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");
 572
 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());
 577 }
 578
 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"));
 585
 586   MessageWriter writer(&signal);
 587   writer.AppendString("payload");
 588
 589   EXPECT_EQ(
 590       "message_type: MESSAGE_SIGNAL\n"
 591       "path: /com/example/Object\n"
 592       "interface: com.example.Interface\n"
 593       "member: SomeSignal\n"
 594       "signature: s\n"
 595       "\n"
 596       "string \"payload\"\n",
 597       signal.ToString());
 598 }
 599
 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");
 604
 605   std::unique_ptr<Signal> signal(Signal::FromRawMessage(raw_message));
 606   EXPECT_EQ("com.example.Interface", signal->GetInterface());
 607   EXPECT_EQ("SomeSignal", signal->GetMember());
 608 }
 609
 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());
 615 }
 616
 617 TEST(MessageTest, Response_FromMethodCall) {
 618   const uint32_t kSerial = 123;
 619   MethodCall method_call("com.example.Interface", "SomeMethod");
 620   method_call.SetSerial(kSerial);
 621
 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());
 627 }
 628
 629 TEST(MessageTest, ErrorResponse_FromMethodCall) {
 630   const uint32_t kSerial = 123;
 631   const char kErrorMessage[] = "error message";
 632
 633   MethodCall method_call("com.example.Interface", "SomeMethod");
 634   method_call.SetSerial(kSerial);
 635
 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());
 642
 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);
 648 }
 649
 650 TEST(MessageTest, GetAndSetHeaders) {
 651   std::unique_ptr<Response> message(Response::CreateEmpty());
 652
 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());
 661
 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);
 670
 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());
 679 }
 680
 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());
 689
 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("?!#*"));
 702
 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());
 709 }
 710
 711 TEST(MessageTest, ToString_LongString) {
 712   const std::string kLongString(1000, 'o');
 713
 714   std::unique_ptr<Response> message(Response::CreateEmpty());
 715   MessageWriter writer(message.get());
 716   writer.AppendString(kLongString);
 717
 718   ASSERT_EQ(
 719       "message_type: MESSAGE_METHOD_RETURN\n"
 720       "signature: s\n\n"
 721       "string \"oooooooooooooooooooooooooooooooooooooooooooooooo"
 722       "oooooooooooooooooooooooooooooooooooooooooooooooooooo... "
 723       "(1000 bytes in total)\"\n",
 724       message->ToString());
 725 }
 726
 727 }  // namespace dbus