Add utility functions to Message classes.

dbus/message_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "dbus/message.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Test that a byte can be properly written and read. We only have this
 // test for byte, as repeating this for other basic types is too redundant.
 TEST(MessageTest, AppendAndPopByte) {
   dbus::Message message;
   message.reset_raw_message(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL));
   dbus::MessageWriter writer(&message);
   writer.AppendByte(123);  // The input is 123.
 
@@ skipping 318 matching lines @@
 TEST(MessageTest, Message) {
   dbus::Message message;
   EXPECT_TRUE(message.raw_message() == NULL);
   EXPECT_EQ(dbus::Message::MESSAGE_INVALID, message.GetMessageType());
 }
 
 TEST(MessageTest, MethodCall) {
   dbus::MethodCall method_call("com.example.Interface", "SomeMethod");
   EXPECT_TRUE(method_call.raw_message() != NULL);
   EXPECT_EQ(dbus::Message::MESSAGE_METHOD_CALL, method_call.GetMessageType());
-  method_call.SetServiceName("com.example.Service");
-  method_call.SetObjectPath("/com/example/Object");
+  method_call.SetDestination("com.example.Service");
+  method_call.SetPath("/com/example/Object");
 
   dbus::MessageWriter writer(&method_call);
   writer.AppendString("payload");
 
   EXPECT_EQ("destination: com.example.Service\n"
             "path: /com/example/Object\n"
             "interface: com.example.Interface\n"
             "member: SomeMethod\n"
             "signature: s\n"
             "\n"
             "string \"payload\"\n",
             method_call.ToString());
 }
 
+TEST(MessageTest, MethodCall_FromRawMessage) {
+  DBusMessage* raw_message = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
+  dbus_message_set_interface(raw_message, "com.example.Interface");
+  dbus_message_set_member(raw_message, "SomeMethod");
+
+  scoped_ptr<dbus::MethodCall> method_call(
+      dbus::MethodCall::FromRawMessage(raw_message));
+  EXPECT_EQ("com.example.Interface", method_call->GetInterface());
+  EXPECT_EQ("SomeMethod", method_call->GetMember());
+}
+
 TEST(MessageTest, Response) {
   dbus::Response response;
   EXPECT_TRUE(response.raw_message() == NULL);
   response.reset_raw_message(
       dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN));
   EXPECT_EQ(dbus::Message::MESSAGE_METHOD_RETURN, response.GetMessageType());
 }
 
+TEST(MergeTest, Response_FromMethodCall) {
+  const uint32 kSerial = 123;
+  dbus::MethodCall method_call("com.example.Interface", "SomeMethod");
+  method_call.SetSerial(kSerial);
+
+  scoped_ptr<dbus::Response> response(
+      dbus::Response::FromMethodCall(&method_call));
+  EXPECT_EQ(dbus::Message::MESSAGE_METHOD_RETURN, response->GetMessageType());
+  // The serial should be copied to the reply serial.
+  EXPECT_EQ(kSerial, response->GetReplySerial());
+}
+
+TEST(MergeTest, ErrorResponse) {
+  dbus::ErrorResponse error_response;
+  EXPECT_TRUE(error_response.raw_message() == NULL);
+  error_response.reset_raw_message(
+      dbus_message_new(DBUS_MESSAGE_TYPE_ERROR));
+  EXPECT_EQ(dbus::Message::MESSAGE_ERROR, error_response.GetMessageType());
+}
+
+TEST(MergeTest, ErrorResponse_FromMethodCall) {
+  const uint32 kSerial = 123;
+const char kErrorMessage[] = "error message";
+
+  dbus::MethodCall method_call("com.example.Interface", "SomeMethod");
+  method_call.SetSerial(kSerial);
+
+  scoped_ptr<dbus::ErrorResponse> error_response(
+      dbus::ErrorResponse::FromMethodCall(&method_call,
+                                          DBUS_ERROR_FAILED,
+                                          kErrorMessage));
+  EXPECT_EQ(dbus::Message::MESSAGE_ERROR, error_response->GetMessageType());
+  // The serial should be copied to the reply serial.
+  EXPECT_EQ(kSerial, error_response->GetReplySerial());
+
+  // Error message should be added to the payload.
+  dbus::MessageReader reader(error_response.get());
+  std::string error_message;
+  ASSERT_TRUE(reader.PopString(&error_message));
+  EXPECT_EQ(kErrorMessage, error_message);
+}
+
 TEST(MessageTest, ToString_EmptyMessage) {
   dbus::Message message;
   EXPECT_EQ("", message.ToString());
 }
+
+TEST(MessageTest, GetAndSetHeaders) {
+  dbus::Message message;
+  message.reset_raw_message(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL));
+
+  EXPECT_EQ("", message.GetDestination());
+  EXPECT_EQ("", message.GetPath());
+  EXPECT_EQ("", message.GetInterface());
+  EXPECT_EQ("", message.GetMember());
+  EXPECT_EQ("", message.GetErrorName());
+  EXPECT_EQ("", message.GetSender());
+  EXPECT_EQ(0U, message.GetSerial());
+  EXPECT_EQ(0U, message.GetReplySerial());
+
+  message.SetDestination("org.chromium.destination");
+  message.SetPath("/org/chromium/path");
+  message.SetInterface("org.chromium.interface");
+  message.SetMember("member");
+  message.SetErrorName("org.chromium.error");
+  message.SetSender(":1.2");
+  message.SetSerial(123);
+  message.SetReplySerial(456);
+
+  EXPECT_EQ("org.chromium.destination", message.GetDestination());
+  EXPECT_EQ("/org/chromium/path", message.GetPath());
+  EXPECT_EQ("org.chromium.interface", message.GetInterface());
+  EXPECT_EQ("member", message.GetMember());
+  EXPECT_EQ("org.chromium.error", message.GetErrorName());
+  EXPECT_EQ(":1.2", message.GetSender());
+  EXPECT_EQ(123U, message.GetSerial());
+  EXPECT_EQ(456U, message.GetReplySerial());
+}