chromeos-dbus-bindings/dbus_signature_test.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2014 The Chromium OS 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 "chromeos-dbus-bindings/dbus_signature.h"

 #include <map>
 #include <string>

 #include <dbus/dbus-protocol.h>
 #include <gtest/gtest.h>

 using std::map;
 using std::string;
 using testing::Test;
 using testing::TestWithParam;

 namespace chromeos_dbus_bindings {

 using Direction = DBusType::Direction;
 using Receiver = DBusType::Receiver;

 namespace {

 // Failing signatures.
 const char kEmptySignature[] = "";
 const char kEmptyDictSignature[] = "a{}";
 const char kMissingArraryParameterSignature[] = "a";
 const char kMissingArraryParameterInnerSignature[] = "a{sa}i";
 const char kOrphanDictSignature[] = "a{s{i}}";
 const char kTooFewDictMembersSignature[] = "a{s}";
 const char kTooManyDictMembersSignature[] = "a{sa{i}u}";
 const char kUnclosedDictOuterSignature[] = "a{s";
 const char kUnclosedDictInnerSignature[] = "a{a{u}";
 const char kUnexpectedCloseSignature[] = "a}i{";
 const char kUnknownSignature[] = "al";

 // Signature for protobuf type
 const char kMyProtobufClassName[] = "MyProtobufClass";

 }  // namespace

 TEST(DBusSignatureTest, ParseFailures) {
   DBusSignature signature;
   for (const auto& failing_string :
        {kEmptySignature, kEmptyDictSignature, kMissingArraryParameterSignature,
         kMissingArraryParameterInnerSignature, kOrphanDictSignature,
         kTooFewDictMembersSignature, kTooManyDictMembersSignature,
         kUnclosedDictOuterSignature, kUnclosedDictInnerSignature,
         kUnexpectedCloseSignature, kUnknownSignature}) {
     EXPECT_FALSE(signature.Parse(failing_string))
         << "Expected signature " << failing_string
         << " to fail but it succeeded";
   }
 }

 TEST(DBusSignatureTest, ParseSuccesses) {
   DBusSignature signature;
   const map<string, string> parse_values{
       // Simple types.
       {DBUS_TYPE_BOOLEAN_AS_STRING, "bool"},
       {DBUS_TYPE_BYTE_AS_STRING, "uint8_t"},
       {DBUS_TYPE_DOUBLE_AS_STRING, "double"},
       {DBUS_TYPE_OBJECT_PATH_AS_STRING, "dbus::ObjectPath"},
       {DBUS_TYPE_INT16_AS_STRING, "int16_t"},
       {DBUS_TYPE_INT32_AS_STRING, "int32_t"},
       {DBUS_TYPE_INT64_AS_STRING, "int64_t"},
       {DBUS_TYPE_STRING_AS_STRING, "std::string"},
       {DBUS_TYPE_UINT16_AS_STRING, "uint16_t"},
       {DBUS_TYPE_UINT32_AS_STRING, "uint32_t"},
       {DBUS_TYPE_UINT64_AS_STRING, "uint64_t"},
       {DBUS_TYPE_VARIANT_AS_STRING, "brillo::Any"},

       // Complex types.
       {"ab", "std::vector<bool>"},
       {"ay", "std::vector<uint8_t>"},
       {"aay", "std::vector<std::vector<uint8_t>>"},
       {"ao", "std::vector<dbus::ObjectPath>"},
       {"a{oa{sa{sv}}}",
        "std::map<dbus::ObjectPath, std::map<std::string, "
        "brillo::VariantDictionary>>"},
       {"a{os}", "std::map<dbus::ObjectPath, std::string>"},
       {"as", "std::vector<std::string>"},
       {"a{ss}", "std::map<std::string, std::string>"},
       {"a{sa{ss}}",
        "std::map<std::string, std::map<std::string, "
        "std::string>>"},
       {"a{sa{sv}}", "std::map<std::string, brillo::VariantDictionary>"},
       {"a{sv}", "brillo::VariantDictionary"},
       {"a{sv}Garbage", "brillo::VariantDictionary"},
       {"at", "std::vector<uint64_t>"},
       {"a{iv}", "std::map<int32_t, brillo::Any>"},
       {"(ib)", "std::tuple<int32_t, bool>"},
       {"(ibs)", "std::tuple<int32_t, bool, std::string>"},
   };
   for (const auto& parse_test : parse_values) {
     auto type = signature.Parse(parse_test.first);
     EXPECT_TRUE(type) << "Expected signature " << parse_test.first
                       << " to succeed but it failed.";

     string output = type->GetBaseType(Direction::kAppend);
     EXPECT_EQ(parse_test.second, output)
         << "Expected typename for " << parse_test.first << " to be "
         << parse_test.second << " but instead it was " << output;
     output = type->GetBaseType(Direction::kExtract);
     EXPECT_EQ(parse_test.second, output)
         << "Expected typename for " << parse_test.first << " to be "
         << parse_test.second << " but instead it was " << output;
   }
 }

 // Scalar types should not have reference behavior when used as in-args, and
 // should just produce the base type as their in-arg type.
 TEST(DBusSignatureTest, ScalarTypes) {
   DBusSignature signature;
   const std::vector<string> parse_values{
       DBUS_TYPE_BOOLEAN_AS_STRING, DBUS_TYPE_BYTE_AS_STRING,
       DBUS_TYPE_DOUBLE_AS_STRING,  DBUS_TYPE_INT16_AS_STRING,
       DBUS_TYPE_INT32_AS_STRING,   DBUS_TYPE_INT64_AS_STRING,
       DBUS_TYPE_UINT16_AS_STRING,  DBUS_TYPE_UINT32_AS_STRING,
       DBUS_TYPE_UINT64_AS_STRING,
   };

   for (const auto& parse_test : parse_values) {
     auto type = signature.Parse(parse_test);
     EXPECT_TRUE(type);
     EXPECT_EQ(type->GetBaseType(Direction::kExtract),
               type->GetInArgType(Receiver::kAdaptor));
     EXPECT_EQ(type->GetBaseType(Direction::kAppend),
               type->GetInArgType(Receiver::kProxy));
   }
 }

 // Non-scalar types should have const reference behavior when used as in-args.
 // The references should not be nested.
 TEST(DBusSignatureTest, NonScalarTypes) {
   DBusSignature signature;
   const map<string, string> parse_values{
       {"o", "const dbus::ObjectPath&"},
       {"s", "const std::string&"},
       {"v", "const brillo::Any&"},
       {"ab", "const std::vector<bool>&"},
       {"ay", "const std::vector<uint8_t>&"},
       {"aay", "const std::vector<std::vector<uint8_t>>&"},
       {"ao", "const std::vector<dbus::ObjectPath>&"},
       {"a{oa{sa{sv}}}",
        "const std::map<dbus::ObjectPath, std::map<"
        "std::string, brillo::VariantDictionary>>&"},
       {"a{os}", "const std::map<dbus::ObjectPath, std::string>&"},
       {"as", "const std::vector<std::string>&"},
       {"a{ss}", "const std::map<std::string, std::string>&"},
       {"a{sa{ss}}",
        "const std::map<std::string, std::map<std::string, "
        "std::string>>&"},
       {"a{sa{sv}}",
        "const std::map<std::string, "
        "brillo::VariantDictionary>&"},
       {"a{sv}", "const brillo::VariantDictionary&"},
       {"at", "const std::vector<uint64_t>&"},
       {"a{iv}", "const std::map<int32_t, brillo::Any>&"},
       {"(ib)", "const std::tuple<int32_t, bool>&"},
       {"(ibs)", "const std::tuple<int32_t, bool, std::string>&"},
   };

   for (const auto& parse_test : parse_values) {
     auto type = signature.Parse(parse_test.first);
     EXPECT_TRUE(type);
     EXPECT_EQ(parse_test.second, type->GetInArgType(Receiver::kAdaptor));
     EXPECT_EQ(parse_test.second, type->GetInArgType(Receiver::kProxy));
   }
 }

 // Out-args should be pointers, but only at the top level.
 TEST(DBusSignatureTest, OutArgTypes) {
   DBusSignature signature;
   const map<string, string> parse_values{
       {"b", "bool*"},
       {"y", "uint8_t*"},
       {"i", "int32_t*"},
       {"t", "uint64_t*"},
       {"o", "dbus::ObjectPath*"},
       {"s", "std::string*"},
       {"v", "brillo::Any*"},
       {"ab", "std::vector<bool>*"},
       {"ay", "std::vector<uint8_t>*"},
       {"aay", "std::vector<std::vector<uint8_t>>*"},
       {"ao", "std::vector<dbus::ObjectPath>*"},
       {"a{oa{sa{sv}}}",
        "std::map<dbus::ObjectPath, std::map<"
        "std::string, brillo::VariantDictionary>>*"},
       {"a{os}", "std::map<dbus::ObjectPath, std::string>*"},
       {"as", "std::vector<std::string>*"},
       {"a{ss}", "std::map<std::string, std::string>*"},
       {"a{sa{ss}}",
        "std::map<std::string, std::map<std::string, "
        "std::string>>*"},
       {"a{sa{sv}}",
        "std::map<std::string, "
        "brillo::VariantDictionary>*"},
       {"a{sv}", "brillo::VariantDictionary*"},
       {"at", "std::vector<uint64_t>*"},
       {"a{iv}", "std::map<int32_t, brillo::Any>*"},
       {"(ib)", "std::tuple<int32_t, bool>*"},
       {"(ibs)", "std::tuple<int32_t, bool, std::string>*"},
   };

   for (const auto& parse_test : parse_values) {
     auto type = signature.Parse(parse_test.first);
     EXPECT_TRUE(type);
     EXPECT_EQ(parse_test.second, type->GetOutArgType(Receiver::kAdaptor));
     EXPECT_EQ(parse_test.second, type->GetOutArgType(Receiver::kProxy));
   }
 }

 // Test to ensure that file descriptors at varying levels of depth do
 // not produce valid types.
 TEST(DBusSignatureTest, IsValidPropertyType) {
   DBusSignature signature;
   const std::vector<string> valid_property_types{
       "b",     "y",     "i",     "t",         "o",         "s",
       "v",     "ab",    "ay",    "aay",       "ao",        "a{oa{sa{sv}}}",
       "a{os}", "as",    "a{ss}", "a{sa{ss}}", "a{sa{sv}}", "a{sv}",
       "at",    "a{iv}", "(ib)",  "(ibs)",
   };

   for (const auto& parse_test : valid_property_types) {
     auto type = signature.Parse(parse_test);
     EXPECT_TRUE(type);
     EXPECT_TRUE(type->IsValidPropertyType());
   }

   const std::vector<string> invalid_property_types{
       "h", "ah", "aah", "a{sh}", "a{ia{oh}}", "a{hi}", "(sih)", "a(ta{sh})",
   };

   for (const auto& parse_test : invalid_property_types) {
     auto type = signature.Parse(parse_test);
     EXPECT_TRUE(type);
     EXPECT_FALSE(type->IsValidPropertyType());
   }
 }

 TEST(DBusSignatureTest, FileDescriptors) {
   DBusSignature signature;

   auto type = signature.Parse(DBUS_TYPE_UNIX_FD_AS_STRING);
   EXPECT_TRUE(type);
   // for_extraction does matter now.
   EXPECT_EQ("brillo::dbus_utils::FileDescriptor",
             type->GetBaseType(Direction::kAppend));
   EXPECT_EQ("base::ScopedFD", type->GetBaseType(Direction::kExtract));
   // for_adaptor propagates as a different for_extraction as well.
   EXPECT_EQ("const brillo::dbus_utils::FileDescriptor&",
             type->GetInArgType(Receiver::kProxy));
   EXPECT_EQ("const base::ScopedFD&", type->GetInArgType(Receiver::kAdaptor));
   EXPECT_EQ("base::ScopedFD*", type->GetOutArgType(Receiver::kProxy));
   EXPECT_EQ("brillo::dbus_utils::FileDescriptor*",
             type->GetOutArgType(Receiver::kAdaptor));

   // Check that more involved types are correct as well.
   type = signature.Parse("ah");
   EXPECT_EQ("std::vector<brillo::dbus_utils::FileDescriptor>",
             type->GetBaseType(Direction::kAppend));
   EXPECT_EQ("std::vector<base::ScopedFD>",
             type->GetBaseType(Direction::kExtract));

   type = signature.Parse("a{ih}");
   EXPECT_EQ("std::map<int32_t, brillo::dbus_utils::FileDescriptor>",
             type->GetBaseType(Direction::kAppend));
   EXPECT_EQ("std::map<int32_t, base::ScopedFD>",
             type->GetBaseType(Direction::kExtract));

   type = signature.Parse("(ih)");
   EXPECT_EQ("std::tuple<int32_t, brillo::dbus_utils::FileDescriptor>",
             type->GetBaseType(Direction::kAppend));
   EXPECT_EQ("std::tuple<int32_t, base::ScopedFD>",
             type->GetBaseType(Direction::kExtract));
 }

 TEST(DBusSignatureTest, Protobufs) {
   DBusSignature signature;

   auto type = signature.Parse(string(kProtobufType) + kMyProtobufClassName);
   EXPECT_TRUE(type);

   EXPECT_EQ("MyProtobufClass", type->GetBaseType(Direction::kAppend));
   EXPECT_EQ("MyProtobufClass", type->GetBaseType(Direction::kExtract));

   EXPECT_EQ("const MyProtobufClass&", type->GetInArgType(Receiver::kAdaptor));
   EXPECT_EQ("const MyProtobufClass&", type->GetInArgType(Receiver::kProxy));

   EXPECT_EQ("MyProtobufClass*", type->GetOutArgType(Receiver::kAdaptor));
   EXPECT_EQ("MyProtobufClass*", type->GetOutArgType(Receiver::kProxy));
 }

 }  // namespace chromeos_dbus_bindings
	// Copyright 2014 The Chromium OS 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 "chromeos-dbus-bindings/dbus_signature.h"

	#include <map>
	#include <string>

	#include <dbus/dbus-protocol.h>
	#include <gtest/gtest.h>

	using std::map;
	using std::string;
	using testing::Test;
	using testing::TestWithParam;

	namespace chromeos_dbus_bindings {

	using Direction = DBusType::Direction;
	using Receiver = DBusType::Receiver;

	namespace {

	// Failing signatures.
	const char kEmptySignature[] = "";
	const char kEmptyDictSignature[] = "a{}";
	const char kMissingArraryParameterSignature[] = "a";
	const char kMissingArraryParameterInnerSignature[] = "a{sa}i";
	const char kOrphanDictSignature[] = "a{s{i}}";
	const char kTooFewDictMembersSignature[] = "a{s}";
	const char kTooManyDictMembersSignature[] = "a{sa{i}u}";
	const char kUnclosedDictOuterSignature[] = "a{s";
	const char kUnclosedDictInnerSignature[] = "a{a{u}";
	const char kUnexpectedCloseSignature[] = "a}i{";
	const char kUnknownSignature[] = "al";

	// Signature for protobuf type
	const char kMyProtobufClassName[] = "MyProtobufClass";

	} // namespace

	TEST(DBusSignatureTest, ParseFailures) {
	DBusSignature signature;
	for (const auto& failing_string :
	{kEmptySignature, kEmptyDictSignature, kMissingArraryParameterSignature,
	kMissingArraryParameterInnerSignature, kOrphanDictSignature,
	kTooFewDictMembersSignature, kTooManyDictMembersSignature,
	kUnclosedDictOuterSignature, kUnclosedDictInnerSignature,
	kUnexpectedCloseSignature, kUnknownSignature}) {
	EXPECT_FALSE(signature.Parse(failing_string))
	<< "Expected signature " << failing_string
	<< " to fail but it succeeded";
	}
	}

	TEST(DBusSignatureTest, ParseSuccesses) {
	DBusSignature signature;
	const map<string, string> parse_values{
	// Simple types.
	{DBUS_TYPE_BOOLEAN_AS_STRING, "bool"},
	{DBUS_TYPE_BYTE_AS_STRING, "uint8_t"},
	{DBUS_TYPE_DOUBLE_AS_STRING, "double"},
	{DBUS_TYPE_OBJECT_PATH_AS_STRING, "dbus::ObjectPath"},
	{DBUS_TYPE_INT16_AS_STRING, "int16_t"},
	{DBUS_TYPE_INT32_AS_STRING, "int32_t"},
	{DBUS_TYPE_INT64_AS_STRING, "int64_t"},
	{DBUS_TYPE_STRING_AS_STRING, "std::string"},
	{DBUS_TYPE_UINT16_AS_STRING, "uint16_t"},
	{DBUS_TYPE_UINT32_AS_STRING, "uint32_t"},
	{DBUS_TYPE_UINT64_AS_STRING, "uint64_t"},
	{DBUS_TYPE_VARIANT_AS_STRING, "brillo::Any"},

	// Complex types.
	{"ab", "std::vector<bool>"},
	{"ay", "std::vector<uint8_t>"},
	{"aay", "std::vector<std::vector<uint8_t>>"},
	{"ao", "std::vector<dbus::ObjectPath>"},
	{"a{oa{sa{sv}}}",
	"std::map<dbus::ObjectPath, std::map<std::string, "
	"brillo::VariantDictionary>>"},
	{"a{os}", "std::map<dbus::ObjectPath, std::string>"},
	{"as", "std::vector<std::string>"},
	{"a{ss}", "std::map<std::string, std::string>"},
	{"a{sa{ss}}",
	"std::map<std::string, std::map<std::string, "
	"std::string>>"},
	{"a{sa{sv}}", "std::map<std::string, brillo::VariantDictionary>"},
	{"a{sv}", "brillo::VariantDictionary"},
	{"a{sv}Garbage", "brillo::VariantDictionary"},
	{"at", "std::vector<uint64_t>"},
	{"a{iv}", "std::map<int32_t, brillo::Any>"},
	{"(ib)", "std::tuple<int32_t, bool>"},
	{"(ibs)", "std::tuple<int32_t, bool, std::string>"},
	};
	for (const auto& parse_test : parse_values) {
	auto type = signature.Parse(parse_test.first);
	EXPECT_TRUE(type) << "Expected signature " << parse_test.first
	<< " to succeed but it failed.";

	string output = type->GetBaseType(Direction::kAppend);
	EXPECT_EQ(parse_test.second, output)
	<< "Expected typename for " << parse_test.first << " to be "
	<< parse_test.second << " but instead it was " << output;
	output = type->GetBaseType(Direction::kExtract);
	EXPECT_EQ(parse_test.second, output)
	<< "Expected typename for " << parse_test.first << " to be "
	<< parse_test.second << " but instead it was " << output;
	}
	}

	// Scalar types should not have reference behavior when used as in-args, and
	// should just produce the base type as their in-arg type.
	TEST(DBusSignatureTest, ScalarTypes) {
	DBusSignature signature;
	const std::vector<string> parse_values{
	DBUS_TYPE_BOOLEAN_AS_STRING, DBUS_TYPE_BYTE_AS_STRING,
	DBUS_TYPE_DOUBLE_AS_STRING, DBUS_TYPE_INT16_AS_STRING,
	DBUS_TYPE_INT32_AS_STRING, DBUS_TYPE_INT64_AS_STRING,
	DBUS_TYPE_UINT16_AS_STRING, DBUS_TYPE_UINT32_AS_STRING,
	DBUS_TYPE_UINT64_AS_STRING,
	};

	for (const auto& parse_test : parse_values) {
	auto type = signature.Parse(parse_test);
	EXPECT_TRUE(type);
	EXPECT_EQ(type->GetBaseType(Direction::kExtract),
	type->GetInArgType(Receiver::kAdaptor));
	EXPECT_EQ(type->GetBaseType(Direction::kAppend),
	type->GetInArgType(Receiver::kProxy));
	}
	}

	// Non-scalar types should have const reference behavior when used as in-args.
	// The references should not be nested.
	TEST(DBusSignatureTest, NonScalarTypes) {
	DBusSignature signature;
	const map<string, string> parse_values{
	{"o", "const dbus::ObjectPath&"},
	{"s", "const std::string&"},
	{"v", "const brillo::Any&"},
	{"ab", "const std::vector<bool>&"},
	{"ay", "const std::vector<uint8_t>&"},
	{"aay", "const std::vector<std::vector<uint8_t>>&"},
	{"ao", "const std::vector<dbus::ObjectPath>&"},
	{"a{oa{sa{sv}}}",
	"const std::map<dbus::ObjectPath, std::map<"
	"std::string, brillo::VariantDictionary>>&"},
	{"a{os}", "const std::map<dbus::ObjectPath, std::string>&"},
	{"as", "const std::vector<std::string>&"},
	{"a{ss}", "const std::map<std::string, std::string>&"},
	{"a{sa{ss}}",
	"const std::map<std::string, std::map<std::string, "
	"std::string>>&"},
	{"a{sa{sv}}",
	"const std::map<std::string, "
	"brillo::VariantDictionary>&"},
	{"a{sv}", "const brillo::VariantDictionary&"},
	{"at", "const std::vector<uint64_t>&"},
	{"a{iv}", "const std::map<int32_t, brillo::Any>&"},
	{"(ib)", "const std::tuple<int32_t, bool>&"},
	{"(ibs)", "const std::tuple<int32_t, bool, std::string>&"},
	};

	for (const auto& parse_test : parse_values) {
	auto type = signature.Parse(parse_test.first);
	EXPECT_TRUE(type);
	EXPECT_EQ(parse_test.second, type->GetInArgType(Receiver::kAdaptor));
	EXPECT_EQ(parse_test.second, type->GetInArgType(Receiver::kProxy));
	}
	}

	// Out-args should be pointers, but only at the top level.
	TEST(DBusSignatureTest, OutArgTypes) {
	DBusSignature signature;
	const map<string, string> parse_values{
	{"b", "bool*"},
	{"y", "uint8_t*"},
	{"i", "int32_t*"},
	{"t", "uint64_t*"},
	{"o", "dbus::ObjectPath*"},
	{"s", "std::string*"},
	{"v", "brillo::Any*"},
	{"ab", "std::vector<bool>*"},
	{"ay", "std::vector<uint8_t>*"},
	{"aay", "std::vector<std::vector<uint8_t>>*"},
	{"ao", "std::vector<dbus::ObjectPath>*"},
	{"a{oa{sa{sv}}}",
	"std::map<dbus::ObjectPath, std::map<"
	"std::string, brillo::VariantDictionary>>*"},
	{"a{os}", "std::map<dbus::ObjectPath, std::string>*"},
	{"as", "std::vector<std::string>*"},
	{"a{ss}", "std::map<std::string, std::string>*"},
	{"a{sa{ss}}",
	"std::map<std::string, std::map<std::string, "
	"std::string>>*"},
	{"a{sa{sv}}",
	"std::map<std::string, "
	"brillo::VariantDictionary>*"},
	{"a{sv}", "brillo::VariantDictionary*"},
	{"at", "std::vector<uint64_t>*"},
	{"a{iv}", "std::map<int32_t, brillo::Any>*"},
	{"(ib)", "std::tuple<int32_t, bool>*"},
	{"(ibs)", "std::tuple<int32_t, bool, std::string>*"},
	};

	for (const auto& parse_test : parse_values) {
	auto type = signature.Parse(parse_test.first);
	EXPECT_TRUE(type);
	EXPECT_EQ(parse_test.second, type->GetOutArgType(Receiver::kAdaptor));
	EXPECT_EQ(parse_test.second, type->GetOutArgType(Receiver::kProxy));
	}
	}

	// Test to ensure that file descriptors at varying levels of depth do
	// not produce valid types.
	TEST(DBusSignatureTest, IsValidPropertyType) {
	DBusSignature signature;
	const std::vector<string> valid_property_types{
	"b", "y", "i", "t", "o", "s",
	"v", "ab", "ay", "aay", "ao", "a{oa{sa{sv}}}",
	"a{os}", "as", "a{ss}", "a{sa{ss}}", "a{sa{sv}}", "a{sv}",
	"at", "a{iv}", "(ib)", "(ibs)",
	};

	for (const auto& parse_test : valid_property_types) {
	auto type = signature.Parse(parse_test);
	EXPECT_TRUE(type);
	EXPECT_TRUE(type->IsValidPropertyType());
	}

	const std::vector<string> invalid_property_types{
	"h", "ah", "aah", "a{sh}", "a{ia{oh}}", "a{hi}", "(sih)", "a(ta{sh})",
	};

	for (const auto& parse_test : invalid_property_types) {
	auto type = signature.Parse(parse_test);
	EXPECT_TRUE(type);
	EXPECT_FALSE(type->IsValidPropertyType());
	}
	}

	TEST(DBusSignatureTest, FileDescriptors) {
	DBusSignature signature;

	auto type = signature.Parse(DBUS_TYPE_UNIX_FD_AS_STRING);
	EXPECT_TRUE(type);
	// for_extraction does matter now.
	EXPECT_EQ("brillo::dbus_utils::FileDescriptor",
	type->GetBaseType(Direction::kAppend));
	EXPECT_EQ("base::ScopedFD", type->GetBaseType(Direction::kExtract));
	// for_adaptor propagates as a different for_extraction as well.
	EXPECT_EQ("const brillo::dbus_utils::FileDescriptor&",
	type->GetInArgType(Receiver::kProxy));
	EXPECT_EQ("const base::ScopedFD&", type->GetInArgType(Receiver::kAdaptor));
	EXPECT_EQ("base::ScopedFD*", type->GetOutArgType(Receiver::kProxy));
	EXPECT_EQ("brillo::dbus_utils::FileDescriptor*",
	type->GetOutArgType(Receiver::kAdaptor));

	// Check that more involved types are correct as well.
	type = signature.Parse("ah");
	EXPECT_EQ("std::vector<brillo::dbus_utils::FileDescriptor>",
	type->GetBaseType(Direction::kAppend));
	EXPECT_EQ("std::vector<base::ScopedFD>",
	type->GetBaseType(Direction::kExtract));

	type = signature.Parse("a{ih}");
	EXPECT_EQ("std::map<int32_t, brillo::dbus_utils::FileDescriptor>",
	type->GetBaseType(Direction::kAppend));
	EXPECT_EQ("std::map<int32_t, base::ScopedFD>",
	type->GetBaseType(Direction::kExtract));

	type = signature.Parse("(ih)");
	EXPECT_EQ("std::tuple<int32_t, brillo::dbus_utils::FileDescriptor>",
	type->GetBaseType(Direction::kAppend));
	EXPECT_EQ("std::tuple<int32_t, base::ScopedFD>",
	type->GetBaseType(Direction::kExtract));
	}

	TEST(DBusSignatureTest, Protobufs) {
	DBusSignature signature;

	auto type = signature.Parse(string(kProtobufType) + kMyProtobufClassName);
	EXPECT_TRUE(type);

	EXPECT_EQ("MyProtobufClass", type->GetBaseType(Direction::kAppend));
	EXPECT_EQ("MyProtobufClass", type->GetBaseType(Direction::kExtract));

	EXPECT_EQ("const MyProtobufClass&", type->GetInArgType(Receiver::kAdaptor));
	EXPECT_EQ("const MyProtobufClass&", type->GetInArgType(Receiver::kProxy));

	EXPECT_EQ("MyProtobufClass*", type->GetOutArgType(Receiver::kAdaptor));
	EXPECT_EQ("MyProtobufClass*", type->GetOutArgType(Receiver::kProxy));
	}

	} // namespace chromeos_dbus_bindings