// Copyright 2022 The Fuchsia 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 <lib/ddk/device.h>

#include <memory>

#include <bind/fuchsia/cpp/bind.h>
#include <bind/testlib/cpp/bind.h>
#include <ddktl/device.h>
#include <zxtest/zxtest.h>

namespace {

void VerifyPropertyKey(device_bind_prop_key_t expected, device_bind_prop_key_t actual) {
  ASSERT_EQ(expected.key_type, actual.key_type);
  switch (expected.key_type) {
    case DEVICE_BIND_PROPERTY_KEY_INT: {
      ASSERT_EQ(expected.data.int_key, actual.data.int_key);
      break;
    }
    case DEVICE_BIND_PROPERTY_KEY_STRING: {
      ASSERT_STREQ(expected.data.str_key, actual.data.str_key);
      break;
    }
    default: {
      ASSERT_TRUE(false);
    }
  }
}

void VerifyPropertyValue(device_bind_prop_value_t expected, device_bind_prop_value_t actual) {
  ASSERT_EQ(expected.data_type, actual.data_type);
  switch (expected.data_type) {
    case ZX_DEVICE_PROPERTY_VALUE_INT: {
      ASSERT_EQ(expected.data.int_value, actual.data.int_value);
      break;
    }
    case ZX_DEVICE_PROPERTY_VALUE_STRING: {
      ASSERT_STREQ(expected.data.str_value, actual.data.str_value);
      break;
    }
    case ZX_DEVICE_PROPERTY_VALUE_BOOL: {
      ASSERT_EQ(expected.data.bool_value, actual.data.bool_value);
      break;
    }
    case ZX_DEVICE_PROPERTY_VALUE_ENUM: {
      ASSERT_STREQ(expected.data.enum_value, actual.data.enum_value);
      break;
    }
    default: {
      ASSERT_TRUE(false);
    }
  }
}

class CompositeNodeSpecTest : public zxtest::Test {};

TEST_F(CompositeNodeSpecTest, CreateAcceptBindRules) {
  auto int_key_bind_rule = ddk::MakeAcceptBindRule(5, 100);
  ASSERT_EQ(5, int_key_bind_rule.get().key.data.int_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, int_key_bind_rule.get().condition);
  ASSERT_EQ(1, int_key_bind_rule.get().values_count);
  ASSERT_EQ(100, int_key_bind_rule.get().values[0].data.int_value);

  auto int_val_bind_rule = ddk::MakeAcceptBindRule("int_based_val", static_cast<uint32_t>(50));
  ASSERT_STREQ("int_based_val", int_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, int_val_bind_rule.get().condition);
  ASSERT_EQ(1, int_val_bind_rule.get().values_count);
  ASSERT_EQ(50, int_val_bind_rule.get().values[0].data.int_value);

  auto str_val_bind_rule = ddk::MakeAcceptBindRule("string_based_val", "thrush");
  ASSERT_STREQ("string_based_val", str_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, str_val_bind_rule.get().condition);
  ASSERT_EQ(1, str_val_bind_rule.get().values_count);
  ASSERT_STREQ("thrush", str_val_bind_rule.get().values[0].data.str_value);

  auto bool_val_bind_rule = ddk::MakeAcceptBindRule("bool_based_val", true);
  ASSERT_STREQ("bool_based_val", bool_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, bool_val_bind_rule.get().condition);
  ASSERT_EQ(1, bool_val_bind_rule.get().values_count);
  ASSERT_TRUE(bool_val_bind_rule.get().values[0].data.bool_value);

  auto enum_val_bind_rule =
      ddk::MakeAcceptBindRule("enum_based_val", "fuchsia.gpio.BIND_PROTOCOL.DEVICE");
  ASSERT_STREQ("enum_based_val", enum_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, enum_val_bind_rule.get().condition);
  ASSERT_EQ(1, enum_val_bind_rule.get().values_count);
  ASSERT_STREQ("fuchsia.gpio.BIND_PROTOCOL.DEVICE",
               enum_val_bind_rule.get().values[0].data.enum_value);
}

TEST_F(CompositeNodeSpecTest, CreateAcceptBindRulesGeneratedConstants) {
  auto int_val_bind_rule =
      ddk::MakeAcceptBindRule(bind_fuchsia::PROTOCOL, bind_testlib::BIND_PROTOCOL_VALUE);
  ASSERT_STREQ(bind_fuchsia::PROTOCOL, int_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, int_val_bind_rule.get().condition);
  ASSERT_EQ(1, int_val_bind_rule.get().values_count);
  ASSERT_EQ(bind_testlib::BIND_PROTOCOL_VALUE, int_val_bind_rule.get().values[0].data.int_value);

  auto str_val_bind_rule =
      ddk::MakeAcceptBindRule(bind_testlib::STRING_PROP, bind_testlib::STRING_PROP_VALUE);
  ASSERT_STREQ(bind_testlib::STRING_PROP, str_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, str_val_bind_rule.get().condition);
  ASSERT_EQ(1, str_val_bind_rule.get().values_count);
  ASSERT_STREQ(bind_testlib::STRING_PROP_VALUE, str_val_bind_rule.get().values[0].data.str_value);

  auto bool_val_bind_rule =
      ddk::MakeAcceptBindRule(bind_testlib::BOOL_PROP, bind_testlib::BOOL_PROP_VALUE);
  ASSERT_STREQ(bind_testlib::BOOL_PROP, bool_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, bool_val_bind_rule.get().condition);
  ASSERT_EQ(1, bool_val_bind_rule.get().values_count);
  ASSERT_EQ(bind_testlib::BOOL_PROP_VALUE, bool_val_bind_rule.get().values[0].data.bool_value);

  auto enum_val_bind_rule =
      ddk::MakeAcceptBindRule(bind_testlib::ENUM_PROP, bind_testlib::ENUM_PROP_VALUE);
  ASSERT_STREQ(bind_testlib::ENUM_PROP, enum_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, enum_val_bind_rule.get().condition);
  ASSERT_EQ(1, enum_val_bind_rule.get().values_count);
  ASSERT_STREQ(bind_testlib::ENUM_PROP_VALUE, enum_val_bind_rule.get().values[0].data.enum_value);
}

TEST_F(CompositeNodeSpecTest, CreateRejectBindRules) {
  auto int_key_bind_rule = ddk::MakeRejectBindRule(5, 100);
  ASSERT_EQ(5, int_key_bind_rule.get().key.data.int_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, int_key_bind_rule.get().condition);
  ASSERT_EQ(1, int_key_bind_rule.get().values_count);
  ASSERT_EQ(100, int_key_bind_rule.get().values[0].data.int_value);

  auto int_val_bind_rule = ddk::MakeRejectBindRule("int_based_val", static_cast<uint32_t>(50));
  ASSERT_STREQ("int_based_val", int_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, int_val_bind_rule.get().condition);
  ASSERT_EQ(1, int_val_bind_rule.get().values_count);
  ASSERT_EQ(50, int_val_bind_rule.get().values[0].data.int_value);

  auto str_val_bind_rule = ddk::MakeRejectBindRule("string_based_val", "thrush");
  ASSERT_STREQ("string_based_val", str_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, str_val_bind_rule.get().condition);
  ASSERT_EQ(1, str_val_bind_rule.get().values_count);
  ASSERT_STREQ("thrush", str_val_bind_rule.get().values[0].data.str_value);

  auto bool_val_bind_rule = ddk::MakeRejectBindRule("bool_based_val", true);
  ASSERT_STREQ("bool_based_val", bool_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, bool_val_bind_rule.get().condition);
  ASSERT_EQ(1, bool_val_bind_rule.get().values_count);
  ASSERT_TRUE(bool_val_bind_rule.get().values[0].data.bool_value);

  auto enum_val_bind_rule =
      ddk::MakeRejectBindRule("enum_based_val", "fuchsia.gpio.BIND_PROTOCOL.DEVICE");
  ASSERT_STREQ("enum_based_val", enum_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, enum_val_bind_rule.get().condition);
  ASSERT_EQ(1, enum_val_bind_rule.get().values_count);
  ASSERT_STREQ("fuchsia.gpio.BIND_PROTOCOL.DEVICE",
               enum_val_bind_rule.get().values[0].data.enum_value);
}

TEST_F(CompositeNodeSpecTest, CreateRejectBindRulesGeneratedConstants) {
  auto int_val_bind_rule =
      ddk::MakeRejectBindRule(bind_fuchsia::PROTOCOL, bind_testlib::BIND_PROTOCOL_VALUE);
  ASSERT_STREQ(bind_fuchsia::PROTOCOL, int_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, int_val_bind_rule.get().condition);
  ASSERT_EQ(1, int_val_bind_rule.get().values_count);
  ASSERT_EQ(bind_testlib::BIND_PROTOCOL_VALUE, int_val_bind_rule.get().values[0].data.int_value);

  auto str_val_bind_rule =
      ddk::MakeRejectBindRule(bind_testlib::STRING_PROP, bind_testlib::STRING_PROP_VALUE);
  ASSERT_STREQ(bind_testlib::STRING_PROP, str_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, str_val_bind_rule.get().condition);
  ASSERT_EQ(1, str_val_bind_rule.get().values_count);
  ASSERT_STREQ(bind_testlib::STRING_PROP_VALUE, str_val_bind_rule.get().values[0].data.str_value);

  auto bool_val_bind_rule =
      ddk::MakeRejectBindRule(bind_testlib::BOOL_PROP, bind_testlib::BOOL_PROP_VALUE);
  ASSERT_STREQ(bind_testlib::BOOL_PROP, bool_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, bool_val_bind_rule.get().condition);
  ASSERT_EQ(1, bool_val_bind_rule.get().values_count);
  ASSERT_EQ(bind_testlib::BOOL_PROP_VALUE, bool_val_bind_rule.get().values[0].data.bool_value);

  auto enum_val_bind_rule =
      ddk::MakeRejectBindRule(bind_testlib::ENUM_PROP, bind_testlib::ENUM_PROP_VALUE);
  ASSERT_STREQ(bind_testlib::ENUM_PROP, enum_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, enum_val_bind_rule.get().condition);
  ASSERT_EQ(1, enum_val_bind_rule.get().values_count);
  ASSERT_STREQ(bind_testlib::ENUM_PROP_VALUE, enum_val_bind_rule.get().values[0].data.enum_value);
}

TEST_F(CompositeNodeSpecTest, CreateAcceptBindRuleList) {
  const uint32_t int_key_bind_rule_values[] = {10, 3};
  auto int_key_bind_rule = ddk::MakeAcceptBindRuleList(5, int_key_bind_rule_values);
  ASSERT_EQ(5, int_key_bind_rule.get().key.data.int_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, int_key_bind_rule.get().condition);
  ASSERT_EQ(2, int_key_bind_rule.get().values_count);
  ASSERT_EQ(10, int_key_bind_rule.get().values[0].data.int_value);
  ASSERT_EQ(3, int_key_bind_rule.get().values[1].data.int_value);

  const uint32_t int_val_bind_rule_values[] = {20, 150, 8};
  auto int_val_bind_rule = ddk::MakeAcceptBindRuleList("int_based_val", int_val_bind_rule_values);
  ASSERT_STREQ("int_based_val", int_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, int_val_bind_rule.get().condition);
  ASSERT_EQ(3, int_val_bind_rule.get().values_count);
  ASSERT_EQ(20, int_val_bind_rule.get().values[0].data.int_value);
  ASSERT_EQ(150, int_val_bind_rule.get().values[1].data.int_value);
  ASSERT_EQ(8, int_val_bind_rule.get().values[2].data.int_value);

  const char* str_val_bind_rule_values[] = {"thrush", "robin"};
  auto str_val_bind_rule =
      ddk::MakeAcceptBindRuleList("string_based_val", str_val_bind_rule_values);
  ASSERT_STREQ("string_based_val", str_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, str_val_bind_rule.get().condition);
  ASSERT_EQ(2, str_val_bind_rule.get().values_count);
  ASSERT_STREQ("thrush", str_val_bind_rule.get().values[0].data.str_value);
  ASSERT_STREQ("robin", str_val_bind_rule.get().values[1].data.str_value);

  const char* enum_val_bind_rule_values[] = {"fuchsia.gpio.BIND_PROTOCOL.DEVICE",
                                             "fuchsia.gpio.BIND_PROTOCOL.IMPL"};
  auto enum_val_bind_rule =
      ddk::MakeAcceptBindRuleList("enum_based_val", enum_val_bind_rule_values);
  ASSERT_STREQ("enum_based_val", enum_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, enum_val_bind_rule.get().condition);
  ASSERT_EQ(2, enum_val_bind_rule.get().values_count);
  ASSERT_STREQ("fuchsia.gpio.BIND_PROTOCOL.DEVICE",
               enum_val_bind_rule.get().values[0].data.enum_value);
  ASSERT_STREQ("fuchsia.gpio.BIND_PROTOCOL.IMPL",
               enum_val_bind_rule.get().values[1].data.enum_value);
}

TEST_F(CompositeNodeSpecTest, CreateAcceptBindRuleListWithConstants) {
  const uint32_t int_val_bind_rule_values[] = {bind_testlib::BIND_PROTOCOL_VALUE,
                                               bind_testlib::BIND_PROTOCOL_VALUE_2};
  auto int_val_bind_rule =
      ddk::MakeAcceptBindRuleList(bind_fuchsia::PROTOCOL, int_val_bind_rule_values);
  ASSERT_STREQ(bind_fuchsia::PROTOCOL, int_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, int_val_bind_rule.get().condition);
  ASSERT_EQ(2, int_val_bind_rule.get().values_count);
  ASSERT_EQ(bind_testlib::BIND_PROTOCOL_VALUE, int_val_bind_rule.get().values[0].data.int_value);
  ASSERT_EQ(bind_testlib::BIND_PROTOCOL_VALUE_2, int_val_bind_rule.get().values[1].data.int_value);

  const char* str_val_bind_rule_values[] = {bind_testlib::STRING_PROP_VALUE.c_str(),
                                            bind_testlib::STRING_PROP_VALUE_2.c_str()};
  auto str_val_bind_rule =
      ddk::MakeAcceptBindRuleList(bind_testlib::STRING_PROP, str_val_bind_rule_values);
  ASSERT_STREQ(bind_testlib::STRING_PROP, str_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, str_val_bind_rule.get().condition);
  ASSERT_EQ(2, str_val_bind_rule.get().values_count);
  ASSERT_STREQ(bind_testlib::STRING_PROP_VALUE, str_val_bind_rule.get().values[0].data.str_value);
  ASSERT_STREQ(bind_testlib::STRING_PROP_VALUE_2, str_val_bind_rule.get().values[1].data.str_value);

  const char* enum_val_bind_rule_values[] = {bind_testlib::ENUM_PROP_VALUE.c_str(),
                                             bind_testlib::ENUM_PROP_VALUE_2.c_str()};
  auto enum_val_bind_rule =
      ddk::MakeAcceptBindRuleList(bind_testlib::ENUM_PROP, enum_val_bind_rule_values);
  ASSERT_STREQ(bind_testlib::ENUM_PROP, enum_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, enum_val_bind_rule.get().condition);
  ASSERT_EQ(2, enum_val_bind_rule.get().values_count);
  ASSERT_STREQ(bind_testlib::ENUM_PROP_VALUE, enum_val_bind_rule.get().values[0].data.enum_value);
  ASSERT_STREQ(bind_testlib::ENUM_PROP_VALUE_2, enum_val_bind_rule.get().values[1].data.enum_value);
}

TEST_F(CompositeNodeSpecTest, CreateRejectBindRuleList) {
  const uint32_t int_key_bind_rule_values[] = {10, 3};
  auto int_key_bind_rule = ddk::MakeRejectBindRuleList(5, int_key_bind_rule_values);
  ASSERT_EQ(5, int_key_bind_rule.get().key.data.int_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, int_key_bind_rule.get().condition);
  ASSERT_EQ(2, int_key_bind_rule.get().values_count);
  ASSERT_EQ(10, int_key_bind_rule.get().values[0].data.int_value);
  ASSERT_EQ(3, int_key_bind_rule.get().values[1].data.int_value);

  const uint32_t int_val_bind_rule_values[] = {20, 150, 8};
  auto int_val_bind_rule = ddk::MakeRejectBindRuleList("int_based_val", int_val_bind_rule_values);
  ASSERT_STREQ("int_based_val", int_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, int_val_bind_rule.get().condition);
  ASSERT_EQ(3, int_val_bind_rule.get().values_count);
  ASSERT_EQ(20, int_val_bind_rule.get().values[0].data.int_value);
  ASSERT_EQ(150, int_val_bind_rule.get().values[1].data.int_value);
  ASSERT_EQ(8, int_val_bind_rule.get().values[2].data.int_value);

  const char* str_val_bind_rule_values[] = {"thrush", "robin"};
  auto str_val_bind_rule =
      ddk::MakeRejectBindRuleList("string_based_val", str_val_bind_rule_values);
  ASSERT_STREQ("string_based_val", str_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, str_val_bind_rule.get().condition);
  ASSERT_EQ(2, str_val_bind_rule.get().values_count);
  ASSERT_STREQ("thrush", str_val_bind_rule.get().values[0].data.str_value);
  ASSERT_STREQ("robin", str_val_bind_rule.get().values[1].data.str_value);

  const char* enum_val_bind_rule_values[] = {"fuchsia.gpio.BIND_PROTOCOL.DEVICE",
                                             "fuchsia.gpio.BIND_PROTOCOL.IMPL"};
  auto enum_val_bind_rule =
      ddk::MakeRejectBindRuleList("enum_based_val", enum_val_bind_rule_values);
  ASSERT_STREQ("enum_based_val", enum_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, enum_val_bind_rule.get().condition);
  ASSERT_EQ(2, enum_val_bind_rule.get().values_count);
  ASSERT_STREQ("fuchsia.gpio.BIND_PROTOCOL.DEVICE",
               enum_val_bind_rule.get().values[0].data.enum_value);
  ASSERT_STREQ("fuchsia.gpio.BIND_PROTOCOL.IMPL",
               enum_val_bind_rule.get().values[1].data.enum_value);
}

TEST_F(CompositeNodeSpecTest, CreateRejectBindRuleListWithConstants) {
  const uint32_t int_val_bind_rule_values[] = {bind_testlib::BIND_PROTOCOL_VALUE,
                                               bind_testlib::BIND_PROTOCOL_VALUE_2};
  auto int_val_bind_rule =
      ddk::MakeRejectBindRuleList(bind_fuchsia::PROTOCOL, int_val_bind_rule_values);
  ASSERT_STREQ(bind_fuchsia::PROTOCOL, int_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, int_val_bind_rule.get().condition);
  ASSERT_EQ(2, int_val_bind_rule.get().values_count);
  ASSERT_EQ(bind_testlib::BIND_PROTOCOL_VALUE, int_val_bind_rule.get().values[0].data.int_value);
  ASSERT_EQ(bind_testlib::BIND_PROTOCOL_VALUE_2, int_val_bind_rule.get().values[1].data.int_value);

  const char* str_val_bind_rule_values[] = {bind_testlib::STRING_PROP_VALUE.c_str(),
                                            bind_testlib::STRING_PROP_VALUE_2.c_str()};
  auto str_val_bind_rule =
      ddk::MakeRejectBindRuleList(bind_testlib::STRING_PROP, str_val_bind_rule_values);
  ASSERT_STREQ(bind_testlib::STRING_PROP, str_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, str_val_bind_rule.get().condition);
  ASSERT_EQ(2, str_val_bind_rule.get().values_count);
  ASSERT_STREQ(bind_testlib::STRING_PROP_VALUE, str_val_bind_rule.get().values[0].data.str_value);
  ASSERT_STREQ(bind_testlib::STRING_PROP_VALUE_2, str_val_bind_rule.get().values[1].data.str_value);

  const char* enum_val_bind_rule_values[] = {bind_testlib::ENUM_PROP_VALUE.c_str(),
                                             bind_testlib::ENUM_PROP_VALUE_2.c_str()};
  auto enum_val_bind_rule =
      ddk::MakeRejectBindRuleList(bind_testlib::ENUM_PROP, enum_val_bind_rule_values);
  ASSERT_STREQ(bind_testlib::ENUM_PROP, enum_val_bind_rule.get().key.data.str_key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_REJECT, enum_val_bind_rule.get().condition);
  ASSERT_EQ(2, enum_val_bind_rule.get().values_count);
  ASSERT_STREQ(bind_testlib::ENUM_PROP_VALUE, enum_val_bind_rule.get().values[0].data.enum_value);
  ASSERT_STREQ(bind_testlib::ENUM_PROP_VALUE_2, enum_val_bind_rule.get().values[1].data.enum_value);
}

TEST_F(CompositeNodeSpecTest, CreateBindProperties) {
  auto int_key_bind_prop = ddk::MakeProperty(1, 100);
  ASSERT_EQ(1, int_key_bind_prop.key.data.int_key);
  ASSERT_EQ(100, int_key_bind_prop.value.data.int_value);

  auto int_val_bind_prop = ddk::MakeProperty("int_key", static_cast<uint32_t>(20));
  ASSERT_STREQ("int_key", int_val_bind_prop.key.data.str_key);
  ASSERT_EQ(20, int_val_bind_prop.value.data.int_value);

  auto str_val_bind_prop = ddk::MakeProperty("str_key", "thrush");
  ASSERT_STREQ("str_key", str_val_bind_prop.key.data.str_key);
  ASSERT_STREQ("thrush", str_val_bind_prop.value.data.str_value);

  auto bool_val_bind_prop = ddk::MakeProperty("bool_key", true);
  ASSERT_STREQ("bool_key", bool_val_bind_prop.key.data.str_key);
  ASSERT_TRUE(bool_val_bind_prop.value.data.bool_value);

  auto enum_val_bind_prop = ddk::MakeProperty("enum_key", "fuchsia.gpio.BIND_PROTOCOL.DEVICE");
  ASSERT_STREQ("enum_key", enum_val_bind_prop.key.data.str_key);
  ASSERT_STREQ("fuchsia.gpio.BIND_PROTOCOL.DEVICE", enum_val_bind_prop.value.data.enum_value);
}

TEST_F(CompositeNodeSpecTest, CreateBindPropertiesWithContants) {
  auto int_val_bind_prop =
      ddk::MakeProperty(bind_fuchsia::PROTOCOL, bind_testlib::BIND_PROTOCOL_VALUE);
  ASSERT_STREQ(bind_fuchsia::PROTOCOL, int_val_bind_prop.key.data.str_key);
  ASSERT_EQ(bind_testlib::BIND_PROTOCOL_VALUE, int_val_bind_prop.value.data.int_value);

  auto str_val_bind_prop =
      ddk::MakeProperty(bind_testlib::STRING_PROP, bind_testlib::STRING_PROP_VALUE);
  ASSERT_STREQ(bind_testlib::STRING_PROP, str_val_bind_prop.key.data.str_key);
  ASSERT_STREQ(bind_testlib::STRING_PROP_VALUE, str_val_bind_prop.value.data.str_value);

  auto bool_val_bind_prop =
      ddk::MakeProperty(bind_testlib::BOOL_PROP, bind_testlib::BOOL_PROP_VALUE);
  ASSERT_STREQ(bind_testlib::BOOL_PROP, bool_val_bind_prop.key.data.str_key);
  ASSERT_EQ(bind_testlib::BOOL_PROP_VALUE, bool_val_bind_prop.value.data.bool_value);

  auto enum_val_bind_prop =
      ddk::MakeProperty(bind_testlib::ENUM_PROP, bind_testlib::ENUM_PROP_VALUE);
  ASSERT_STREQ(bind_testlib::ENUM_PROP, enum_val_bind_prop.key.data.str_key);
  ASSERT_STREQ(bind_testlib::ENUM_PROP_VALUE, enum_val_bind_prop.value.data.enum_value);
}

TEST_F(CompositeNodeSpecTest, CreateSpec) {
  const ddk::BindRule kBindRules[] = {
      ddk::MakeAcceptBindRule("test", static_cast<uint32_t>(10)),
  };

  const device_bind_prop_t kBindProperties[] = {
      ddk::MakeProperty("test", static_cast<uint32_t>(10)),
  };

  auto composite_node_spec = ddk::CompositeNodeSpec(kBindRules, kBindProperties);

  {
    auto dealloc_props = std::vector{
        ddk::MakeProperty("test", static_cast<uint32_t>(10)),
        ddk::MakeProperty("swallow", true),
    };

    // Store the int values dynacmically into a vector and then pass
    // it to |composite_node_spec|.
    uint32_t kTestDeallocIntValues[] = {10, 20, 100};
    std::vector<ddk::BindRule> dealloc_rules;
    for (auto val : kTestDeallocIntValues) {
      dealloc_rules.push_back(ddk::MakeAcceptBindRule("test", val));
    }
    composite_node_spec.AddParentSpec(dealloc_rules, dealloc_props);
  }

  auto spec = composite_node_spec.get();
  ASSERT_EQ(2, spec.parent_count);

  // Verify the bind properties in the first parent.
  auto parent_1 = spec.parents[0];
  ASSERT_EQ(1, parent_1.property_count);
  VerifyPropertyKey(device_bind_prop_str_key("test"), parent_1.properties[0].key);
  VerifyPropertyValue(device_bind_prop_int_val(10), parent_1.properties[0].value);

  // Verify the bind rules in the first parent.
  ASSERT_EQ(1, parent_1.bind_rule_count);
  VerifyPropertyKey(device_bind_prop_str_key("test"), parent_1.bind_rules[0].key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, parent_1.bind_rules[0].condition);
  ASSERT_EQ(1, parent_1.bind_rules[0].values_count);
  VerifyPropertyValue(device_bind_prop_int_val(10), parent_1.bind_rules[0].values[0]);

  // Verify the bind properties in the second parent.
  auto parent_2 = spec.parents[1];
  ASSERT_EQ(2, parent_2.property_count);
  VerifyPropertyKey(device_bind_prop_str_key("test"), parent_2.properties[0].key);
  VerifyPropertyValue(device_bind_prop_int_val(10), parent_2.properties[0].value);
  VerifyPropertyKey(device_bind_prop_str_key("swallow"), parent_2.properties[1].key);
  VerifyPropertyValue(device_bind_prop_bool_val(true), parent_2.properties[1].value);

  // Verify the bind rules in the second parent.
  ASSERT_EQ(3, parent_2.bind_rule_count);
  VerifyPropertyKey(device_bind_prop_str_key("test"), parent_2.bind_rules[0].key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, parent_2.bind_rules[0].condition);
  ASSERT_EQ(1, parent_2.bind_rules[1].values_count);
  VerifyPropertyValue(device_bind_prop_int_val(10), parent_2.bind_rules[0].values[0]);

  VerifyPropertyKey(device_bind_prop_str_key("test"), parent_2.bind_rules[1].key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, parent_2.bind_rules[1].condition);
  ASSERT_EQ(1, parent_2.bind_rules[1].values_count);
  VerifyPropertyValue(device_bind_prop_int_val(20), parent_2.bind_rules[1].values[0]);

  VerifyPropertyKey(device_bind_prop_str_key("test"), parent_2.bind_rules[2].key);
  ASSERT_EQ(DEVICE_BIND_RULE_CONDITION_ACCEPT, parent_2.bind_rules[2].condition);
  ASSERT_EQ(1, parent_2.bind_rules[2].values_count);
  VerifyPropertyValue(device_bind_prop_int_val(100), parent_2.bind_rules[2].values[0]);
}

}  // namespace