From: Francis Dupont Date: Thu, 17 Dec 2020 18:01:46 +0000 (+0100) Subject: [#1585] Checkpoint: libdhcp tests X-Git-Tag: Kea-1.9.4~107 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=fd7bc3fba44a9230b0e623e2d6872f3cb3f585ac;p=thirdparty%2Fkea.git [#1585] Checkpoint: libdhcp tests --- diff --git a/src/lib/dhcp/option_definition.cc b/src/lib/dhcp/option_definition.cc index c83474a10d..be8efd4aad 100644 --- a/src/lib/dhcp/option_definition.cc +++ b/src/lib/dhcp/option_definition.cc @@ -77,7 +77,7 @@ OptionDefinition::OptionDefinition(const std::string& name, const uint16_t code, const std::string& space, const std::string& type, - const std::string& encapsulated_space) + const char* encapsulated_space) : name_(name), code_(code), // Data type is held as enum value by this class. @@ -95,7 +95,7 @@ OptionDefinition::OptionDefinition(const std::string& name, const uint16_t code, const std::string& space, const OptionDataType type, - const std::string& encapsulated_space) + const char* encapsulated_space) : name_(name), code_(code), type_(type), @@ -129,7 +129,7 @@ OptionDefinition::create(const std::string& name, const uint16_t code, const std::string& space, const std::string& type, - const std::string& encapsulated_space) { + const char* encapsulated_space) { return (boost::make_shared(name, code, space, type, encapsulated_space)); } @@ -138,7 +138,7 @@ OptionDefinition::create(const std::string& name, const uint16_t code, const std::string& space, const OptionDataType type, - const std::string& encapsulated_space) { + const char* encapsulated_space) { return (boost::make_shared(name, code, space, type, encapsulated_space)); } diff --git a/src/lib/dhcp/option_definition.h b/src/lib/dhcp/option_definition.h index b29898600c..5660d1b9d8 100644 --- a/src/lib/dhcp/option_definition.h +++ b/src/lib/dhcp/option_definition.h @@ -190,7 +190,7 @@ public: const uint16_t code, const std::string& space, const std::string& type, - const std::string& encapsulated_space); + const char* encapsulated_space); /// @brief Constructor. /// @@ -211,7 +211,7 @@ public: const uint16_t code, const std::string& space, const OptionDataType type, - const std::string& encapsulated_space); + const char* encapsulated_space); /// @brief Factory function creating an instance of the @c OptionDefinition. /// @@ -274,7 +274,7 @@ public: const uint16_t code, const std::string& space, const std::string& type, - const std::string& encapsulated_space); + const char* encapsulated_space); /// @brief Factory function creating an instance of the @c OptionDefinition. /// @@ -295,7 +295,7 @@ public: const uint16_t code, const std::string& space, const OptionDataType type, - const std::string& encapsulated_space); + const char* encapsulated_space); /// @name Comparison functions and operators. /// diff --git a/src/lib/dhcp/tests/libdhcp++_unittest.cc b/src/lib/dhcp/tests/libdhcp++_unittest.cc index b42d7d4694..7f29b336bd 100644 --- a/src/lib/dhcp/tests/libdhcp++_unittest.cc +++ b/src/lib/dhcp/tests/libdhcp++_unittest.cc @@ -184,7 +184,9 @@ public: std::ostringstream name; name << "name-for-option-" << code; OptionDefinitionPtr opt_def(new OptionDefinition(name.str(), - code, "string")); + code, + space_name.str(), + "string")); defs.addItem(opt_def, space_name.str()); } } @@ -539,6 +541,7 @@ TEST_F(LibDhcpTest, unpackOptions6) { TEST_F(LibDhcpTest, unpackEmptyOption6) { // Create option definition for the option code 1024 without fields. OptionDefinitionPtr opt_def(new OptionDefinition("option-empty", 1024, + DHCP6_OPTION_SPACE, "empty", false)); // Use it as runtime option definition within standard options space. @@ -579,20 +582,25 @@ TEST_F(LibDhcpTest, unpackSubOptions6) { // option code because they belong to different option spaces. // Top level option encapsulates options which belong to 'space-foo'. - OptionDefinitionPtr opt_def(new OptionDefinition("option-foobar", 1, "uint32", - "space-foo"));\ + OptionDefinitionPtr opt_def(new OptionDefinition("option-foobar", 1, + "space-foobar", + "uint32", + "space-foo")); // Middle option encapsulates options which belong to 'space-bar' - OptionDefinitionPtr opt_def2(new OptionDefinition("option-foo", 1, "uint16", + OptionDefinitionPtr opt_def2(new OptionDefinition("option-foo", 1, + "space-foo", + "uint16", "space-bar")); // Low level option doesn't encapsulate any option space. OptionDefinitionPtr opt_def3(new OptionDefinition("option-bar", 1, + "space-bar", "uint8")); // Register created option definitions as runtime option definitions. OptionDefSpaceContainer defs; - ASSERT_NO_THROW(defs.addItem(opt_def, "space-foobar")); - ASSERT_NO_THROW(defs.addItem(opt_def2, "space-foo")); - ASSERT_NO_THROW(defs.addItem(opt_def3, "space-bar")); + ASSERT_NO_THROW(defs.addItem(opt_def, opt_def->getOptionSpaceName())); + ASSERT_NO_THROW(defs.addItem(opt_def2, opt_def2->getOptionSpaceName())); + ASSERT_NO_THROW(defs.addItem(opt_def3, opt_def3->getOptionSpaceName())); LibDHCP::setRuntimeOptionDefs(defs); LibDHCP::commitRuntimeOptionDefs(); @@ -905,6 +913,7 @@ TEST_F(LibDhcpTest, unpackOptions4) { TEST_F(LibDhcpTest, unpackEmptyOption4) { // Create option definition for the option code 254 without fields. OptionDefinitionPtr opt_def(new OptionDefinition("option-empty", 254, + DHCP4_OPTION_SPACE, "empty", false)); // Use it as runtime option definition within standard options space. @@ -947,20 +956,25 @@ TEST_F(LibDhcpTest, unpackSubOptions4) { // option code because they belong to different option spaces. // Top level option encapsulates options which belong to 'space-foo'. - OptionDefinitionPtr opt_def(new OptionDefinition("option-foobar", 1, "uint32", - "space-foo"));\ + OptionDefinitionPtr opt_def(new OptionDefinition("option-foobar", 1, + "space-foobar", + "uint32", + "space-foo")); \ // Middle option encapsulates options which belong to 'space-bar' - OptionDefinitionPtr opt_def2(new OptionDefinition("option-foo", 1, "uint16", + OptionDefinitionPtr opt_def2(new OptionDefinition("option-foo", 1, + "space-foo", + "uint16", "space-bar")); // Low level option doesn't encapsulate any option space. OptionDefinitionPtr opt_def3(new OptionDefinition("option-bar", 1, + "space-bar", "uint8")); // Register created option definitions as runtime option definitions. OptionDefSpaceContainer defs; - ASSERT_NO_THROW(defs.addItem(opt_def, "space-foobar")); - ASSERT_NO_THROW(defs.addItem(opt_def2, "space-foo")); - ASSERT_NO_THROW(defs.addItem(opt_def3, "space-bar")); + ASSERT_NO_THROW(defs.addItem(opt_def, opt_def->getOptionSpaceName())); + ASSERT_NO_THROW(defs.addItem(opt_def2, opt_def2->getOptionSpaceName())); + ASSERT_NO_THROW(defs.addItem(opt_def3, opt_def3->getOptionSpaceName())); LibDHCP::setRuntimeOptionDefs(defs); LibDHCP::commitRuntimeOptionDefs(); @@ -1015,16 +1029,19 @@ TEST_F(LibDhcpTest, unpackSubOptions4) { TEST_F(LibDhcpTest, unpackPadEnd) { // Create option definition for the container. OptionDefinitionPtr opt_def(new OptionDefinition("container", 200, + DHCP4_OPTION_SPACE, "empty", "my-space")); // Create option definition for option 0. - OptionDefinitionPtr opt_def0(new OptionDefinition("zero", 0, "uint8")); + OptionDefinitionPtr opt_def0(new OptionDefinition("zero", 0, + "my-space", "uint8")); // Create option definition for option 255. - OptionDefinitionPtr opt_def255(new OptionDefinition("max", 255, "uint8")); + OptionDefinitionPtr opt_def255(new OptionDefinition("max", 255, + "my-space", "uint8")); // Create option definition for another option. OptionDefinitionPtr opt_def2(new OptionDefinition("my-option", 1, - "string")); + "my-space", "string")); // Register created option definitions as runtime option definitions. OptionDefSpaceContainer defs; @@ -1105,10 +1122,10 @@ TEST_F(LibDhcpTest, option43Pad) { string space = "my-option43-space"; // Create option definition for option 1. - OptionDefinitionPtr opt_def1(new OptionDefinition("one", 1, "binary")); + OptionDefinitionPtr opt_def1(new OptionDefinition("one", 1, space, "binary")); // Create option definition for option 2. - OptionDefinitionPtr opt_def2(new OptionDefinition("two", 2, "uint8")); + OptionDefinitionPtr opt_def2(new OptionDefinition("two", 2, space, "uint8")); // Register created option definitions as runtime option definitions. OptionDefSpaceContainer defs; @@ -1151,7 +1168,7 @@ TEST_F(LibDhcpTest, option43Pad) { EXPECT_EQ(1, sub2->getValue()); // Create option definition for option 0 and register it. - OptionDefinitionPtr opt_def0(new OptionDefinition("zero", 0, "uint8")); + OptionDefinitionPtr opt_def0(new OptionDefinition("zero", 0, space, "uint8")); ASSERT_NO_THROW(defs.addItem(opt_def0, space)); LibDHCP::clearRuntimeOptionDefs(); LibDHCP::setRuntimeOptionDefs(defs); @@ -1206,7 +1223,7 @@ TEST_F(LibDhcpTest, option43End) { // Create option definition for option 255. - OptionDefinitionPtr opt_def255(new OptionDefinition("max", 255, "uint8")); + OptionDefinitionPtr opt_def255(new OptionDefinition("max", 255, space, "uint8")); // Register created option definition as runtime option definitions. OptionDefSpaceContainer defs; diff --git a/src/lib/dhcp/tests/option_copy_unittest.cc b/src/lib/dhcp/tests/option_copy_unittest.cc index 233ffebf5a..78dbba12cb 100644 --- a/src/lib/dhcp/tests/option_copy_unittest.cc +++ b/src/lib/dhcp/tests/option_copy_unittest.cc @@ -1,4 +1,4 @@ -// Copyright (C) 2016 Internet Systems Consortium, Inc. ("ISC") +// Copyright (C) 2016-2020 Internet Systems Consortium, Inc. ("ISC") // // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this @@ -709,13 +709,13 @@ TEST(OptionCopyTest, option6ClientFqdnAssignment) { /// @param op_type Copy operation type. void testOptionCustom(const OpType& op_type) { // Create option with a single field carrying 16-bits integer. - OptionDefinition def("foo", 1, "uint16", true); + OptionDefinition def("foo", 1, "my-space", "uint16", true); OptionCustomPtr option(new OptionCustom(def, Option::V4)); option->addArrayDataField(5555); // Create option with two fields carrying IPv4 address and 32-bit // integer. - OptionDefinition def_copy("bar", 10, "record"); + OptionDefinition def_copy("bar", 10, "my-space", "record"); def_copy.addRecordField("ipv4-address"); def_copy.addRecordField("uint32"); OptionCustomPtr option_copy(new OptionCustom(def_copy, Option::V6)); diff --git a/src/lib/dhcp/tests/option_custom_unittest.cc b/src/lib/dhcp/tests/option_custom_unittest.cc index e0311e7c69..ca1a6740ad 100644 --- a/src/lib/dhcp/tests/option_custom_unittest.cc +++ b/src/lib/dhcp/tests/option_custom_unittest.cc @@ -1,4 +1,4 @@ -// Copyright (C) 2012-2017 Internet Systems Consortium, Inc. ("ISC") +// Copyright (C) 2012-2020 Internet Systems Consortium, Inc. ("ISC") // // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this @@ -137,7 +137,7 @@ public: // members. TEST_F(OptionCustomTest, constructor) { // Create option definition for a DHCPv6 option. - OptionDefinition opt_def1("OPTION_FOO", 1000, "boolean", true); + OptionDefinition opt_def1("OPTION_FOO", 1000, "my-space", "boolean", true); // Initialize some dummy buffer that holds single boolean value. OptionBuffer buf; @@ -155,7 +155,7 @@ TEST_F(OptionCustomTest, constructor) { EXPECT_EQ(1000, option->getType()); // Do another round of testing for DHCPv4 option. - OptionDefinition opt_def2("OPTION_FOO", 232, "boolean"); + OptionDefinition opt_def2("OPTION_FOO", 232, "my-space", "boolean"); ASSERT_NO_THROW( option.reset(new OptionCustom(opt_def2, Option::V4, buf.begin(), buf.end())); @@ -166,7 +166,7 @@ TEST_F(OptionCustomTest, constructor) { EXPECT_EQ(232, option->getType()); // Try to create an option using 'empty data' constructor - OptionDefinition opt_def3("OPTION_FOO", 1000, "uint32"); + OptionDefinition opt_def3("OPTION_FOO", 1000, "my-space", "uint32"); ASSERT_NO_THROW( option.reset(new OptionCustom(opt_def3, Option::V6)); @@ -180,7 +180,8 @@ TEST_F(OptionCustomTest, constructor) { // The purpose of this test is to verify that 'empty' option definition can // be used to create an instance of custom option. TEST_F(OptionCustomTest, emptyData) { - OptionDefinition opt_def("option-foo", 232, "empty", "option-foo-space"); + OptionDefinition opt_def("option-foo", 232, "my-space", "empty", + "option-foo-space"); // Create a buffer holding 1 suboption. OptionBuffer buf; @@ -204,7 +205,8 @@ TEST_F(OptionCustomTest, emptyData) { // The purpose of this test is to verify that the option definition comprising // a binary value can be used to create an instance of custom option. TEST_F(OptionCustomTest, binaryData) { - OptionDefinition opt_def("option-foo", 231, "binary", "option-foo-space"); + OptionDefinition opt_def("option-foo", 231, "my-space", "binary", + "option-foo-space"); // Create a buffer holding some binary data. This data will be // used as reference when we read back the data from a created @@ -258,7 +260,8 @@ TEST_F(OptionCustomTest, binaryData) { // The purpose of this test is to verify that an option definition comprising // a single boolean value can be used to create an instance of custom option. TEST_F(OptionCustomTest, booleanData) { - OptionDefinition opt_def("option-foo", 1000, "boolean", "option-foo-space"); + OptionDefinition opt_def("option-foo", 1000, "my-space", "boolean", + "option-foo-space"); OptionBuffer buf; // Push back the value that represents 'false'. @@ -300,7 +303,8 @@ TEST_F(OptionCustomTest, booleanData) { // The purpose of this test is to verify that the data from a buffer // can be read as a DHCPv4 tuple. TEST_F(OptionCustomTest, tupleData4) { - OptionDefinition opt_def("option-foo", 232, "tuple", "option-foo-space"); + OptionDefinition opt_def("option-foo", 232, "my-space", "tuple", + "option-foo-space"); const char data[] = { 6, 102, 111, 111, 98, 97, 114 // "foobar" @@ -352,7 +356,8 @@ TEST_F(OptionCustomTest, tupleData4) { // The purpose of this test is to verify that the data from a buffer // can be read as a DHCPv6 tuple. TEST_F(OptionCustomTest, tupleData6) { - OptionDefinition opt_def("option-foo", 1000, "tuple", "option-foo-space"); + OptionDefinition opt_def("option-foo", 1000, "my-space", "tuple", + "option-foo-space"); const char data[] = { 0, 6, 102, 111, 111, 98, 97, 114 // "foobar" @@ -403,7 +408,8 @@ TEST_F(OptionCustomTest, tupleData6) { // The purpose of this test is to verify that the data from a buffer // can be read as FQDN. TEST_F(OptionCustomTest, fqdnData) { - OptionDefinition opt_def("option-foo", 1000, "fqdn", "option-foo-space"); + OptionDefinition opt_def("option-foo", 1000, "my-space", "fqdn", + "option-foo-space"); const char data[] = { 8, 109, 121, 100, 111, 109, 97, 105, 110, // "mydomain" @@ -443,7 +449,8 @@ TEST_F(OptionCustomTest, fqdnData) { // The purpose of this test is to verify that the option definition comprising // 16-bit signed integer value can be used to create an instance of custom option. TEST_F(OptionCustomTest, int16Data) { - OptionDefinition opt_def("option-foo", 1000, "int16", "option-foo-space"); + OptionDefinition opt_def("option-foo", 1000, "my-space", "int16", + "option-foo-space"); OptionBuffer buf; // Store signed integer value in the input buffer. @@ -482,7 +489,8 @@ TEST_F(OptionCustomTest, int16Data) { // The purpose of this test is to verify that the option definition comprising // 32-bit signed integer value can be used to create an instance of custom option. TEST_F(OptionCustomTest, int32Data) { - OptionDefinition opt_def("option-foo", 1000, "int32", "option-foo-space"); + OptionDefinition opt_def("option-foo", 1000, "my-space", "int32", + "option-foo-space"); OptionBuffer buf; writeInt(-234, buf); @@ -520,7 +528,7 @@ TEST_F(OptionCustomTest, int32Data) { // The purpose of this test is to verify that the option definition comprising // single IPv4 address can be used to create an instance of custom option. TEST_F(OptionCustomTest, ipv4AddressData) { - OptionDefinition opt_def("OPTION_FOO", 231, "ipv4-address", + OptionDefinition opt_def("OPTION_FOO", 231, "my-space", "ipv4-address", "option-foo-space"); // Create input buffer. @@ -560,7 +568,7 @@ TEST_F(OptionCustomTest, ipv4AddressData) { // The purpose of this test is to verify that the option definition comprising // single IPv6 address can be used to create an instance of custom option. TEST_F(OptionCustomTest, ipv6AddressData) { - OptionDefinition opt_def("option-foo", 1000, "ipv6-address", + OptionDefinition opt_def("option-foo", 1000, "my-space", "ipv6-address", "option-foo-space"); // Initialize input buffer. @@ -604,7 +612,7 @@ TEST_F(OptionCustomTest, ipv6AddressData) { // single variable length prefix can be used to create an instance of custom // option. TEST_F(OptionCustomTest, prefixData) { - OptionDefinition opt_def("option-foo", 1000, "ipv6-prefix", + OptionDefinition opt_def("option-foo", 1000, "my-space", "ipv6-prefix", "option-foo-space"); // Initialize input buffer. @@ -642,7 +650,7 @@ TEST_F(OptionCustomTest, prefixData) { // The purpose of this test is to verify that the option definition comprising // single PSID can be used to create an instance of custom option. TEST_F(OptionCustomTest, psidData) { - OptionDefinition opt_def("option-foo", 1000, "psid", + OptionDefinition opt_def("option-foo", 1000, "my-space", "psid", "option-foo-space"); // Initialize input buffer. @@ -680,7 +688,8 @@ TEST_F(OptionCustomTest, psidData) { // The purpose of this test is to verify that the option definition comprising // string value can be used to create an instance of custom option. TEST_F(OptionCustomTest, stringData) { - OptionDefinition opt_def("option-foo", 1000, "string", "option-foo-space"); + OptionDefinition opt_def("option-foo", 1000, "my-space", "string", + "option-foo-space"); // Create an input buffer holding some string value. OptionBuffer buf; @@ -728,7 +737,7 @@ TEST_F(OptionCustomTest, stringData) { // The purpose of this test is to verify that the option definition comprising // an array of boolean values can be used to create an instance of custom option. TEST_F(OptionCustomTest, booleanDataArray) { - OptionDefinition opt_def("option-foo", 1000, "boolean", true); + OptionDefinition opt_def("option-foo", 1000, "my-space", "boolean", true); // Create a buffer with 5 values that represent array of // booleans. @@ -784,7 +793,7 @@ TEST_F(OptionCustomTest, booleanDataArray) { // an array of 32-bit signed integer values can be used to create an instance // of custom option. TEST_F(OptionCustomTest, uint32DataArray) { - OptionDefinition opt_def("option-foo", 1000, "uint32", true); + OptionDefinition opt_def("option-foo", 1000, "my-space", "uint32", true); // Create an input buffer that holds 4 uint32 values that // represent an array. @@ -832,7 +841,8 @@ TEST_F(OptionCustomTest, uint32DataArray) { // The purpose of this test is to verify that the option definition comprising // an array of IPv4 addresses can be used to create an instance of custom option. TEST_F(OptionCustomTest, ipv4AddressDataArray) { - OptionDefinition opt_def("OPTION_FOO", 231, "ipv4-address", true); + OptionDefinition opt_def("OPTION_FOO", 231, "my-space", "ipv4-address", + true); // Initialize reference data. std::vector addresses; @@ -882,7 +892,8 @@ TEST_F(OptionCustomTest, ipv4AddressDataArray) { // The purpose of this test is to verify that the option definition comprising // an array of IPv6 addresses can be used to create an instance of custom option. TEST_F(OptionCustomTest, ipv6AddressDataArray) { - OptionDefinition opt_def("OPTION_FOO", 1000, "ipv6-address", true); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "ipv6-address", + true); // Initialize reference data. std::vector addresses; @@ -934,7 +945,7 @@ TEST_F(OptionCustomTest, ipv6AddressDataArray) { // multiple FQDN values encoded as described in the RFC1035, section // 3.1 TEST_F(OptionCustomTest, fqdnDataArray) { - OptionDefinition opt_def("OPTION_FOO", 1000, "fqdn", true); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "fqdn", true); const char data[] = { 8, 109, 121, 100, 111, 109, 97, 105, 110, // "mydomain" @@ -971,7 +982,8 @@ TEST_F(OptionCustomTest, fqdnDataArray) { // The purpose of this test is to verify that the option definition comprising // an array of IPv6 prefixes can be used to create an instance of OptionCustom. TEST_F(OptionCustomTest, prefixDataArray) { - OptionDefinition opt_def("option-foo", 1000, "ipv6-prefix", true); + OptionDefinition opt_def("option-foo", 1000, "my-space", "ipv6-prefix", + true); // The following buffer comprises three prefixes with different // prefix lengths. @@ -1016,7 +1028,7 @@ TEST_F(OptionCustomTest, prefixDataArray) { // The purpose of this test is to verify that the option definition comprising // an array of PSIDs can be used to create an instance of OptionCustom. TEST_F(OptionCustomTest, psidDataArray) { - OptionDefinition opt_def("option-foo", 1000, "psid", true); + OptionDefinition opt_def("option-foo", 1000, "my-space", "psid", true); // The following buffer comprises three PSIDs. const uint8_t data[] = { @@ -1062,7 +1074,7 @@ TEST_F(OptionCustomTest, psidDataArray) { // The purpose of this test is to verify that the data from a buffer // can be read as DHCPv4 tuples. TEST_F(OptionCustomTest, tupleDataArray4) { - OptionDefinition opt_def("option-foo", 232, "tuple", true); + OptionDefinition opt_def("option-foo", 232, "my-space", "tuple", true); const char data[] = { 5, 104, 101, 108, 108, 111, // "hello" @@ -1104,7 +1116,7 @@ TEST_F(OptionCustomTest, tupleDataArray4) { // The purpose of this test is to verify that the data from a buffer // can be read as DHCPv6 tuples. TEST_F(OptionCustomTest, tupleDataArray6) { - OptionDefinition opt_def("option-foo", 1000, "tuple", true); + OptionDefinition opt_def("option-foo", 1000, "my-space", "tuple", true); const char data[] = { 0, 5, 104, 101, 108, 108, 111, // "hello" @@ -1153,7 +1165,8 @@ TEST_F(OptionCustomTest, tupleDataArray6) { // a record of fixed-size fields can be used to create an option with a // suboption. TEST_F(OptionCustomTest, recordDataWithSuboption) { - OptionDefinition opt_def("option-foo", 1000, "record", "option-foo-space"); + OptionDefinition opt_def("option-foo", 1000, "my-space", "record", + "option-foo-space"); ASSERT_NO_THROW(opt_def.addRecordField("uint32")); ASSERT_NO_THROW(opt_def.addRecordField("ipv4-address")); @@ -1196,7 +1209,7 @@ TEST_F(OptionCustomTest, recordDataWithSuboption) { TEST_F(OptionCustomTest, recordData) { // Create the definition of an option which comprises // a record of fields of different types. - OptionDefinition opt_def("OPTION_FOO", 1000, "record"); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "record"); ASSERT_NO_THROW(opt_def.addRecordField("uint16")); ASSERT_NO_THROW(opt_def.addRecordField("boolean")); ASSERT_NO_THROW(opt_def.addRecordField("fqdn")); @@ -1281,7 +1294,7 @@ TEST_F(OptionCustomTest, recordData) { TEST_F(OptionCustomTest, recordArrayData) { // Create the definition of an option which comprises // a record of fields of different types. - OptionDefinition opt_def("OPTION_FOO", 1000, "record", true); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "record", true); ASSERT_NO_THROW(opt_def.addRecordField("uint16")); ASSERT_NO_THROW(opt_def.addRecordField("boolean")); ASSERT_NO_THROW(opt_def.addRecordField("fqdn")); @@ -1372,7 +1385,7 @@ TEST_F(OptionCustomTest, recordArrayData) { TEST_F(OptionCustomTest, recordDataTruncated) { // Create the definition of an option which comprises // a record of fields of different types. - OptionDefinition opt_def("OPTION_FOO", 1000, "record"); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "record"); ASSERT_NO_THROW(opt_def.addRecordField("uint16")); ASSERT_NO_THROW(opt_def.addRecordField("ipv6-address")); ASSERT_NO_THROW(opt_def.addRecordField("string")); @@ -1426,7 +1439,7 @@ TEST_F(OptionCustomTest, recordDataTruncated) { // test also checks that it is possible to override this default // value. TEST_F(OptionCustomTest, setBinaryData) { - OptionDefinition opt_def("OPTION_FOO", 1000, "binary"); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "binary"); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1458,7 +1471,7 @@ TEST_F(OptionCustomTest, setBinaryData) { // single boolean data field can be created and that its default // value can be overridden by a new value. TEST_F(OptionCustomTest, setBooleanData) { - OptionDefinition opt_def("OPTION_FOO", 1000, "boolean"); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "boolean"); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1483,7 +1496,7 @@ TEST_F(OptionCustomTest, setBooleanData) { TEST_F(OptionCustomTest, setUint32Data) { // Create a definition of an option that holds single // uint32 value. - OptionDefinition opt_def("OPTION_FOO", 1000, "uint32"); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "uint32"); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1511,7 +1524,7 @@ TEST_F(OptionCustomTest, setUint32Data) { // single IPv4 address can be created and that this address can // be overridden by a new value. TEST_F(OptionCustomTest, setIpv4AddressData) { - OptionDefinition opt_def("OPTION_FOO", 232, "ipv4-address"); + OptionDefinition opt_def("OPTION_FOO", 232, "my-space", "ipv4-address"); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1535,7 +1548,7 @@ TEST_F(OptionCustomTest, setIpv4AddressData) { // single IPv6 address can be created and that this address can // be overridden by a new value. TEST_F(OptionCustomTest, setIpv6AddressData) { - OptionDefinition opt_def("OPTION_FOO", 1000, "ipv6-address"); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "ipv6-address"); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1559,7 +1572,7 @@ TEST_F(OptionCustomTest, setIpv6AddressData) { // a prefix can be created and that the prefix can be overridden by // a new value. TEST_F(OptionCustomTest, setPrefixData) { - OptionDefinition opt_def("option-foo", 1000, "ipv6-prefix"); + OptionDefinition opt_def("option-foo", 1000, "my-space", "ipv6-prefix"); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1588,7 +1601,7 @@ TEST_F(OptionCustomTest, setPrefixData) { // a single PSID can be created and that the PSID can be overridden // by a new value. TEST_F(OptionCustomTest, setPsidData) { - OptionDefinition opt_def("option-foo", 1000, "psid"); + OptionDefinition opt_def("option-foo", 1000, "my-space", "psid"); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1618,7 +1631,7 @@ TEST_F(OptionCustomTest, setPsidData) { // is initialized to the default value. Also, this test checks that // this value can be overwritten by a new value. TEST_F(OptionCustomTest, setStringData) { - OptionDefinition opt_def("OPTION_FOO", 1000, "string"); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "string"); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1644,7 +1657,7 @@ TEST_F(OptionCustomTest, setStringData) { /// a default FQDN value can be created and that this value can be /// overridden after the option has been created. TEST_F(OptionCustomTest, setFqdnData) { - OptionDefinition opt_def("OPTION_FOO", 1000, "fqdn"); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "fqdn"); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1668,7 +1681,7 @@ TEST_F(OptionCustomTest, setFqdnData) { // an array of boolean values can be created with no values // initially and that values can be later added to it. TEST_F(OptionCustomTest, setBooleanDataArray) { - OptionDefinition opt_def("OPTION_FOO", 1000, "boolean", true); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "boolean", true); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1702,7 +1715,7 @@ TEST_F(OptionCustomTest, setBooleanDataArray) { // an array of 16-bit signed integer values can be created with // no values initially and that the values can be later added to it. TEST_F(OptionCustomTest, setUint16DataArray) { - OptionDefinition opt_def("OPTION_FOO", 1000, "uint16", true); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "uint16", true); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1739,7 +1752,8 @@ TEST_F(OptionCustomTest, setUint16DataArray) { /// array of IPv4 address can be created with no addresses and that /// multiple IPv4 addresses can be added to it after creation. TEST_F(OptionCustomTest, setIpv4AddressDataArray) { - OptionDefinition opt_def("OPTION_FOO", 232, "ipv4-address", true); + OptionDefinition opt_def("OPTION_FOO", 232, "my-space", "ipv4-address", + true); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1781,7 +1795,8 @@ TEST_F(OptionCustomTest, setIpv4AddressDataArray) { /// array of IPv6 address can be created with no addresses and that /// multiple IPv6 addresses can be added to it after creation. TEST_F(OptionCustomTest, setIpv6AddressDataArray) { - OptionDefinition opt_def("OPTION_FOO", 1000, "ipv6-address", true); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "ipv6-address", + true); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1824,7 +1839,7 @@ TEST_F(OptionCustomTest, setIpv6AddressDataArray) { /// array of PSIDs can be created with no PSIDs and that PSIDs can be /// later added after the option has been created. TEST_F(OptionCustomTest, setPSIDPrefixArray) { - OptionDefinition opt_def("option-foo", 1000, "psid", true); + OptionDefinition opt_def("option-foo", 1000, "my-space", "psid", true); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1866,7 +1881,8 @@ TEST_F(OptionCustomTest, setPSIDPrefixArray) { /// array of IPv6 prefixes can be created with no prefixes and that /// prefixes can be later added after the option has been created. TEST_F(OptionCustomTest, setIPv6PrefixDataArray) { - OptionDefinition opt_def("option-foo", 1000, "ipv6-prefix", true); + OptionDefinition opt_def("option-foo", 1000, "my-space", "ipv6-prefix", + true); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1914,7 +1930,7 @@ TEST_F(OptionCustomTest, setIPv6PrefixDataArray) { /// array of DHCPv4 tuples can be created with no tuples and that /// tuples can be later added after the option has been created. TEST_F(OptionCustomTest, setTupleDataArray4) { - OptionDefinition opt_def("option-foo", 232, "tuple", true); + OptionDefinition opt_def("option-foo", 232, "my-space", "tuple", true); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -1959,7 +1975,7 @@ TEST_F(OptionCustomTest, setTupleDataArray4) { /// array of DHCPv6 tuples can be created with no tuples and that /// tuples can be later added after the option has been created. TEST_F(OptionCustomTest, setTupleDataArray6) { - OptionDefinition opt_def("option-foo", 1000, "tuple", true); + OptionDefinition opt_def("option-foo", 1000, "my-space", "tuple", true); // Create an option and let the data field be initialized // to default value (do not provide any data buffer). @@ -2001,7 +2017,7 @@ TEST_F(OptionCustomTest, setTupleDataArray6) { } TEST_F(OptionCustomTest, setRecordData) { - OptionDefinition opt_def("OPTION_FOO", 1000, "record"); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "record"); ASSERT_NO_THROW(opt_def.addRecordField("uint16")); ASSERT_NO_THROW(opt_def.addRecordField("boolean")); @@ -2092,7 +2108,7 @@ TEST_F(OptionCustomTest, setRecordData) { } TEST_F(OptionCustomTest, setRecordArrayData) { - OptionDefinition opt_def("OPTION_FOO", 1000, "record", true); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "record", true); ASSERT_NO_THROW(opt_def.addRecordField("uint16")); ASSERT_NO_THROW(opt_def.addRecordField("boolean")); @@ -2191,7 +2207,7 @@ TEST_F(OptionCustomTest, setRecordArrayData) { // The purpose of this test is to verify that pack function for // DHCPv4 custom option works correctly. TEST_F(OptionCustomTest, pack4) { - OptionDefinition opt_def("OPTION_FOO", 234, "record"); + OptionDefinition opt_def("OPTION_FOO", 234, "my-space", "record"); ASSERT_NO_THROW(opt_def.addRecordField("uint8")); ASSERT_NO_THROW(opt_def.addRecordField("uint16")); ASSERT_NO_THROW(opt_def.addRecordField("uint32")); @@ -2224,7 +2240,7 @@ TEST_F(OptionCustomTest, pack4) { // The purpose of this test is to verify that pack function for // DHCPv6 custom option works correctly. TEST_F(OptionCustomTest, pack6) { - OptionDefinition opt_def("OPTION_FOO", 1000, "record"); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "record"); ASSERT_NO_THROW(opt_def.addRecordField("boolean")); ASSERT_NO_THROW(opt_def.addRecordField("uint16")); ASSERT_NO_THROW(opt_def.addRecordField("string")); @@ -2259,7 +2275,8 @@ TEST_F(OptionCustomTest, pack6) { // The purpose of this test is to verify that unpack function works // correctly for a custom option. TEST_F(OptionCustomTest, unpack) { - OptionDefinition opt_def("OPTION_FOO", 231, "ipv4-address", true); + OptionDefinition opt_def("OPTION_FOO", 231, "my-space", "ipv4-address", + true); // Initialize reference data. std::vector addresses; @@ -2321,7 +2338,7 @@ TEST_F(OptionCustomTest, unpack) { // The purpose of this test is to verify that unpack function works // correctly for a custom option with record and trailing array. TEST_F(OptionCustomTest, unpackRecordArray) { - OptionDefinition opt_def("OPTION_FOO", 231, "record", true); + OptionDefinition opt_def("OPTION_FOO", 231, "my-space", "record", true); ASSERT_NO_THROW(opt_def.addRecordField("uint16")); ASSERT_NO_THROW(opt_def.addRecordField("ipv4-address")); @@ -2370,7 +2387,8 @@ TEST_F(OptionCustomTest, unpackRecordArray) { // The purpose of this test is to verify that new data can be set for // a custom option. TEST_F(OptionCustomTest, initialize) { - OptionDefinition opt_def("OPTION_FOO", 1000, "ipv6-address", true); + OptionDefinition opt_def("OPTION_FOO", 1000, "my-space", "ipv6-address", + true); // Initialize reference data. std::vector addresses; @@ -2431,7 +2449,7 @@ TEST_F(OptionCustomTest, initialize) { // The purpose of this test is to verify that an invalid index // value can't be used to access option data fields. TEST_F(OptionCustomTest, invalidIndex) { - OptionDefinition opt_def("OPTION_FOO", 999, "uint32", true); + OptionDefinition opt_def("OPTION_FOO", 999, "my-space", "uint32", true); OptionBuffer buf; for (int i = 0; i < 10; ++i) { @@ -2458,7 +2476,7 @@ TEST_F(OptionCustomTest, invalidIndex) { // This test checks that the custom option holding a record of data // fields can be presented in the textual format. TEST_F(OptionCustomTest, toTextRecord) { - OptionDefinition opt_def("foo", 123, "record"); + OptionDefinition opt_def("foo", 123, "my-space", "record"); opt_def.addRecordField("uint32"); opt_def.addRecordField("string"); @@ -2473,12 +2491,12 @@ TEST_F(OptionCustomTest, toTextRecord) { // This test checks that the custom option holding other data type // than "record" be presented in the textual format. TEST_F(OptionCustomTest, toTextNoRecord) { - OptionDefinition opt_def("foo", 234, "uint32"); + OptionDefinition opt_def("foo", 234, "my-space", "uint32"); OptionCustom option(opt_def, Option::V6); option.writeInteger(123456); - OptionDefinition sub_opt_def("bar", 333, "fqdn"); + OptionDefinition sub_opt_def("bar", 333, "my-space", "fqdn"); OptionCustomPtr sub_opt(new OptionCustom(sub_opt_def, Option::V6)); sub_opt->writeFqdn("myhost.example.org."); option.addOption(sub_opt); diff --git a/src/lib/dhcp/tests/option_definition_unittest.cc b/src/lib/dhcp/tests/option_definition_unittest.cc index c31cbb9fe7..a4447e0313 100644 --- a/src/lib/dhcp/tests/option_definition_unittest.cc +++ b/src/lib/dhcp/tests/option_definition_unittest.cc @@ -1,4 +1,4 @@ -// Copyright (C) 2012-2019 Internet Systems Consortium, Inc. ("ISC") +// Copyright (C) 2012-2020 Internet Systems Consortium, Inc. ("ISC") // // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this @@ -48,20 +48,22 @@ public: TEST_F(OptionDefinitionTest, constructor) { // Specify the option data type as string. This should get converted // to enum value returned by getType(). - OptionDefinition opt_def1("OPTION_CLIENTID", D6O_CLIENTID, "string"); + OptionDefinition opt_def1("OPTION_CLIENTID", D6O_CLIENTID, + DHCP6_OPTION_SPACE, "string"); EXPECT_EQ("OPTION_CLIENTID", opt_def1.getName()); - EXPECT_EQ(1, opt_def1.getCode()); - EXPECT_EQ(OPT_STRING_TYPE, opt_def1.getType()); + EXPECT_EQ(DHCP6_OPTION_SPACE, opt_def1.getOptionSpaceName()); + EXPECT_EQ(OPT_STRING_TYPE, opt_def1.getType()); EXPECT_FALSE(opt_def1.getArrayType()); EXPECT_TRUE(opt_def1.getEncapsulatedSpace().empty()); EXPECT_NO_THROW(opt_def1.validate()); // Specify the option data type as an enum value. OptionDefinition opt_def2("OPTION_RAPID_COMMIT", D6O_RAPID_COMMIT, - OPT_EMPTY_TYPE); + DHCP6_OPTION_SPACE, OPT_EMPTY_TYPE); EXPECT_EQ("OPTION_RAPID_COMMIT", opt_def2.getName()); EXPECT_EQ(14, opt_def2.getCode()); + EXPECT_EQ(DHCP6_OPTION_SPACE, opt_def2.getOptionSpaceName()); EXPECT_EQ(OPT_EMPTY_TYPE, opt_def2.getType()); EXPECT_FALSE(opt_def2.getArrayType()); EXPECT_TRUE(opt_def2.getEncapsulatedSpace().empty()); @@ -70,9 +72,10 @@ TEST_F(OptionDefinitionTest, constructor) { // Specify encapsulated option space name and option data type // as enum value. OptionDefinition opt_def3("OPTION_VENDOR_OPTS", D6O_VENDOR_OPTS, - OPT_UINT32_TYPE, "isc"); + DHCP6_OPTION_SPACE, OPT_UINT32_TYPE, "isc"); EXPECT_EQ("OPTION_VENDOR_OPTS", opt_def3.getName()); EXPECT_EQ(D6O_VENDOR_OPTS, opt_def3.getCode()); + EXPECT_EQ(DHCP6_OPTION_SPACE, opt_def3.getOptionSpaceName()); EXPECT_EQ(OPT_UINT32_TYPE, opt_def3.getType()); EXPECT_FALSE(opt_def3.getArrayType()); EXPECT_EQ("isc", opt_def3.getEncapsulatedSpace()); @@ -81,9 +84,10 @@ TEST_F(OptionDefinitionTest, constructor) { // Specify encapsulated option space name and option data type // as string value. OptionDefinition opt_def4("OPTION_VENDOR_OPTS", D6O_VENDOR_OPTS, - "uint32", "isc"); + DHCP6_OPTION_SPACE, "uint32", "isc"); EXPECT_EQ("OPTION_VENDOR_OPTS", opt_def4.getName()); EXPECT_EQ(D6O_VENDOR_OPTS, opt_def4.getCode()); + EXPECT_EQ(DHCP6_OPTION_SPACE, opt_def4.getOptionSpaceName()); EXPECT_EQ(OPT_UINT32_TYPE, opt_def4.getType()); EXPECT_FALSE(opt_def4.getArrayType()); EXPECT_EQ("isc", opt_def4.getEncapsulatedSpace()); @@ -91,10 +95,12 @@ TEST_F(OptionDefinitionTest, constructor) { // Check if it is possible to set that option is an array. OptionDefinition opt_def5("OPTION_NIS_SERVERS", 27, + DHCP6_OPTION_SPACE, OPT_IPV6_ADDRESS_TYPE, true); EXPECT_EQ("OPTION_NIS_SERVERS", opt_def5.getName()); EXPECT_EQ(27, opt_def5.getCode()); + EXPECT_EQ(DHCP6_OPTION_SPACE, opt_def5.getOptionSpaceName()); EXPECT_EQ(OPT_IPV6_ADDRESS_TYPE, opt_def5.getType()); EXPECT_TRUE(opt_def5.getArrayType()); EXPECT_NO_THROW(opt_def5.validate()); @@ -105,19 +111,21 @@ TEST_F(OptionDefinitionTest, constructor) { EXPECT_NO_THROW( OptionDefinition opt_def6("OPTION_SERVERID", OPT_UNKNOWN_TYPE + 10, + DHCP6_OPTION_SPACE, OPT_STRING_TYPE); ); } // This test checks that the copy constructor works properly. TEST_F(OptionDefinitionTest, copyConstructor) { - OptionDefinition opt_def("option-foo", 27, "record", true); + OptionDefinition opt_def("option-foo", 27, "my-space", "record", true); ASSERT_NO_THROW(opt_def.addRecordField("uint16")); ASSERT_NO_THROW(opt_def.addRecordField("string")); OptionDefinition opt_def_copy(opt_def); EXPECT_EQ("option-foo", opt_def_copy.getName()); EXPECT_EQ(27, opt_def_copy.getCode()); + EXPECT_EQ("my-space", opt_def_copy.getOptionSpaceName()); EXPECT_TRUE(opt_def_copy.getArrayType()); EXPECT_TRUE(opt_def_copy.getEncapsulatedSpace().empty()); ASSERT_EQ(OPT_RECORD_TYPE, opt_def_copy.getType()); @@ -129,10 +137,11 @@ TEST_F(OptionDefinitionTest, copyConstructor) { // Let's make another test to check if encapsulated option space is // copied properly. - OptionDefinition opt_def2("option-bar", 30, "uint32", "isc"); + OptionDefinition opt_def2("option-bar", 30, "my-space", "uint32", "isc"); OptionDefinition opt_def_copy2(opt_def2); EXPECT_EQ("option-bar", opt_def_copy2.getName()); EXPECT_EQ(30, opt_def_copy2.getCode()); + EXPECT_EQ("my-space", opt_def_copy2.getOptionSpaceName()); EXPECT_FALSE(opt_def_copy2.getArrayType()); EXPECT_EQ(OPT_UINT32_TYPE, opt_def_copy2.getType()); EXPECT_EQ("isc", opt_def_copy2.getEncapsulatedSpace()); @@ -141,11 +150,13 @@ TEST_F(OptionDefinitionTest, copyConstructor) { // This test checks that the factory function taking string option // data type as argument creates a valid instance. TEST_F(OptionDefinitionTest, createStringType) { - auto def = OptionDefinition::create("option-foo", 123, "uint16", "isc"); + auto def = OptionDefinition::create("option-foo", 123, "my-space", + "uint16", "isc"); ASSERT_TRUE(def); EXPECT_EQ("option-foo", def->getName()); EXPECT_EQ(123, def->getCode()); + EXPECT_EQ("my-space", def->getOptionSpaceName()); EXPECT_EQ(OPT_UINT16_TYPE, def->getType()); EXPECT_FALSE(def->getArrayType()); EXPECT_EQ("isc", def->getEncapsulatedSpace()); @@ -154,11 +165,13 @@ TEST_F(OptionDefinitionTest, createStringType) { // This test checks that the factory function taking enum option // data type as argument creates a valid instance. TEST_F(OptionDefinitionTest, createEnumType) { - auto def = OptionDefinition::create("option-foo", 123, OPT_UINT16_TYPE, "isc"); + auto def = OptionDefinition::create("option-foo", 123, "my-space", + OPT_UINT16_TYPE, "isc"); ASSERT_TRUE(def); EXPECT_EQ("option-foo", def->getName()); EXPECT_EQ(123, def->getCode()); + EXPECT_EQ("my-space", def->getOptionSpaceName()); EXPECT_EQ(OPT_UINT16_TYPE, def->getType()); EXPECT_FALSE(def->getArrayType()); EXPECT_EQ("isc", def->getEncapsulatedSpace()); @@ -167,11 +180,13 @@ TEST_F(OptionDefinitionTest, createEnumType) { // This test checks that the factory function creating an array and // taking string option data type as argument creates a valid instance. TEST_F(OptionDefinitionTest, createStringTypeArray) { - auto def = OptionDefinition::create("option-foo", 123, "uint16", true); + auto def = OptionDefinition::create("option-foo", 123, "my-space", + "uint16", true); ASSERT_TRUE(def); EXPECT_EQ("option-foo", def->getName()); EXPECT_EQ(123, def->getCode()); + EXPECT_EQ("my-space", def->getOptionSpaceName()); EXPECT_EQ(OPT_UINT16_TYPE, def->getType()); EXPECT_TRUE(def->getArrayType()); EXPECT_TRUE(def->getEncapsulatedSpace().empty()); @@ -180,11 +195,13 @@ TEST_F(OptionDefinitionTest, createStringTypeArray) { // This test checks that the factory function creating an array and // taking enum option data type as argument creates a valid instance. TEST_F(OptionDefinitionTest, createEnumTypeArray) { - auto def = OptionDefinition::create("option-foo", 123, OPT_UINT16_TYPE, true); + auto def = OptionDefinition::create("option-foo", 123, "my-space", + OPT_UINT16_TYPE, true); ASSERT_TRUE(def); EXPECT_EQ("option-foo", def->getName()); EXPECT_EQ(123, def->getCode()); + EXPECT_EQ("my-space", def->getOptionSpaceName()); EXPECT_EQ(OPT_UINT16_TYPE, def->getType()); EXPECT_TRUE(def->getArrayType()); EXPECT_TRUE(def->getEncapsulatedSpace().empty()); @@ -193,40 +210,46 @@ TEST_F(OptionDefinitionTest, createEnumTypeArray) { // This test checks that two option definitions may be compared for equality. TEST_F(OptionDefinitionTest, equality) { // Equal definitions. - EXPECT_TRUE(OptionDefinition("option-foo", 5, "uint16", false) - == OptionDefinition("option-foo", 5, "uint16", false)); - EXPECT_FALSE(OptionDefinition("option-foo", 5, "uint16", false) - != OptionDefinition("option-foo", 5, "uint16", false)); + EXPECT_TRUE(OptionDefinition("option-foo", 5, "my-space", "uint16", false) + == OptionDefinition("option-foo", 5, "my-space", "uint16", false)); + EXPECT_FALSE(OptionDefinition("option-foo", 5, "my-space", "uint16", false) + != OptionDefinition("option-foo", 5, "my-space", "uint16", false)); // Differ by name. - EXPECT_FALSE(OptionDefinition("option-foo", 5, "uint16", false) - == OptionDefinition("option-foobar", 5, "uint16", false)); - EXPECT_FALSE(OptionDefinition("option-bar", 5, "uint16", false) - == OptionDefinition("option-foo", 5, "uint16", false)); - EXPECT_TRUE(OptionDefinition("option-bar", 5, "uint16", false) - != OptionDefinition("option-foo", 5, "uint16", false)); + EXPECT_FALSE(OptionDefinition("option-foo", 5, "my-space", "uint16", false) + == OptionDefinition("option-foobar", 5, "my-space", "uint16", false)); + EXPECT_FALSE(OptionDefinition("option-bar", 5, "my-space", "uint16", false) + == OptionDefinition("option-foo", 5, "my-space", "uint16", false)); + EXPECT_TRUE(OptionDefinition("option-bar", 5, "my-space", "uint16", false) + != OptionDefinition("option-foo", 5, "my-space", "uint16", false)); // Differ by option code. - EXPECT_FALSE(OptionDefinition("option-foo", 5, "uint16", false) - == OptionDefinition("option-foo", 6, "uint16", false)); - EXPECT_TRUE(OptionDefinition("option-foo", 5, "uint16", false) - != OptionDefinition("option-foo", 6, "uint16", false)); + EXPECT_FALSE(OptionDefinition("option-foo", 5, "my-space", "uint16", false) + == OptionDefinition("option-foo", 6, "my-space", "uint16", false)); + EXPECT_TRUE(OptionDefinition("option-foo", 5, "my-space", "uint16", false) + != OptionDefinition("option-foo", 6, "my-space", "uint16", false)); + + // Differ by option space name. + EXPECT_FALSE(OptionDefinition("option-foo", 5, "my-space", "uint16", false) + == OptionDefinition("option-foo", 5, "mi-space", "uint16", false)); + EXPECT_TRUE(OptionDefinition("option-foo", 5, "my-space", "uint16", false) + != OptionDefinition("option-foo", 5, "mi-space", "uint16", false)); // Differ by type of the data. - EXPECT_FALSE(OptionDefinition("option-foo", 5, "uint16", false) - == OptionDefinition("option-foo", 5, "uint32", false)); - EXPECT_TRUE(OptionDefinition("option-foo", 5, "uint16", false) - != OptionDefinition("option-foo", 5, "uint32", false)); + EXPECT_FALSE(OptionDefinition("option-foo", 5, "my-space", "uint16", false) + == OptionDefinition("option-foo", 5, "my-space", "uint32", false)); + EXPECT_TRUE(OptionDefinition("option-foo", 5, "my-space", "uint16", false) + != OptionDefinition("option-foo", 5, "my-space", "uint32", false)); // Differ by array-type property. - EXPECT_FALSE(OptionDefinition("option-foo", 5, "uint16", false) - == OptionDefinition("option-foo", 5, "uint16", true)); - EXPECT_TRUE(OptionDefinition("option-foo", 5, "uint16", false) - != OptionDefinition("option-foo", 5, "uint16", true)); + EXPECT_FALSE(OptionDefinition("option-foo", 5, "my-space", "uint16", false) + == OptionDefinition("option-foo", 5, "my-space", "uint16", true)); + EXPECT_TRUE(OptionDefinition("option-foo", 5, "my-space", "uint16", false) + != OptionDefinition("option-foo", 5, "my-space", "uint16", true)); // Differ by record fields. - OptionDefinition def1("option-foo", 5, "record"); - OptionDefinition def2("option-foo", 5, "record"); + OptionDefinition def1("option-foo", 5, "my-space", "record"); + OptionDefinition def2("option-foo", 5, "my-space", "record"); // There are no record fields specified yet, so initially they have // to be equal. @@ -268,13 +291,13 @@ TEST_F(OptionDefinitionTest, addRecordField) { if (i == OPT_RECORD_TYPE) { continue; } - OptionDefinition opt_def("OPTION_IAADDR", 5, + OptionDefinition opt_def("OPTION_IAADDR", 5, DHCP6_OPTION_SPACE, static_cast(i)); EXPECT_THROW(opt_def.addRecordField("uint8"), isc::InvalidOperation); } // Positive scenario starts here. - OptionDefinition opt_def("OPTION_IAADDR", 5, "record"); + OptionDefinition opt_def("OPTION_IAADDR", 5, DHCP6_OPTION_SPACE, "record"); EXPECT_NO_THROW(opt_def.addRecordField("ipv6-address")); EXPECT_NO_THROW(opt_def.addRecordField("uint32")); // It should not matter if we specify field type by its name or using enum. @@ -295,7 +318,7 @@ TEST_F(OptionDefinitionTest, addRecordField) { // It is bad if we use 'record' option type but don't specify // at least two fields. - OptionDefinition opt_def2("OPTION_EMPTY_RECORD", 100, "record"); + OptionDefinition opt_def2("OPTION_EMPTY_RECORD", 100, "my-space", "record"); EXPECT_THROW(opt_def2.validate(), MalformedOptionDefinition); opt_def2.addRecordField("uint8"); EXPECT_THROW(opt_def2.validate(), MalformedOptionDefinition); @@ -307,89 +330,150 @@ TEST_F(OptionDefinitionTest, addRecordField) { // reports errors for invalid option definitions. TEST_F(OptionDefinitionTest, validate) { // Not supported option type string is not allowed. - OptionDefinition opt_def1("OPTION_CLIENTID", D6O_CLIENTID, "non-existent-type"); + OptionDefinition opt_def1("OPTION_CLIENTID", D6O_CLIENTID, + DHCP6_OPTION_SPACE, "non-existent-type"); EXPECT_THROW(opt_def1.validate(), MalformedOptionDefinition); // Not supported option type enum value is not allowed. - OptionDefinition opt_def2("OPTION_CLIENTID", D6O_CLIENTID, OPT_UNKNOWN_TYPE); + OptionDefinition opt_def2("OPTION_CLIENTID", D6O_CLIENTID, + DHCP6_OPTION_SPACE, OPT_UNKNOWN_TYPE); EXPECT_THROW(opt_def2.validate(), MalformedOptionDefinition); OptionDefinition opt_def3("OPTION_CLIENTID", D6O_CLIENTID, + DHCP6_OPTION_SPACE, static_cast(OPT_UNKNOWN_TYPE + 2)); EXPECT_THROW(opt_def3.validate(), MalformedOptionDefinition); // Empty option name is not allowed. - OptionDefinition opt_def4("", D6O_CLIENTID, "string"); + OptionDefinition opt_def4("", D6O_CLIENTID, DHCP6_OPTION_SPACE, "string"); EXPECT_THROW(opt_def4.validate(), MalformedOptionDefinition); // Option name must not contain spaces. - OptionDefinition opt_def5(" OPTION_CLIENTID", D6O_CLIENTID, "string"); + OptionDefinition opt_def5(" OPTION_CLIENTID", D6O_CLIENTID, + DHCP6_OPTION_SPACE, "string"); EXPECT_THROW(opt_def5.validate(), MalformedOptionDefinition); // Option name must not contain spaces. - OptionDefinition opt_def6("OPTION CLIENTID", D6O_CLIENTID, "string"); + OptionDefinition opt_def6("OPTION CLIENTID", D6O_CLIENTID, + DHCP6_OPTION_SPACE, "string"); EXPECT_THROW(opt_def6.validate(), MalformedOptionDefinition); // Option name may contain lower case letters. - OptionDefinition opt_def7("option_clientid", D6O_CLIENTID, "string"); + OptionDefinition opt_def7("option_clientid", D6O_CLIENTID, + DHCP6_OPTION_SPACE, "string"); EXPECT_NO_THROW(opt_def7.validate()); // Using digits in option name is legal. - OptionDefinition opt_def8("option_123", D6O_CLIENTID, "string"); + OptionDefinition opt_def8("option_123", D6O_CLIENTID, DHCP6_OPTION_SPACE, + "string"); EXPECT_NO_THROW(opt_def8.validate()); // Using hyphen is legal. - OptionDefinition opt_def9("option-clientid", D6O_CLIENTID, "string"); + OptionDefinition opt_def9("option-clientid", D6O_CLIENTID, + DHCP6_OPTION_SPACE, "string"); EXPECT_NO_THROW(opt_def9.validate()); // Using hyphen or underscore at the beginning or at the end // of the option name is not allowed. - OptionDefinition opt_def10("-option-clientid", D6O_CLIENTID, "string"); + OptionDefinition opt_def10("-option-clientid", D6O_CLIENTID, + DHCP6_OPTION_SPACE, "string"); EXPECT_THROW(opt_def10.validate(), MalformedOptionDefinition); - OptionDefinition opt_def11("_option-clientid", D6O_CLIENTID, "string"); + OptionDefinition opt_def11("_option-clientid", D6O_CLIENTID, + DHCP6_OPTION_SPACE, "string"); EXPECT_THROW(opt_def11.validate(), MalformedOptionDefinition); - OptionDefinition opt_def12("option-clientid_", D6O_CLIENTID, "string"); + OptionDefinition opt_def12("option-clientid_", D6O_CLIENTID, + DHCP6_OPTION_SPACE, "string"); EXPECT_THROW(opt_def12.validate(), MalformedOptionDefinition); - OptionDefinition opt_def13("option-clientid-", D6O_CLIENTID, "string"); + OptionDefinition opt_def13("option-clientid-", D6O_CLIENTID, + DHCP6_OPTION_SPACE, "string"); EXPECT_THROW(opt_def13.validate(), MalformedOptionDefinition); + // Empty option space name is not allowed. + OptionDefinition opt_def14("OPTION_CLIENTID", D6O_CLIENTID, "", "string"); + EXPECT_THROW(opt_def14.validate(), MalformedOptionDefinition); + + // Option name must not contain spaces. + OptionDefinition opt_def15("OPTION_CLIENTID", D6O_CLIENTID, " space", + "string"); + EXPECT_THROW(opt_def15.validate(), MalformedOptionDefinition); + + // Option name must not contain spaces. + OptionDefinition opt_def16("OPTION_CLIENTID", D6O_CLIENTID, "my space", + "string"); + EXPECT_THROW(opt_def16.validate(), MalformedOptionDefinition); + + // Option name may contain upper case letters. + OptionDefinition opt_def17("OPTION_CLIENTID", D6O_CLIENTID, "SPACE", + "string"); + EXPECT_NO_THROW(opt_def17.validate()); + + // Using digits in option name is legal. + OptionDefinition opt_def18("OPTION_CLIENTID", D6O_CLIENTID, "space_123", + "string"); + EXPECT_NO_THROW(opt_def18.validate()); + + // Using hyphen is legal. + OptionDefinition opt_def19("OPTION_CLIENTID", D6O_CLIENTID, "my-space", + "string"); + EXPECT_NO_THROW(opt_def19.validate()); + + // Using hyphen or underscore at the beginning or at the end + // of the option name is not allowed. + OptionDefinition opt_def20("OPTION_CLIENTID", D6O_CLIENTID, "-space", + "string"); + EXPECT_THROW(opt_def20.validate(), MalformedOptionDefinition); + + OptionDefinition opt_def21("OPTION_CLIENTID", D6O_CLIENTID, "_space", + "string"); + EXPECT_THROW(opt_def21.validate(), MalformedOptionDefinition); + + OptionDefinition opt_def22("OPTION_CLIENTID", D6O_CLIENTID, "space_", + "string"); + EXPECT_THROW(opt_def22.validate(), MalformedOptionDefinition); + + OptionDefinition opt_def23("OPTION_CLIENTID", D6O_CLIENTID, "space-", + "string"); + EXPECT_THROW(opt_def23.validate(), MalformedOptionDefinition); + // Having array of strings does not make sense because there is no way // to determine string's length. - OptionDefinition opt_def14("OPTION_CLIENTID", D6O_CLIENTID, "string", true); - EXPECT_THROW(opt_def14.validate(), MalformedOptionDefinition); + OptionDefinition opt_def24("OPTION_CLIENTID", D6O_CLIENTID, + DHCP6_OPTION_SPACE, "string", true); + EXPECT_THROW(opt_def24.validate(), MalformedOptionDefinition); // It does not make sense to have string field within the record before // other fields because there is no way to determine the length of this // string and thus there is no way to determine where the other field // begins. - OptionDefinition opt_def15("OPTION_STATUS_CODE", D6O_STATUS_CODE, - "record"); - opt_def15.addRecordField("string"); - opt_def15.addRecordField("uint16"); - EXPECT_THROW(opt_def15.validate(), MalformedOptionDefinition); + OptionDefinition opt_def25("OPTION_STATUS_CODE", D6O_STATUS_CODE, + DHCP6_OPTION_SPACE, "record"); + opt_def25.addRecordField("string"); + opt_def25.addRecordField("uint16"); + EXPECT_THROW(opt_def25.validate(), MalformedOptionDefinition); // ... but it is ok if the string value is the last one. - OptionDefinition opt_def16("OPTION_STATUS_CODE", D6O_STATUS_CODE, - "record"); - opt_def16.addRecordField("uint8"); - opt_def16.addRecordField("string"); - EXPECT_NO_THROW(opt_def16.validate()); + OptionDefinition opt_def26("OPTION_STATUS_CODE", D6O_STATUS_CODE, + DHCP6_OPTION_SPACE, "record"); + opt_def26.addRecordField("uint8"); + opt_def26.addRecordField("string"); + EXPECT_NO_THROW(opt_def26.validate()); // ... at least if it is not an array. - OptionDefinition opt_def17("OPTION_STATUS_CODE", D6O_STATUS_CODE, - "record", true); - opt_def17.addRecordField("uint8"); - opt_def17.addRecordField("string"); - EXPECT_THROW(opt_def17.validate(), MalformedOptionDefinition); + OptionDefinition opt_def27("OPTION_STATUS_CODE", D6O_STATUS_CODE, + DHCP6_OPTION_SPACE, "record", true); + opt_def27.addRecordField("uint8"); + opt_def27.addRecordField("string"); + EXPECT_THROW(opt_def27.validate(), MalformedOptionDefinition); // Check invalid encapsulated option space name. - OptionDefinition opt_def18("OPTION_VENDOR_OPTS", D6O_VENDOR_OPTS, - "uint32", "invalid%space%name"); - EXPECT_THROW(opt_def18.validate(), MalformedOptionDefinition); + OptionDefinition opt_def28("OPTION_VENDOR_OPTS", D6O_VENDOR_OPTS, + DHCP6_OPTION_SPACE, "uint32", + "invalid%space%name"); + EXPECT_THROW(opt_def28.validate(), MalformedOptionDefinition); } @@ -398,7 +482,7 @@ TEST_F(OptionDefinitionTest, validate) { // of option with a list of IPv6 addresses. TEST_F(OptionDefinitionTest, ipv6AddressArray) { OptionDefinition opt_def("OPTION_NIS_SERVERS", D6O_NIS_SERVERS, - "ipv6-address", true); + DHCP6_OPTION_SPACE, "ipv6-address", true); // Create a list of some V6 addresses. std::vector addrs; @@ -453,7 +537,7 @@ TEST_F(OptionDefinitionTest, ipv6AddressArray) { // IPv6 address). TEST_F(OptionDefinitionTest, ipv6AddressArrayTokenized) { OptionDefinition opt_def("OPTION_NIS_SERVERS", D6O_NIS_SERVERS, - "ipv6-address", true); + DHCP6_OPTION_SPACE, "ipv6-address", true); // Create a vector of some V6 addresses. std::vector addrs; @@ -500,7 +584,7 @@ TEST_F(OptionDefinitionTest, ipv6AddressArrayTokenized) { // of option with a list of IPv4 addresses. TEST_F(OptionDefinitionTest, ipv4AddressArray) { OptionDefinition opt_def("OPTION_NAME_SERVERS", D6O_NIS_SERVERS, - "ipv4-address", true); + DHCP6_OPTION_SPACE, "ipv4-address", true); // Create a list of some V6 addresses. std::vector addrs; @@ -552,7 +636,7 @@ TEST_F(OptionDefinitionTest, ipv4AddressArray) { // IPv4 address). TEST_F(OptionDefinitionTest, ipv4AddressArrayTokenized) { OptionDefinition opt_def("OPTION_NIS_SERVERS", DHO_NIS_SERVERS, - "ipv4-address", true); + DHCP4_OPTION_SPACE, "ipv4-address", true); // Create a vector of some V6 addresses. std::vector addrs; @@ -597,7 +681,8 @@ TEST_F(OptionDefinitionTest, ipv4AddressArrayTokenized) { // The purpose of this test is to verify that option definition for // 'empty' option can be created and that it returns 'empty' option. TEST_F(OptionDefinitionTest, empty) { - OptionDefinition opt_def("OPTION_RAPID_COMMIT", D6O_RAPID_COMMIT, "empty"); + OptionDefinition opt_def("OPTION_RAPID_COMMIT", D6O_RAPID_COMMIT, + DHCP6_OPTION_SPACE, "empty"); // Create option instance and provide empty buffer as expected. OptionPtr option_v6; @@ -630,8 +715,8 @@ TEST_F(OptionDefinitionTest, emptyWithSuboptions) { // with this definition the OptionCustom should be returned. The // Option Custom is generic option which support variety of formats // and supports decoding suboptions. - OptionDefinition opt_def("option-foo", 1024, "empty", "option-foo-space"); - + OptionDefinition opt_def("option-foo", 1024, "my-space", "empty", + "option-foo-space"); // Define a suboption. const uint8_t subopt_data[] = { 0x04, 0x01, // Option code 1025 @@ -674,7 +759,8 @@ TEST_F(OptionDefinitionTest, binary) { // class but for some of them it is just natural. The SERVERID // option consists of the option code, length and binary data so // this one was picked for this test. - OptionDefinition opt_def("OPTION_SERVERID", D6O_SERVERID, "binary"); + OptionDefinition opt_def("OPTION_SERVERID", D6O_SERVERID, + DHCP6_OPTION_SPACE, "binary"); // Prepare some dummy data (serverid): 0, 1, 2 etc. OptionBuffer buf(14); @@ -725,7 +811,8 @@ TEST_F(OptionDefinitionTest, recordIA6) { const int option6_ia_len = 12; // Get the factory function pointer. - OptionDefinition opt_def("OPTION_IA_NA", D6O_IA_NA, "record", false); + OptionDefinition opt_def("OPTION_IA_NA", D6O_IA_NA, DHCP6_OPTION_SPACE, + "record", false); // Each data field is uint32. for (int i = 0; i < 3; ++i) { EXPECT_NO_THROW(opt_def.addRecordField("uint32")); @@ -763,7 +850,8 @@ TEST_F(OptionDefinitionTest, recordIAAddr6) { // valid-lifetime fields (each 4 bytes long). const int option6_iaaddr_len = 24; - OptionDefinition opt_def("OPTION_IAADDR", D6O_IAADDR, "record"); + OptionDefinition opt_def("OPTION_IAADDR", D6O_IAADDR, DHCP6_OPTION_SPACE, + "record"); ASSERT_NO_THROW(opt_def.addRecordField("ipv6-address")); ASSERT_NO_THROW(opt_def.addRecordField("uint32")); ASSERT_NO_THROW(opt_def.addRecordField("uint32")); @@ -808,7 +896,8 @@ TEST_F(OptionDefinitionTest, recordIAAddr6) { TEST_F(OptionDefinitionTest, recordIAAddr6Tokenized) { // This option consists of IPV6 Address (16 bytes) and preferred-lifetime and // valid-lifetime fields (each 4 bytes long). - OptionDefinition opt_def("OPTION_IAADDR", D6O_IAADDR, "record"); + OptionDefinition opt_def("OPTION_IAADDR", D6O_IAADDR, DHCP6_OPTION_SPACE, + "record"); ASSERT_NO_THROW(opt_def.addRecordField("ipv6-address")); ASSERT_NO_THROW(opt_def.addRecordField("uint32")); ASSERT_NO_THROW(opt_def.addRecordField("uint32")); @@ -838,7 +927,7 @@ TEST_F(OptionDefinitionTest, recordIAAddr6Tokenized) { TEST_F(OptionDefinitionTest, boolValue) { // The IP Forwarding option comprises one boolean value. OptionDefinition opt_def("ip-forwarding", DHO_IP_FORWARDING, - "boolean"); + DHCP4_OPTION_SPACE, "boolean"); OptionPtr option_v4; // Use an option buffer which holds one value of 1 (true). @@ -877,7 +966,8 @@ TEST_F(OptionDefinitionTest, boolValue) { // the following values: "true", "false", "1" or "0". For all other // values exception should be thrown. TEST_F(OptionDefinitionTest, boolTokenized) { - OptionDefinition opt_def("ip-forwarding", DHO_IP_FORWARDING, "boolean"); + OptionDefinition opt_def("ip-forwarding", DHO_IP_FORWARDING, + DHCP6_OPTION_SPACE, "boolean"); OptionPtr option_v4; std::vector values; @@ -952,7 +1042,8 @@ TEST_F(OptionDefinitionTest, boolTokenized) { // comprises single uint8 value can be created and that this definition // can be used to create an option with single uint8 value. TEST_F(OptionDefinitionTest, uint8) { - OptionDefinition opt_def("OPTION_PREFERENCE", D6O_PREFERENCE, "uint8"); + OptionDefinition opt_def("OPTION_PREFERENCE", D6O_PREFERENCE, + DHCP6_OPTION_SPACE, "uint8"); OptionPtr option_v6; // Try to use correct buffer length = 1 byte. @@ -981,7 +1072,8 @@ TEST_F(OptionDefinitionTest, uint8) { // comprises single uint8 value can be created and that this definition // can be used to create an option with single uint8 value. TEST_F(OptionDefinitionTest, uint8Tokenized) { - OptionDefinition opt_def("OPTION_PREFERENCE", D6O_PREFERENCE, "uint8"); + OptionDefinition opt_def("OPTION_PREFERENCE", D6O_PREFERENCE, + DHCP6_OPTION_SPACE, "uint8"); OptionPtr option_v6; std::vector values; @@ -1005,7 +1097,8 @@ TEST_F(OptionDefinitionTest, uint8Tokenized) { // comprises single uint16 value can be created and that this definition // can be used to create an option with single uint16 value. TEST_F(OptionDefinitionTest, uint16) { - OptionDefinition opt_def("OPTION_ELAPSED_TIME", D6O_ELAPSED_TIME, "uint16"); + OptionDefinition opt_def("OPTION_ELAPSED_TIME", D6O_ELAPSED_TIME, + DHCP6_OPTION_SPACE, "uint16"); OptionPtr option_v6; // Try to use correct buffer length = 2 bytes. @@ -1036,7 +1129,8 @@ TEST_F(OptionDefinitionTest, uint16) { // comprises single uint16 value can be created and that this definition // can be used to create an option with single uint16 value. TEST_F(OptionDefinitionTest, uint16Tokenized) { - OptionDefinition opt_def("OPTION_ELAPSED_TIME", D6O_ELAPSED_TIME, "uint16"); + OptionDefinition opt_def("OPTION_ELAPSED_TIME", D6O_ELAPSED_TIME, + DHCP6_OPTION_SPACE, "uint16"); OptionPtr option_v6; @@ -1062,7 +1156,8 @@ TEST_F(OptionDefinitionTest, uint16Tokenized) { // comprises single uint32 value can be created and that this definition // can be used to create an option with single uint32 value. TEST_F(OptionDefinitionTest, uint32) { - OptionDefinition opt_def("OPTION_CLT_TIME", D6O_CLT_TIME, "uint32"); + OptionDefinition opt_def("OPTION_CLT_TIME", D6O_CLT_TIME, + DHCP6_OPTION_SPACE, "uint32"); OptionPtr option_v6; OptionBuffer buf; @@ -1094,7 +1189,8 @@ TEST_F(OptionDefinitionTest, uint32) { // comprises single uint32 value can be created and that this definition // can be used to create an option with single uint32 value. TEST_F(OptionDefinitionTest, uint32Tokenized) { - OptionDefinition opt_def("OPTION_CLT_TIME", D6O_CLT_TIME, "uint32"); + OptionDefinition opt_def("OPTION_CLT_TIME", D6O_CLT_TIME, + DHCP6_OPTION_SPACE, "uint32"); OptionPtr option_v6; std::vector values; @@ -1120,7 +1216,8 @@ TEST_F(OptionDefinitionTest, uint32Tokenized) { TEST_F(OptionDefinitionTest, uint16Array) { // Let's define some dummy option. const uint16_t opt_code = 79; - OptionDefinition opt_def("OPTION_UINT16_ARRAY", opt_code, "uint16", true); + OptionDefinition opt_def("OPTION_UINT16_ARRAY", opt_code, "my-space", + "uint16", true); OptionPtr option_v6; // Positive scenario, initiate the buffer with length being @@ -1168,7 +1265,8 @@ TEST_F(OptionDefinitionTest, uint16Array) { TEST_F(OptionDefinitionTest, uint16ArrayTokenized) { // Let's define some dummy option. const uint16_t opt_code = 79; - OptionDefinition opt_def("OPTION_UINT16_ARRAY", opt_code, "uint16", true); + OptionDefinition opt_def("OPTION_UINT16_ARRAY", opt_code, "my-space", + "uint16", true); OptionPtr option_v6; std::vector str_values; @@ -1197,7 +1295,8 @@ TEST_F(OptionDefinitionTest, uint32Array) { // Let's define some dummy option. const uint16_t opt_code = 80; - OptionDefinition opt_def("OPTION_UINT32_ARRAY", opt_code, "uint32", true); + OptionDefinition opt_def("OPTION_UINT32_ARRAY", opt_code, "my-space", + "uint32", true); OptionPtr option_v6; // Positive scenario, initiate the buffer with length being @@ -1246,7 +1345,8 @@ TEST_F(OptionDefinitionTest, uint32ArrayTokenized) { // Let's define some dummy option. const uint16_t opt_code = 80; - OptionDefinition opt_def("OPTION_UINT32_ARRAY", opt_code, "uint32", true); + OptionDefinition opt_def("OPTION_UINT32_ARRAY", opt_code, "my-space", + "uint32", true); OptionPtr option_v6; std::vector str_values; @@ -1277,7 +1377,8 @@ TEST_F(OptionDefinitionTest, uint32ArrayTokenized) { TEST_F(OptionDefinitionTest, utf8StringTokenized) { // Let's create some dummy option. const uint16_t opt_code = 80; - OptionDefinition opt_def("OPTION_WITH_STRING", opt_code, "string"); + OptionDefinition opt_def("OPTION_WITH_STRING", opt_code, "my-space", + "string"); std::vector values; values.push_back("Hello World"); @@ -1314,32 +1415,37 @@ TEST_F(OptionDefinitionTest, integerInvalidType) { // IA_NA and IAADDR option formats. TEST_F(OptionDefinitionTest, haveIAFormat) { // IA_NA option format. - OptionDefinition opt_def1("OPTION_IA_NA", D6O_IA_NA, "record"); + OptionDefinition opt_def1("OPTION_IA_NA", D6O_IA_NA, DHCP6_OPTION_SPACE, + "record"); for (int i = 0; i < 3; ++i) { opt_def1.addRecordField("uint32"); } EXPECT_TRUE(opt_def1.haveIA6Format()); // Create non-matching format to check that this function does not // return 'true' all the time. - OptionDefinition opt_def2("OPTION_IA_NA", D6O_IA_NA, "uint16"); + OptionDefinition opt_def2("OPTION_IA_NA", D6O_IA_NA, DHCP6_OPTION_SPACE, + "uint16"); EXPECT_FALSE(opt_def2.haveIA6Format()); // IAADDR option format. - OptionDefinition opt_def3("OPTION_IAADDR", D6O_IAADDR, "record"); + OptionDefinition opt_def3("OPTION_IAADDR", D6O_IAADDR, DHCP6_OPTION_SPACE, + "record"); opt_def3.addRecordField("ipv6-address"); opt_def3.addRecordField("uint32"); opt_def3.addRecordField("uint32"); EXPECT_TRUE(opt_def3.haveIAAddr6Format()); // Create non-matching format to check that this function does not // return 'true' all the time. - OptionDefinition opt_def4("OPTION_IAADDR", D6O_IAADDR, "uint32", true); + OptionDefinition opt_def4("OPTION_IAADDR", D6O_IAADDR, DHCP6_OPTION_SPACE, + "uint32", true); EXPECT_FALSE(opt_def4.haveIAAddr6Format()); } // This test verifies that haveClientFqdnFormat function recognizes that option // definition describes the format of DHCPv6 Client Fqdn Option Format. TEST_F(OptionDefinitionTest, haveClientFqdnFormat) { - OptionDefinition opt_def("OPTION_CLIENT_FQDN", D6O_CLIENT_FQDN, "record"); + OptionDefinition opt_def("OPTION_CLIENT_FQDN", D6O_CLIENT_FQDN, + DHCP6_OPTION_SPACE, "record"); opt_def.addRecordField("uint8"); opt_def.addRecordField("fqdn"); EXPECT_TRUE(opt_def.haveClientFqdnFormat()); @@ -1347,14 +1453,14 @@ TEST_F(OptionDefinitionTest, haveClientFqdnFormat) { // Create option format which is not matching the Client FQDN option format // to verify that tested function does dont always return true. OptionDefinition opt_def_invalid("OPTION_CLIENT_FQDN", D6O_CLIENT_FQDN, - "uint8"); + DHCP6_OPTION_SPACE, "uint8"); EXPECT_FALSE(opt_def_invalid.haveClientFqdnFormat()); } // This test verifies that a definition of an option with a single IPv6 // prefix can be created and used to create an instance of the option. TEST_F(OptionDefinitionTest, prefix) { - OptionDefinition opt_def("option-prefix", 1000, "ipv6-prefix"); + OptionDefinition opt_def("option-prefix", 1000, "my-space", "ipv6-prefix"); // Create a buffer holding a prefix. OptionBuffer buf; @@ -1388,7 +1494,7 @@ TEST_F(OptionDefinitionTest, prefix) { // prefix can be created and that the instance of this option can be // created by specifying the prefix in the textual format. TEST_F(OptionDefinitionTest, prefixTokenized) { - OptionDefinition opt_def("option-prefix", 1000, "ipv6-prefix"); + OptionDefinition opt_def("option-prefix", 1000, "my-space", "ipv6-prefix"); OptionPtr option_v6; // Specify a single prefix. @@ -1418,7 +1524,8 @@ TEST_F(OptionDefinitionTest, prefixTokenized) { // option can be created by specifying multiple prefixes in the // textual format. TEST_F(OptionDefinitionTest, prefixArrayTokenized) { - OptionDefinition opt_def("option-prefix", 1000, "ipv6-prefix", true); + OptionDefinition opt_def("option-prefix", 1000, "my-space", + "ipv6-prefix", true); OptionPtr option_v6; @@ -1466,7 +1573,7 @@ TEST_F(OptionDefinitionTest, prefixArrayTokenized) { // This test verifies that a definition of an option with a single PSID // value can be created and used to create an instance of the option. TEST_F(OptionDefinitionTest, psid) { - OptionDefinition opt_def("option-psid", 1000, "psid"); + OptionDefinition opt_def("option-psid", 1000, "my-space", "psid"); OptionPtr option_v6; @@ -1499,7 +1606,7 @@ TEST_F(OptionDefinitionTest, psid) { // value can be created and that the instance of this option can be // created by specifying PSID length and value in the textual format. TEST_F(OptionDefinitionTest, psidTokenized) { - OptionDefinition opt_def("option-psid", 1000, "psid"); + OptionDefinition opt_def("option-psid", 1000, "my-space", "psid"); OptionPtr option_v6; // Specify a single PSID with a length of 6 and value of 3. @@ -1528,7 +1635,7 @@ TEST_F(OptionDefinitionTest, psidTokenized) { // of PSIDs can be created and that the instance of this option can be // created by specifying multiple PSIDs in the textual format. TEST_F(OptionDefinitionTest, psidArrayTokenized) { - OptionDefinition opt_def("option-psid", 1000, "psid", true); + OptionDefinition opt_def("option-psid", 1000, "my-space", "psid", true); OptionPtr option_v6; @@ -1575,7 +1682,7 @@ TEST_F(OptionDefinitionTest, psidArrayTokenized) { // This test verifies that a definition of an option with a single DHCPv4 // tuple can be created and used to create an instance of the option. TEST_F(OptionDefinitionTest, tuple4) { - OptionDefinition opt_def("option-tuple", 232, "tuple"); + OptionDefinition opt_def("option-tuple", 232, "my-space", "tuple"); OptionPtr option; @@ -1607,7 +1714,7 @@ TEST_F(OptionDefinitionTest, tuple4) { // This test verifies that a definition of an option with a single DHCPv6 // tuple can be created and used to create an instance of the option. TEST_F(OptionDefinitionTest, tuple6) { - OptionDefinition opt_def("option-tuple", 1000, "tuple"); + OptionDefinition opt_def("option-tuple", 1000, "my-space", "tuple"); OptionPtr option; @@ -1640,7 +1747,7 @@ TEST_F(OptionDefinitionTest, tuple6) { // tuple can be created and that the instance of this option can be // created by specifying tuple value in the textual format. TEST_F(OptionDefinitionTest, tuple4Tokenized) { - OptionDefinition opt_def("option-tuple", 232, "tuple"); + OptionDefinition opt_def("option-tuple", 232, "my-space", "tuple"); OptionPtr option; // Specify a single tuple with "foobar" content. @@ -1669,7 +1776,7 @@ TEST_F(OptionDefinitionTest, tuple4Tokenized) { // tuple can be created and that the instance of this option can be // created by specifying tuple value in the textual format. TEST_F(OptionDefinitionTest, tuple6Tokenized) { - OptionDefinition opt_def("option-tuple", 1000, "tuple"); + OptionDefinition opt_def("option-tuple", 1000, "my-space", "tuple"); OptionPtr option; // Specify a single tuple with "foobar" content. @@ -1698,7 +1805,7 @@ TEST_F(OptionDefinitionTest, tuple6Tokenized) { // of DHCPv4 tuples can be created and that the instance of this option // can be created by specifying multiple DHCPv4 tuples in the textual format. TEST_F(OptionDefinitionTest, tuple4ArrayTokenized) { - OptionDefinition opt_def("option-tuple", 232, "tuple", true); + OptionDefinition opt_def("option-tuple", 232, "my-space", "tuple", true); OptionPtr option; @@ -1740,7 +1847,7 @@ TEST_F(OptionDefinitionTest, tuple4ArrayTokenized) { // of DHCPv6 tuples can be created and that the instance of this option // can be created by specifying multiple DHCPv6 tuples in the textual format. TEST_F(OptionDefinitionTest, tuple6ArrayTokenized) { - OptionDefinition opt_def("option-tuple", 1000, "tuple", true); + OptionDefinition opt_def("option-tuple", 1000, "my-space", "tuple", true); OptionPtr option;