message_unittest.cc revision a1401311d1ab56c4ed0a474bd38c108f75cb0cd9 
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
15namespace 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.
19TEST(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.
42TEST(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.
101TEST(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.
143TEST(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
201TEST(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  const 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
221TEST(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  const 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
236TEST(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
257TEST(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
276TEST(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.
295TEST(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.
324TEST(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
451TEST(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
473TEST(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
483TEST(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
503TEST(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
513TEST(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
520TEST(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
533TEST(MessageTest, ErrorResponse_FromMethodCall) {
534  const uint32 kSerial = 123;
535const 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
556TEST(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
587TEST(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
617TEST(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