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 35 matching lines @@
   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("/object/path", object_path_value.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);
@@ skipping 10 matching lines @@
   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("/object/path", object_path_value.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;
+  std::vector<dbus::ObjectPath> object_paths;
   object_paths.push_back("/object/path/1");
   object_paths.push_back("/object/path/2");
   object_paths.push_back("/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("/object/path/1", output_object_paths[0].value());
+  EXPECT_EQ("/object/path/2", output_object_paths[1].value());
+  EXPECT_EQ("/object/path/3", output_object_paths[2].value());
 }
 
 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 268 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("", message->GetPath().value());
   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/path", message->GetPath().value());
   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());
 }