Commit 7741ab8c authored by Marcin Siodelski's avatar Marcin Siodelski

[4300] Addressed review comments.

parent 2b12535e
......@@ -83,7 +83,7 @@ Host::Host(const uint8_t* identifier, const size_t identifier_len,
dhcp6_client_classes_(dhcp6_client_classes), host_id_(0),
cfg_option4_(), cfg_option6_() {
// Initialize HWAddr or DUID
// Initialize host identifier.
setIdentifier(identifier, identifier_len, identifier_type);
if (!ipv4_reservation.isV4Zero()) {
......@@ -147,12 +147,6 @@ Host::getIdentifierAsText() const {
std::string
Host::getIdentifierAsText(const IdentifierType& type, const uint8_t* value,
const size_t length) {
// Length 0 doesn't make sense.
if (length == 0) {
isc_throw(BadValue, "invalid length 0 of the host identifier while"
" converting the identifier to a textual form");
}
// Convert identifier into <type>=<value> form.
std::ostringstream s;
switch (type) {
......@@ -166,14 +160,33 @@ Host::getIdentifierAsText(const IdentifierType& type, const uint8_t* value,
s << "circuit-id";
break;
default:
isc_throw(BadValue, "requested conversion of the unsupported"
" identifier into textual form");
// This should never happen actually, unless we add new identifier
// and forget to add a case for it above.
s << "(invalid-type)";
}
std::vector<uint8_t> vec(value, value + length);
s << "=" << util::encode::encodeHex(vec);
s << "=" << (length > 0 ? util::encode::encodeHex(vec) : "(null)");
return (s.str());
}
std::string
Host::getIdentifierName(const IdentifierType& type) {
switch (type) {
case Host::IDENT_HWADDR:
return ("hw-address");
case Host::IDENT_DUID:
return ("duid");
case Host::IDENT_CIRCUIT_ID:
return ("circuit-id");
default:
;
}
return ("(unknown)");
}
void
Host::setIdentifier(const uint8_t* identifier, const size_t len,
......
......@@ -229,7 +229,7 @@ public:
///
/// In case of identifiers other than HW address and DUID it is possible to use
/// textual representation, e.g. 'some identifier', which is converted to a
/// vector of ASCII codes represnting characters in a given string, excluding
/// vector of ASCII codes representing characters in a given string, excluding
/// quotes. This is useful in cases when specific identifiers, e.g. circuit-id
/// are manually assigned user friendly values.
///
......@@ -309,6 +309,9 @@ public:
/// @return Identifier in the form of <type>=<value>.
std::string getIdentifierAsText() const;
/// @brief Returns name of the identifier of a specified type.
static std::string getIdentifierName(const IdentifierType& type);
/// @brief Returns host identifier in textual form.
///
/// @param type Identifier type.
......
......@@ -42,6 +42,11 @@ const size_t CLIENT_CLASSES_MAX_LEN = 255;
/// in the Client FQDN %Option (see RFC4702 and RFC4704).
const size_t HOSTNAME_MAX_LEN = 255;
/// @brief Numeric value representing last supported identifier.
///
/// This value is used to validate whether the identifier type stored in
/// a database is within bounds. of supported identifiers.
const uint8_t MAX_IDENTIFIER_TYPE = static_cast<uint8_t>(Host::IDENT_CIRCUIT_ID);
/// @brief Prepared MySQL statements used by the backend to insert and
/// retrieve hosts from the database.
......@@ -299,48 +304,21 @@ public:
bind_[0].is_unsigned = MLM_TRUE;
// dhcp_identifier : VARBINARY(128) NOT NULL
// Check which of the identifiers is used and set values accordingly
if (host->getDuid()) {
dhcp_identifier_length_ = host->getDuid()->getDuid().size();
memcpy(static_cast<void*>(dhcp_identifier_buffer_),
&(host->getDuid()->getDuid()[0]),
host->getDuid()->getDuid().size());
bind_[1].buffer_type = MYSQL_TYPE_BLOB;
bind_[1].buffer = dhcp_identifier_buffer_;
bind_[1].buffer_length = dhcp_identifier_length_;
bind_[1].length = &dhcp_identifier_length_;
} else if (host->getHWAddress()){
dhcp_identifier_length_ = host->getHWAddress()->hwaddr_.size();
memcpy(static_cast<void*>(dhcp_identifier_buffer_),
&(host->getHWAddress()->hwaddr_[0]),
host->getHWAddress()->hwaddr_.size());
bind_[1].buffer_type = MYSQL_TYPE_BLOB;
bind_[1].buffer = dhcp_identifier_buffer_;
bind_[1].buffer_length = dhcp_identifier_length_;
bind_[1].length = &dhcp_identifier_length_;
} else {
isc_throw(DbOperationError, "Host object doesn't contain any"
" identifier which can be used to retrieve information"
" from the database about its static reservations");
}
dhcp_identifier_length_ = host->getIdentifier().size();
memcpy(static_cast<void*>(dhcp_identifier_buffer_),
&(host->getIdentifier())[0],
host->getIdentifier().size());
bind_[1].buffer_type = MYSQL_TYPE_BLOB;
bind_[1].buffer = dhcp_identifier_buffer_;
bind_[1].buffer_length = dhcp_identifier_length_;
bind_[1].length = &dhcp_identifier_length_;
// dhcp_identifier_type : TINYINT NOT NULL
// Check which of the identifier types is used and set values accordingly
if (host->getHWAddress()) {
dhcp_identifier_type_ = BaseHostDataSource::ID_HWADDR; // 0
bind_[2].buffer_type = MYSQL_TYPE_TINY;
bind_[2].buffer = reinterpret_cast<char*>(&dhcp_identifier_type_);
bind_[2].is_unsigned = MLM_TRUE;
} else if (host->getDuid()) {
dhcp_identifier_type_ = BaseHostDataSource::ID_DUID; // 1
bind_[2].buffer_type = MYSQL_TYPE_TINY;
bind_[2].buffer = reinterpret_cast<char*>(&dhcp_identifier_type_);
bind_[2].is_unsigned = MLM_TRUE;
}
dhcp_identifier_type_ = static_cast<uint8_t>(host->getIdentifierType());
bind_[2].buffer_type = MYSQL_TYPE_TINY;
bind_[2].buffer = reinterpret_cast<char*>(&dhcp_identifier_type_);
bind_[2].is_unsigned = MLM_TRUE;
// dhcp4_subnet_id : INT UNSIGNED NULL
// Can't take an address of intermediate object, so let's store it
......@@ -501,25 +479,14 @@ public:
/// @return Host Pointer to a @ref HostPtr object holding a pointer to the
/// @ref Host object returned.
HostPtr retrieveHost() {
// Set the dhcp identifier type in a variable of the appropriate data type,
// which has been initialized with an arbitrary (but valid) value.
Host::IdentifierType type = Host::IDENT_HWADDR;
switch (dhcp_identifier_type_) {
case 0:
type = Host::IDENT_HWADDR;
break;
case 1:
type = Host::IDENT_DUID;
break;
default:
// Check if the identifier stored in the database is correct.
if (dhcp_identifier_type_ > MAX_IDENTIFIER_TYPE) {
isc_throw(BadValue, "invalid dhcp identifier type returned: "
<< static_cast<int>(dhcp_identifier_type_)
<< ". Only 0 or 1 are supported.");
<< static_cast<int>(dhcp_identifier_type_));
}
// Set the dhcp identifier type in a variable of the appropriate data type.
Host::IdentifierType type =
static_cast<Host::IdentifierType>(dhcp_identifier_type_);
// Set DHCPv4 subnet ID to the value returned. If NULL returned, set to 0.
SubnetID ipv4_subnet_id(0);
......
......@@ -26,7 +26,7 @@ GenericHostDataSourceTest::GenericHostDataSourceTest()
GenericHostDataSourceTest::~GenericHostDataSourceTest() {
}
std::string
std::vector<uint8_t>
GenericHostDataSourceTest::generateHWAddr(const bool new_identifier) {
/// @todo: Consider moving this somewhere to lib/testutils.
......@@ -34,15 +34,6 @@ GenericHostDataSourceTest::generateHWAddr(const bool new_identifier) {
// if you need to enter MySQL queries by hand.
static uint8_t hwaddr[] = {65, 66, 67, 68, 69, 70};
stringstream tmp;
for (int i = 0; i < sizeof(hwaddr); ++i) {
if (i) {
tmp << ":";
}
tmp << std::setw(2) << std::hex << std::setfill('0')
<< static_cast<unsigned int>(hwaddr[i]);
}
if (new_identifier) {
// Increase the address for the next time we use it.
// This is primitive, but will work for 65k unique
......@@ -52,46 +43,38 @@ GenericHostDataSourceTest::generateHWAddr(const bool new_identifier) {
hwaddr[sizeof(hwaddr) - 2]++;
}
}
return (tmp.str());
return (std::vector<uint8_t>(hwaddr, hwaddr + sizeof(hwaddr)));
}
std::string
GenericHostDataSourceTest::generateDuid(const bool new_identifier) {
std::vector<uint8_t>
GenericHostDataSourceTest::generateIdentifier(const bool new_identifier) {
/// @todo: Consider moving this somewhere to lib/testutils.
// Let's use something that is easily printable. That's convenient
// if you need to enter MySQL queries by hand.
static uint8_t duid[] = { 65, 66, 67, 68, 69, 70, 71, 72, 73, 74 };
static uint8_t ident[] = { 65, 66, 67, 68, 69, 70, 71, 72, 73, 74 };
stringstream tmp;
for (int i = 0; i < sizeof(duid); ++i) {
tmp << std::setw(2) << std::hex << std::setfill('0')
<< static_cast<unsigned int>(duid[i]);
}
// Increase the DUID for the next time we use it.
// Increase the identifier for the next time we use it.
// This is primitive, but will work for 65k unique
// DUIDs.
// identifiers.
if (new_identifier) {
duid[sizeof(duid) - 1]++;
if (duid[sizeof(duid) - 1] == 0) {
duid[sizeof(duid) - 2]++;
ident[sizeof(ident) - 1]++;
if (ident[sizeof(ident) - 1] == 0) {
ident[sizeof(ident) - 2]++;
}
}
return (tmp.str());
return (std::vector<uint8_t>(ident, ident + sizeof(ident)));
}
HostPtr GenericHostDataSourceTest::initializeHost4(std::string address,
bool hwaddr) {
string ident;
string ident_type;
if (hwaddr) {
HostPtr
GenericHostDataSourceTest::initializeHost4(const std::string& address,
const Host::IdentifierType& id) {
std::vector<uint8_t> ident;
if (id == Host::IDENT_HWADDR) {
ident = generateHWAddr();
ident_type = "hw-address";
} else {
ident = generateDuid();
ident_type = "duid";
ident = generateIdentifier();
}
// Let's create ever increasing subnet-ids. Let's keep those different,
......@@ -103,7 +86,7 @@ HostPtr GenericHostDataSourceTest::initializeHost4(std::string address,
subnet6++;
IOAddress addr(address);
HostPtr host(new Host(ident, ident_type, subnet4, subnet6, addr));
HostPtr host(new Host(&ident[0], ident.size(), id, subnet4, subnet6, addr));
return (host);
}
......@@ -112,17 +95,13 @@ HostPtr GenericHostDataSourceTest::initializeHost6(std::string address,
Host::IdentifierType identifier,
bool prefix,
bool new_identifier) {
string ident;
string ident_type;
std::vector<uint8_t> ident;
switch (identifier) {
case Host::IDENT_HWADDR:
ident = generateHWAddr(new_identifier);
ident_type = "hw-address";
break;
case Host::IDENT_DUID:
ident = generateDuid(new_identifier);
ident_type = "duid";
ident = generateIdentifier(new_identifier);
break;
default:
ADD_FAILURE() << "Unknown IdType: " << identifier;
......@@ -137,7 +116,8 @@ HostPtr GenericHostDataSourceTest::initializeHost6(std::string address,
subnet4++;
subnet6++;
HostPtr host(new Host(ident, ident_type, subnet4, subnet6, IOAddress("0.0.0.0")));
HostPtr host(new Host(&ident[0], ident.size(), identifier, subnet4,
subnet6, IOAddress("0.0.0.0")));
if (!prefix) {
// Create IPv6 reservation (for an address)
......@@ -333,12 +313,12 @@ GenericHostDataSourceTest::compareClientClasses(const ClientClasses& /*classes1*
/// This is part of the work for #4213.
}
void GenericHostDataSourceTest::testBasic4(bool hwaddr) {
void GenericHostDataSourceTest::testBasic4(const Host::IdentifierType& id) {
// Make sure we have the pointer to the host data source.
ASSERT_TRUE(hdsptr_);
// Create a host reservation.
HostPtr host = initializeHost4("192.0.2.1", hwaddr);
HostPtr host = initializeHost4("192.0.2.1", id);
ASSERT_TRUE(host); // Make sure the host is generate properly.
SubnetID subnet = host->getIPv4SubnetID();
......@@ -358,15 +338,15 @@ void GenericHostDataSourceTest::testBasic4(bool hwaddr) {
}
void GenericHostDataSourceTest::testGetByIPv4(bool hwaddr) {
void GenericHostDataSourceTest::testGetByIPv4(const Host::IdentifierType& id) {
// Make sure we have a pointer to the host data source.
ASSERT_TRUE(hdsptr_);
// Let's create a couple of hosts...
HostPtr host1 = initializeHost4("192.0.2.1", hwaddr);
HostPtr host2 = initializeHost4("192.0.2.2", hwaddr);
HostPtr host3 = initializeHost4("192.0.2.3", hwaddr);
HostPtr host4 = initializeHost4("192.0.2.4", hwaddr);
HostPtr host1 = initializeHost4("192.0.2.1", id);
HostPtr host2 = initializeHost4("192.0.2.2", id);
HostPtr host3 = initializeHost4("192.0.2.3", id);
HostPtr host4 = initializeHost4("192.0.2.4", id);
// ... and add them to the data source.
ASSERT_NO_THROW(hdsptr_->add(host1));
......@@ -402,52 +382,16 @@ void GenericHostDataSourceTest::testGetByIPv4(bool hwaddr) {
EXPECT_FALSE(hdsptr_->get4(subnet1, IOAddress("192.0.1.5")));
}
void GenericHostDataSourceTest::testGet4ByHWAddr() {
// Make sure we have a pointer to the host data source.
ASSERT_TRUE(hdsptr_);
HostPtr host1 = initializeHost4("192.0.2.1", true);
HostPtr host2 = initializeHost4("192.0.2.2", true);
// Sanity check: make sure the hosts have different HW addresses.
ASSERT_TRUE(host1->getHWAddress());
ASSERT_TRUE(host2->getHWAddress());
compareHwaddrs(host1, host2, false);
// Try to add both of them to the host data source.
ASSERT_NO_THROW(hdsptr_->add(host1));
ASSERT_NO_THROW(hdsptr_->add(host2));
SubnetID subnet1 = host1->getIPv4SubnetID();
SubnetID subnet2 = host2->getIPv4SubnetID();
ConstHostPtr from_hds1 = hdsptr_->get4(subnet1,
Host::IDENT_HWADDR,
&host1->getIdentifier()[0],
host1->getIdentifier().size());
ConstHostPtr from_hds2 = hdsptr_->get4(subnet2,
Host::IDENT_HWADDR,
&host2->getIdentifier()[0],
host2->getIdentifier().size());
// Now let's check if we got what we expected.
ASSERT_TRUE(from_hds1);
ASSERT_TRUE(from_hds2);
compareHosts(host1, from_hds1);
compareHosts(host2, from_hds2);
}
void GenericHostDataSourceTest::testGet4ByClientId() {
void
GenericHostDataSourceTest::testGet4ByIdentifier(const Host::IdentifierType& identifier_type) {
// Make sure we have a pointer to the host data source.
ASSERT_TRUE(hdsptr_);
HostPtr host1 = initializeHost4("192.0.2.1", false);
HostPtr host2 = initializeHost4("192.0.2.2", false);
HostPtr host1 = initializeHost4("192.0.2.1", identifier_type);
HostPtr host2 = initializeHost4("192.0.2.2", identifier_type);
// Sanity check: make sure the hosts have different client-ids.
ASSERT_TRUE(host1->getDuid());
ASSERT_TRUE(host2->getDuid());
compareDuids(host1, host2, false);
// Sanity check: make sure the hosts have different identifiers..
ASSERT_FALSE(host1->getIdentifier() == host2->getIdentifier());
// Try to add both of them to the host data source.
ASSERT_NO_THROW(hdsptr_->add(host1));
......@@ -457,12 +401,12 @@ void GenericHostDataSourceTest::testGet4ByClientId() {
SubnetID subnet2 = host2->getIPv4SubnetID();
ConstHostPtr from_hds1 = hdsptr_->get4(subnet1,
Host::IDENT_DUID,
identifier_type,
&host1->getIdentifier()[0],
host1->getIdentifier().size());
ConstHostPtr from_hds2 = hdsptr_->get4(subnet2,
Host::IDENT_DUID,
identifier_type,
&host2->getIdentifier()[0],
host2->getIdentifier().size());
......@@ -478,7 +422,7 @@ void GenericHostDataSourceTest::testHWAddrNotClientId() {
ASSERT_TRUE(hdsptr_);
// Create a host with HW address
HostPtr host = initializeHost4("192.0.2.1", true);
HostPtr host = initializeHost4("192.0.2.1", Host::IDENT_HWADDR);
ASSERT_TRUE(host->getHWAddress());
ASSERT_FALSE(host->getDuid());
......@@ -509,7 +453,7 @@ void GenericHostDataSourceTest::testClientIdNotHWAddr() {
ASSERT_TRUE(hdsptr_);
// Create a host with client-id
HostPtr host = initializeHost4("192.0.2.1", false);
HostPtr host = initializeHost4("192.0.2.1", Host::IDENT_DUID);
ASSERT_FALSE(host->getHWAddress());
ASSERT_TRUE(host->getDuid());
......@@ -553,7 +497,7 @@ GenericHostDataSourceTest::testHostname(std::string name, int num) {
addr = IOAddress::increase(addr);
HostPtr host = initializeHost4(addr.toText(), false);
HostPtr host = initializeHost4(addr.toText(), Host::IDENT_DUID);
stringstream hostname;
hostname.str("");
......@@ -589,12 +533,13 @@ GenericHostDataSourceTest::testHostname(std::string name, int num) {
}
void
GenericHostDataSourceTest::testMultipleSubnets(int subnets, bool hwaddr) {
GenericHostDataSourceTest::testMultipleSubnets(int subnets,
const Host::IdentifierType& id) {
// Make sure we have a pointer to the host data source.
ASSERT_TRUE(hdsptr_);
HostPtr host = initializeHost4("192.0.2.1", hwaddr);
HostPtr host = initializeHost4("192.0.2.1", id);
for (int i = 0; i < subnets; ++i) {
host->setIPv4SubnetID(i + 1000);
......@@ -616,8 +561,7 @@ GenericHostDataSourceTest::testMultipleSubnets(int subnets, bool hwaddr) {
// Try to retrieve the host by either HW address of client-id
from_hds = hdsptr_->get4(i + 1000,
hwaddr ? Host::IDENT_HWADDR : Host::IDENT_DUID,
&host->getIdentifier()[0],
id, &host->getIdentifier()[0],
host->getIdentifier().size());
ASSERT_TRUE(from_hds);
EXPECT_EQ(i + 1000, from_hds->getIPv4SubnetID());
......@@ -637,8 +581,7 @@ GenericHostDataSourceTest::testMultipleSubnets(int subnets, bool hwaddr) {
// Finally, check that the hosts can be retrived by HW address or DUID
ConstHostCollection all_by_id =
hdsptr_->getAll(hwaddr ? Host::IDENT_HWADDR : Host::IDENT_DUID,
&host->getIdentifier()[0],
hdsptr_->getAll(id, &host->getIdentifier()[0],
host->getIdentifier().size());
ASSERT_EQ(subnets, all_by_id.size());
......@@ -656,8 +599,8 @@ void GenericHostDataSourceTest::testGet6ByHWAddr() {
ASSERT_TRUE(hdsptr_);
// Create a host reservations.
HostPtr host1 = initializeHost6("2001:db8::1", Host::IDENT_HWADDR, true);
HostPtr host2 = initializeHost6("2001:db8::2", Host::IDENT_HWADDR, true);
HostPtr host1 = initializeHost6("2001:db8::1", Host::IDENT_HWADDR, "hw-address");
HostPtr host2 = initializeHost6("2001:db8::2", Host::IDENT_HWADDR, "hw-address");
// Sanity check: make sure the hosts have different HW addresses.
ASSERT_TRUE(host1->getHWAddress());
......@@ -692,8 +635,8 @@ void GenericHostDataSourceTest::testGet6ByClientId() {
ASSERT_TRUE(hdsptr_);
// Create a host reservations.
HostPtr host1 = initializeHost6("2001:db8::1", Host::IDENT_DUID, true);
HostPtr host2 = initializeHost6("2001:db8::2", Host::IDENT_DUID, true);
HostPtr host1 = initializeHost6("2001:db8::1", Host::IDENT_DUID, "hw-address");
HostPtr host2 = initializeHost6("2001:db8::2", Host::IDENT_DUID, "hw-address");
// Sanity check: make sure the hosts have different HW addresses.
ASSERT_TRUE(host1->getDuid());
......@@ -848,7 +791,7 @@ void GenericHostDataSourceTest::testAddDuplicate4() {
ASSERT_TRUE(hdsptr_);
// Create a host reservations.
HostPtr host = initializeHost4("192.0.2.1", false);
HostPtr host = initializeHost4("192.0.2.1", Host::IDENT_DUID);
// Add this reservation once.
ASSERT_NO_THROW(hdsptr_->add(host));
......
......@@ -39,10 +39,11 @@ public:
/// @brief Creates a host reservation for specified IPv4 address.
///
/// @param address IPv4 address to be set
/// @param hwaddr type of identifier (true = hwaddr, false = client-id)
/// @param id Identifier type.
///
/// @return generated Host object
HostPtr initializeHost4(std::string address, bool hwaddr);
HostPtr initializeHost4(const std::string& address,
const Host::IdentifierType& id);
/// @brief Creates a host reservation for specified IPv6 address.
///
......@@ -61,14 +62,14 @@ public:
/// @param increase A boolean value indicating if new address (increased)
/// must be generated or the same address as previously.
/// @return HW address in textual form acceptable by Host constructor
std::string generateHWAddr(const bool new_identifier = true);
std::vector<uint8_t> generateHWAddr(const bool new_identifier = true);
/// @brief Generates a hardware address in text version.
/// @brief Generates a host identifier in a textual form..
///
/// @param increase A boolean value indicating if new DUID (increased)
/// must be generated or the same DUID as previously.
/// @return DUID in textual form acceptable by Host constructor
std::string generateDuid(const bool new_identifier = true);
/// @param increase A boolean value indicating if new identifier (increased)
/// must be generated or the same identifier as previously.
/// @return Identifier in textual form acceptable by Host constructor
std::vector<uint8_t> generateIdentifier(const bool new_identifier = true);
/// @brief Compares hardware addresses of the two hosts.
///
......@@ -130,25 +131,20 @@ public:
/// can be inserted and later retrieved.
///
/// Uses gtest macros to report failures.
/// @param hwaddr true = use HW address as identifier, false = use client-id(DUID)
void testBasic4(bool hwaddr);
/// @param id Identifier type.
void testBasic4(const Host::IdentifierType& id);
/// @brief Test inserts several hosts with unique IPv4 address and
/// checks that they can be retrieved properly.
///
/// Uses gtest macros to report failures.
/// @param hwaddr true = use HW address as identifier, false = use client-id(DUID)
void testGetByIPv4(bool hwaddr);
/// @brief Test that hosts can be retrieved by hardware address.
///
/// Uses gtest macros to report failures.
void testGet4ByHWAddr();
/// @param id Identifier type.
void testGetByIPv4(const Host::IdentifierType& id);
/// @brief Test that hosts can be retrieved by client-id
/// @brief Test that hosts can be retrieved by host identifier.
///
/// Uses gtest macros to report failures.
void testGet4ByClientId();
void testGet4ByIdentifier(const Host::IdentifierType& identifier_type);
/// @brief Test that clients with stored HW address can't be retrieved
/// by DUID with the same value.
......@@ -184,8 +180,8 @@ public:
/// Uses gtest macros to report failures.
///
/// @param subnets number of subnets to test
/// @param hwaddr true = use HW address, false = use client-id
void testMultipleSubnets(int subnets, bool hwaddr);
/// @param id Host identifier type.
void testMultipleSubnets(int subnets, const Host::IdentifierType& id);
/// @brief Test inserts several hosts with unique IPv6 addresses and
/// checks that they can be retrieved properly.
......
......@@ -159,24 +159,6 @@ public:
return (false);
}
/// @brief Converts identifier type to its name.
///
/// @param type identifier type.
/// @return Identifier name as specified in a configuration file.
std::string identifierName(const Host::IdentifierType& type) const {
switch (type) {
case Host::IDENT_HWADDR:
return ("hw-address");
case Host::IDENT_DUID:
return ("duid");
case Host::IDENT_CIRCUIT_ID:
return ("circuit-id");
default:
;
}
return ("unknown");
}
/// @brief Returns upper bound of the supported identifier types.
///
/// Some unit tests verify the @c Host class behavior for all
......@@ -364,7 +346,7 @@ TEST_F(HostTest, createFromIdentifierHex) {
const std::string identifier_hex = (hwaddr ?
hwaddr->toText(false) :
util::encode::encodeHex(identifier));
const std::string identifier_name = identifierName(type);
const std::string identifier_name = Host::getIdentifierName(type);
// Try to create Host instance.
ASSERT_NO_THROW(host.reset(new Host(identifier_hex, identifier_name,
......@@ -394,7 +376,7 @@ TEST_F(HostTest, createFromIdentifierString) {
// It is not allowed to specify HW address or DUID as a string in quotes.
for (unsigned int i = 2; i < identifierTypeUpperBound(); ++i) {
const Host::IdentifierType type = static_cast<Host::IdentifierType>(i);
const std::string identifier_name = identifierName(type);
const std::