From: Marcin Siodelski Date: Wed, 21 Nov 2012 14:56:02 +0000 (+0100) Subject: [2490] Added descriptions for option definition tests. X-Git-Tag: bind10-1.0.0-beta-release~84^2^2~3 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=b4dd93598f4e795c6cac151bc26caa56975fa835;p=thirdparty%2Fkea.git [2490] Added descriptions for option definition tests. --- diff --git a/src/lib/dhcp/tests/option_definition_unittest.cc b/src/lib/dhcp/tests/option_definition_unittest.cc index fa5b85ca06..52fdfd7350 100644 --- a/src/lib/dhcp/tests/option_definition_unittest.cc +++ b/src/lib/dhcp/tests/option_definition_unittest.cc @@ -47,6 +47,8 @@ public: OptionDefinitionTest() { } }; +// The purpose of this test is to verify that OptionDefinition +// constructor initializes its members correctly. TEST_F(OptionDefinitionTest, constructor) { // Specify the option data type as string. This should get converted // to enum value returned by getType(). @@ -87,6 +89,10 @@ TEST_F(OptionDefinitionTest, constructor) { ); } +// The purpose of this test is to verify that various data fields +// can be specified for an option definition when this definition +// is marked as 'record' and that fields can't be added if option +// definition is not marked as 'record'. TEST_F(OptionDefinitionTest, addRecordField) { // We can only add fields to record if the option type has been // specified as 'record'. We try all other types but 'record' @@ -123,6 +129,8 @@ TEST_F(OptionDefinitionTest, addRecordField) { EXPECT_THROW(opt_def.addRecordField(invalid_type), isc::BadValue); } +// The purpose of this test is to check that validate() function +// 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"); @@ -149,6 +157,9 @@ TEST_F(OptionDefinitionTest, validate) { EXPECT_THROW(opt_def6.validate(), isc::BadValue); } +// The purpose of this test is to verify that option definition +// that comprises array of IPv6 addresses will return an instance +// of option with a list of IPv6 addresses. TEST_F(OptionDefinitionTest, ipv6AddressArray) { OptionDefinition opt_def("OPTION_NIS_SERVERS", D6O_NIS_SERVERS, "ipv6-address", true); @@ -198,8 +209,11 @@ TEST_F(OptionDefinitionTest, ipv6AddressArray) { ); } -// This test checks that a vector of strings, holding IPv6 addresses, -// can be used to create option instance with the optionFactory function. +// The purpose of this test is to verify that option definition +// that comprises array of IPv6 addresses will return an instance +// of option with a list of IPv6 addresses. Array of IPv6 addresses +// is specified as a vector of strings (each string represents single +// IPv6 address). TEST_F(OptionDefinitionTest, ipv6AddressArrayTokenized) { OptionDefinition opt_def("OPTION_NIS_SERVERS", D6O_NIS_SERVERS, "ipv6-address", true); @@ -242,6 +256,9 @@ TEST_F(OptionDefinitionTest, ipv6AddressArrayTokenized) { EXPECT_TRUE(std::equal(addrs.begin(), addrs.end(), addrs_returned.begin())); } +// The purpose of this test is to verify that option definition +// that comprises array of IPv4 addresses will return an instance +// of option with a list of IPv4 addresses. TEST_F(OptionDefinitionTest, ipv4AddressArray) { OptionDefinition opt_def("OPTION_NAME_SERVERS", D6O_NIS_SERVERS, "ipv4-address", true); @@ -288,8 +305,11 @@ TEST_F(OptionDefinitionTest, ipv4AddressArray) { isc::OutOfRange); } -// This test checks that a vector of strings, holding IPv4 addresses, -// can be used to create option instance with the optionFactory function. +// The purpose of this test is to verify that option definition +// that comprises array of IPv4 addresses will return an instance +// of option with a list of IPv4 addresses. The array of IPv4 addresses +// is specified as a vector of strings (each string represents single +// IPv4 address). TEST_F(OptionDefinitionTest, ipv4AddressArrayTokenized) { OptionDefinition opt_def("OPTION_NIS_SERVERS", DHO_NIS_SERVERS, "ipv4-address", true); @@ -332,6 +352,8 @@ TEST_F(OptionDefinitionTest, ipv4AddressArrayTokenized) { EXPECT_TRUE(std::equal(addrs.begin(), addrs.end(), addrs_returned.begin())); } +// The purpose of thie 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"); @@ -355,6 +377,8 @@ TEST_F(OptionDefinitionTest, empty) { EXPECT_EQ(0, option_v4->getData().size()); } +// The purpose of this test is to verify that definition can be +// creates for the option that holds binary data. TEST_F(OptionDefinitionTest, binary) { // Binary option is the one that is represented by the generic // Option class. In fact all options can be represented by this @@ -402,6 +426,10 @@ TEST_F(OptionDefinitionTest, binary) { buf.begin())); } +// The purpose of this test is to verify that definition can be +// creates for the option that holds binary data and that the +// binary data can be specified in 'comma separated values' +// format. TEST_F(OptionDefinitionTest, binaryTokenized) { OptionDefinition opt_def("OPTION_FOO", 1000, "binary", true); @@ -448,13 +476,15 @@ TEST_F(OptionDefinitionTest, binaryTokenized) { buf.begin())); } - +// The purpose of this test is to verify that definition can be created +// for option that comprises record of data. In this particular test +// the IA_NA option is used. This option comprises three uint32 fields. TEST_F(OptionDefinitionTest, recordIA6) { // This option consists of IAID, T1 and T2 fields (each 4 bytes long). const int option6_ia_len = 12; // Get the factory function pointer. - OptionDefinition opt_def("OPTION_IA_NA", D6O_IA_NA, "record", true); + OptionDefinition opt_def("OPTION_IA_NA", D6O_IA_NA, "record", false); // Each data field is uint32. for (int i = 0; i < 3; ++i) { EXPECT_NO_THROW(opt_def.addRecordField("uint32")); @@ -487,6 +517,9 @@ TEST_F(OptionDefinitionTest, recordIA6) { ); } +// The purpose of this test is to verify that definition can be created +// for option that comprises record of data. In this particular test +// the IAADDR option is used. TEST_F(OptionDefinitionTest, recordIAAddr6) { // This option consists of IPV6 Address (16 bytes) and preferred-lifetime and // valid-lifetime fields (each 4 bytes long). @@ -531,6 +564,11 @@ TEST_F(OptionDefinitionTest, recordIAAddr6) { ); } +// The purpose of this test is to verify that definition can be created +// for option that comprises record of data. In this particular test +// the IAADDR option is used. The data for the option is speicifed as +// a vector of strings. Each string carries the data for the corresponding +// data field. TEST_F(OptionDefinitionTest, recordIAAddr6Tokenized) { // This option consists of IPV6 Address (16 bytes) and preferred-lifetime and // valid-lifetime fields (each 4 bytes long). @@ -562,18 +600,9 @@ TEST_F(OptionDefinitionTest, recordIAAddr6Tokenized) { ); } -TEST_F(OptionDefinitionTest, integerInvalidType) { - // The template function factoryInteger<> accepts integer values only - // as template typename. Here we try passing different type and - // see if it rejects it. - OptionBuffer buf(1); - EXPECT_THROW( - OptionDefinition::factoryInteger(Option::V6, D6O_PREFERENCE, - buf.begin(), buf.end()), - isc::dhcp::InvalidDataType - ); -} - +// The purpose of this test is to verify that definition for option that +// 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"); @@ -597,6 +626,9 @@ TEST_F(OptionDefinitionTest, uint8) { // @todo Add more cases for DHCPv4 } +// The purpose of this test is to verify that definition for option that +// 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"); @@ -621,7 +653,9 @@ TEST_F(OptionDefinitionTest, uint8Tokenized) { // @todo Add more cases for DHCPv4 } - +// The purpose of this test is to verify that definition for option that +// 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"); @@ -648,6 +682,9 @@ TEST_F(OptionDefinitionTest, uint16) { // @todo Add more cases for DHCPv4 } +// The purpose of this test is to verify that definition for option that +// 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"); @@ -669,6 +706,9 @@ TEST_F(OptionDefinitionTest, uint16Tokenized) { } +// The purpose of this test is to verify that definition for option that +// 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"); @@ -696,6 +736,9 @@ TEST_F(OptionDefinitionTest, uint32) { // @todo Add more cases for DHCPv4 } +// The purpose of this test is to verify that definition for option that +// 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"); @@ -715,6 +758,9 @@ TEST_F(OptionDefinitionTest, uint32Tokenized) { // @todo Add more cases for DHCPv4 } +// The purpose of this test is to verify that definition for option that +// comprises array of uint16 values can be created and that this definition +// can be used to create option with an array of uint16 values. TEST_F(OptionDefinitionTest, uint16Array) { // Let's define some dummy option. const uint16_t opt_code = 79; @@ -758,6 +804,9 @@ TEST_F(OptionDefinitionTest, uint16Array) { ); } +// The purpose of this test is to verify that definition for option that +// comprises array of uint16 values can be created and that this definition +// can be used to create option with an array of uint16 values. TEST_F(OptionDefinitionTest, uint16ArrayTokenized) { // Let's define some dummy option. const uint16_t opt_code = 79; @@ -781,7 +830,9 @@ TEST_F(OptionDefinitionTest, uint16ArrayTokenized) { EXPECT_EQ(12, values[2]); } - +// The purpose of this test is to verify that definition for option that +// comprises array of uint32 values can be created and that this definition +// can be used to create option with an array of uint32 values. TEST_F(OptionDefinitionTest, uint32Array) { // Let's define some dummy option. const uint16_t opt_code = 80; @@ -826,6 +877,9 @@ TEST_F(OptionDefinitionTest, uint32Array) { ); } +// The purpose of this test is to verify that definition for option that +// comprises array of uint32 values can be created and that this definition +// can be used to create option with an array of uint32 values. TEST_F(OptionDefinitionTest, uint32ArrayTokenized) { // Let's define some dummy option. const uint16_t opt_code = 80; @@ -853,6 +907,8 @@ TEST_F(OptionDefinitionTest, uint32ArrayTokenized) { EXPECT_EQ(1111, values[3]); } +// The purpose of this test is to verify that the definition can be created +// for the option that comprises string value in the UTF8 format. TEST_F(OptionDefinitionTest, utf8StringTokenized) { // Let's create some dummy option. const uint16_t opt_code = 80; @@ -873,6 +929,23 @@ TEST_F(OptionDefinitionTest, utf8StringTokenized) { EXPECT_TRUE(std::equal(ref_data.begin(), ref_data.end(), data.begin())); } +// The purpose of this test is to check that non-integer data type can't +// be used for factoryInteger function. +TEST_F(OptionDefinitionTest, integerInvalidType) { + // The template function factoryInteger<> accepts integer values only + // as template typename. Here we try passing different type and + // see if it rejects it. + OptionBuffer buf(1); + EXPECT_THROW( + OptionDefinition::factoryInteger(Option::V6, D6O_PREFERENCE, + buf.begin(), buf.end()), + isc::dhcp::InvalidDataType + ); +} + +// The purpose of this test is to verify that helper methods +// haveIA6Format and haveIAAddr6Format can be used to determine +// IA_NA and IAADDR option formats. TEST_F(OptionDefinitionTest, recognizeFormat) { // IA_NA option format. OptionDefinition opt_def1("OPTION_IA_NA", D6O_IA_NA, "record");