| // 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, | |
| bind_testlib::STRING_PROP_VALUE_2}; | |
| 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, | |
| bind_testlib::ENUM_PROP_VALUE_2}; | |
| 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, | |
| bind_testlib::STRING_PROP_VALUE_2}; | |
| 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, | |
| bind_testlib::ENUM_PROP_VALUE_2}; | |
| 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 |