// 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