-// 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
// 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;
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()));
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));
// 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;
// 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
// 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'.
// 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"
// 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"
// 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"
// 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.
// 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<int32_t>(-234, buf);
// 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.
// 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.
// 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.
// 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.
// 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;
// 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.
// 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.
// 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<IOAddress> addresses;
// 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<IOAddress> addresses;
// 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"
// 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.
// 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[] = {
// 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"
// 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"
// 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"));
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"));
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"));
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"));
// 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).
// 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).
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).
// 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).
// 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).
// 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).
// 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).
// 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).
/// 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).
// 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).
// 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).
/// 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).
/// 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).
/// 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).
/// 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).
/// 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).
/// 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).
}
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"));
}
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"));
// 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"));
// 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"));
// 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<IOAddress> addresses;
// 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"));
// 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<IOAddress> addresses;
// 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) {
// 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");
// 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<uint32_t>(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);
-// 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
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());
// 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());
// 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());
// 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());
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());
// 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());
// 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());
// 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());
// 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());
// 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());
// 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.
if (i == OPT_RECORD_TYPE) {
continue;
}
- OptionDefinition opt_def("OPTION_IAADDR", 5,
+ OptionDefinition opt_def("OPTION_IAADDR", 5, DHCP6_OPTION_SPACE,
static_cast<OptionDataType>(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.
// 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);
// 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<OptionDataType>(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);
}
// 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<asiolink::IOAddress> addrs;
// 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<asiolink::IOAddress> addrs;
// 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<asiolink::IOAddress> addrs;
// 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<asiolink::IOAddress> addrs;
// 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;
// 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
// 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);
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"));
// 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"));
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"));
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).
// 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<std::string> values;
// 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.
// 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<std::string> values;
// 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.
// 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;
// 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;
// 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<std::string> values;
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
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<std::string> str_values;
// 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
// 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<std::string> str_values;
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<std::string> values;
values.push_back("Hello World");
// 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());
// 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;
// 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.
// 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;
// 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;
// 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.
// 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;
// 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;
// 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;
// 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.
// 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.
// 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;
// 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;
projects / thirdparty / kea.git / commitdiff
