dbus: add ObjectPath type

dbus/message_unittest.cc

 // Copyright (c) 2012 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 "dbus/object_path.h"
 #include "dbus/test_proto.pb.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) {
   scoped_ptr<dbus::Response> message(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(message.get());
   writer.AppendByte(123);  // The input is 123.
 
@@ skipping 23 matching lines @@
   writer.AppendByte(0);
   writer.AppendBool(true);
   writer.AppendInt16(2);
   writer.AppendUint16(3);
   writer.AppendInt32(4);
   writer.AppendUint32(5);
   writer.AppendInt64(6);
   writer.AppendUint64(7);
   writer.AppendDouble(8.0);
   writer.AppendString("string");
-  writer.AppendObjectPath("/object/path");
+  writer.AppendObjectPath(dbus::ObjectPath("/object/path"));
 
   uint8 byte_value = 0;
   bool bool_value = false;
   int16 int16_value = 0;
   uint16 uint16_value = 0;
   int32 int32_value = 0;
   uint32 uint32_value = 0;
   int64 int64_value = 0;
   uint64 uint64_value = 0;
   double double_value = 0;
   std::string string_value;
-  std::string object_path_value;
+  dbus::ObjectPath object_path_value;
 
   dbus::MessageReader reader(message.get());
   ASSERT_TRUE(reader.HasMoreData());
   ASSERT_TRUE(reader.PopByte(&byte_value));
   ASSERT_TRUE(reader.PopBool(&bool_value));
   ASSERT_TRUE(reader.PopInt16(&int16_value));
   ASSERT_TRUE(reader.PopUint16(&uint16_value));
   ASSERT_TRUE(reader.PopInt32(&int32_value));
   ASSERT_TRUE(reader.PopUint32(&uint32_value));
   ASSERT_TRUE(reader.PopInt64(&int64_value));
   ASSERT_TRUE(reader.PopUint64(&uint64_value));
   ASSERT_TRUE(reader.PopDouble(&double_value));
   ASSERT_TRUE(reader.PopString(&string_value));
   ASSERT_TRUE(reader.PopObjectPath(&object_path_value));
   ASSERT_FALSE(reader.HasMoreData());
 
   // 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path" should be returned.
   EXPECT_EQ(0, byte_value);
   EXPECT_EQ(true, bool_value);
   EXPECT_EQ(2, int16_value);
   EXPECT_EQ(3U, uint16_value);
   EXPECT_EQ(4, int32_value);
   EXPECT_EQ(5U, uint32_value);
   EXPECT_EQ(6, int64_value);
   EXPECT_EQ(7U, uint64_value);
   EXPECT_DOUBLE_EQ(8.0, double_value);
   EXPECT_EQ("string", string_value);
-  EXPECT_EQ("/object/path", object_path_value);
+  EXPECT_EQ(dbus::ObjectPath("/object/path"), object_path_value);
 }
 
 // Check all variant types can be properly written and read.
 TEST(MessageTest, AppendAndPopVariantDataTypes) {
   scoped_ptr<dbus::Response> message(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(message.get());
 
   // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path".
   writer.AppendVariantOfByte(0);
   writer.AppendVariantOfBool(true);
   writer.AppendVariantOfInt16(2);
   writer.AppendVariantOfUint16(3);
   writer.AppendVariantOfInt32(4);
   writer.AppendVariantOfUint32(5);
   writer.AppendVariantOfInt64(6);
   writer.AppendVariantOfUint64(7);
   writer.AppendVariantOfDouble(8.0);
   writer.AppendVariantOfString("string");
-  writer.AppendVariantOfObjectPath("/object/path");
+  writer.AppendVariantOfObjectPath(dbus::ObjectPath("/object/path"));
 
   uint8 byte_value = 0;
   bool bool_value = false;
   int16 int16_value = 0;
   uint16 uint16_value = 0;
   int32 int32_value = 0;
   uint32 uint32_value = 0;
   int64 int64_value = 0;
   uint64 uint64_value = 0;
   double double_value = 0;
   std::string string_value;
-  std::string object_path_value;
+  dbus::ObjectPath object_path_value;
 
   dbus::MessageReader reader(message.get());
   ASSERT_TRUE(reader.HasMoreData());
   ASSERT_TRUE(reader.PopVariantOfByte(&byte_value));
   ASSERT_TRUE(reader.PopVariantOfBool(&bool_value));
   ASSERT_TRUE(reader.PopVariantOfInt16(&int16_value));
   ASSERT_TRUE(reader.PopVariantOfUint16(&uint16_value));
   ASSERT_TRUE(reader.PopVariantOfInt32(&int32_value));
   ASSERT_TRUE(reader.PopVariantOfUint32(&uint32_value));
   ASSERT_TRUE(reader.PopVariantOfInt64(&int64_value));
   ASSERT_TRUE(reader.PopVariantOfUint64(&uint64_value));
   ASSERT_TRUE(reader.PopVariantOfDouble(&double_value));
   ASSERT_TRUE(reader.PopVariantOfString(&string_value));
   ASSERT_TRUE(reader.PopVariantOfObjectPath(&object_path_value));
   ASSERT_FALSE(reader.HasMoreData());
 
   // 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path" should be returned.
   EXPECT_EQ(0, byte_value);
   EXPECT_EQ(true, bool_value);
   EXPECT_EQ(2, int16_value);
   EXPECT_EQ(3U, uint16_value);
   EXPECT_EQ(4, int32_value);
   EXPECT_EQ(5U, uint32_value);
   EXPECT_EQ(6, int64_value);
   EXPECT_EQ(7U, uint64_value);
   EXPECT_DOUBLE_EQ(8.0, double_value);
   EXPECT_EQ("string", string_value);
-  EXPECT_EQ("/object/path", object_path_value);
+  EXPECT_EQ(dbus::ObjectPath("/object/path"), object_path_value);
 }
 
 TEST(MessageTest, ArrayOfBytes) {
   scoped_ptr<dbus::Response> message(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(message.get());
   std::vector<uint8> bytes;
   bytes.push_back(1);
   bytes.push_back(2);
   bytes.push_back(3);
   writer.AppendArrayOfBytes(bytes.data(), bytes.size());
@@ skipping 41 matching lines @@
   ASSERT_EQ(4U, output_strings.size());
   EXPECT_EQ("fee", output_strings[0]);
   EXPECT_EQ("fie", output_strings[1]);
   EXPECT_EQ("foe", output_strings[2]);
   EXPECT_EQ("fum", output_strings[3]);
 }
 
 TEST(MessageTest, ArrayOfObjectPaths) {
   scoped_ptr<dbus::Response> message(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(message.get());
-  std::vector<std::string> object_paths;
-  object_paths.push_back("/object/path/1");
-  object_paths.push_back("/object/path/2");
-  object_paths.push_back("/object/path/3");
+  std::vector<dbus::ObjectPath> object_paths;
+  object_paths.push_back(dbus::ObjectPath("/object/path/1"));
+  object_paths.push_back(dbus::ObjectPath("/object/path/2"));
+  object_paths.push_back(dbus::ObjectPath("/object/path/3"));
   writer.AppendArrayOfObjectPaths(object_paths);
 
   dbus::MessageReader reader(message.get());
-  std::vector<std::string> output_object_paths;
+  std::vector<dbus::ObjectPath> output_object_paths;
   ASSERT_TRUE(reader.PopArrayOfObjectPaths(&output_object_paths));
   ASSERT_FALSE(reader.HasMoreData());
   ASSERT_EQ(3U, output_object_paths.size());
-  EXPECT_EQ("/object/path/1", output_object_paths[0]);
-  EXPECT_EQ("/object/path/2", output_object_paths[1]);
-  EXPECT_EQ("/object/path/3", output_object_paths[2]);
+  EXPECT_EQ(dbus::ObjectPath("/object/path/1"), output_object_paths[0]);
+  EXPECT_EQ(dbus::ObjectPath("/object/path/2"), output_object_paths[1]);
+  EXPECT_EQ(dbus::ObjectPath("/object/path/3"), output_object_paths[2]);
 }
 
 TEST(MessageTest, ProtoBuf) {
   scoped_ptr<dbus::Response> message(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(message.get());
   TestProto send_message;
   send_message.set_text("testing");
   send_message.set_number(123);
   writer.AppendProtoAsArrayOfBytes(send_message);
 
@@ skipping 163 matching lines @@
   ASSERT_FALSE(array_reader.HasMoreData());
   ASSERT_FALSE(reader.HasMoreData());
 }
 
 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());
   EXPECT_EQ("MESSAGE_METHOD_CALL", method_call.GetMessageTypeAsString());
   method_call.SetDestination("com.example.Service");
-  method_call.SetPath("/com/example/Object");
+  method_call.SetPath(dbus::ObjectPath("/com/example/Object"));
 
   dbus::MessageWriter writer(&method_call);
   writer.AppendString("payload");
 
   EXPECT_EQ("message_type: MESSAGE_METHOD_CALL\n"
             "destination: com.example.Service\n"
             "path: /com/example/Object\n"
             "interface: com.example.Interface\n"
             "member: SomeMethod\n"
             "signature: s\n"
@@ skipping 11 matching lines @@
       dbus::MethodCall::FromRawMessage(raw_message));
   EXPECT_EQ("com.example.Interface", method_call->GetInterface());
   EXPECT_EQ("SomeMethod", method_call->GetMember());
 }
 
 TEST(MessageTest, Signal) {
   dbus::Signal signal("com.example.Interface", "SomeSignal");
   EXPECT_TRUE(signal.raw_message() != NULL);
   EXPECT_EQ(dbus::Message::MESSAGE_SIGNAL, signal.GetMessageType());
   EXPECT_EQ("MESSAGE_SIGNAL", signal.GetMessageTypeAsString());
-  signal.SetPath("/com/example/Object");
+  signal.SetPath(dbus::ObjectPath("/com/example/Object"));
 
   dbus::MessageWriter writer(&signal);
   writer.AppendString("payload");
 
   EXPECT_EQ("message_type: MESSAGE_SIGNAL\n"
             "path: /com/example/Object\n"
             "interface: com.example.Interface\n"
             "member: SomeSignal\n"
             "signature: s\n"
             "\n"
@@ skipping 52 matching lines @@
   dbus::MessageReader reader(error_response.get());
   std::string error_message;
   ASSERT_TRUE(reader.PopString(&error_message));
   EXPECT_EQ(kErrorMessage, error_message);
 }
 
 TEST(MessageTest, GetAndSetHeaders) {
   scoped_ptr<dbus::Response> message(dbus::Response::CreateEmpty());
 
   EXPECT_EQ("", message->GetDestination());
-  EXPECT_EQ("", message->GetPath());
+  EXPECT_EQ(dbus::ObjectPath(""), 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->SetPath(dbus::ObjectPath("/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(dbus::ObjectPath("/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());
 }