TEST(ClassifyTest, ClientClassesFromString) {
{
ClientClasses classes("alpha, beta, gamma");
- EXPECT_EQ(3, classes.size());
+ EXPECT_EQ(3U, classes.size());
EXPECT_FALSE(classes.contains(""));
EXPECT_TRUE(classes.contains("alpha"));
EXPECT_TRUE(classes.contains("beta"));
{
ClientClasses classes("alpha, , beta ,");
- EXPECT_EQ(2, classes.size());
+ EXPECT_EQ(2U, classes.size());
EXPECT_TRUE(classes.contains("alpha"));
EXPECT_FALSE(classes.contains(""));
EXPECT_TRUE(classes.contains("beta"));
cclasses_element->add(Element::create("bar"));
ASSERT_NO_THROW(classes.fromElement(cclasses_element));
- ASSERT_EQ(classes.size(), 2);
+ ASSERT_EQ(classes.size(), 2U);
auto cclass = classes.begin();
EXPECT_EQ(*cclass, "foo");
++cclass;
results.insert(hash(cclasses));
// Should have all four entries.
- EXPECT_EQ(4, results.size());
+ EXPECT_EQ(4U, results.size());
// Check that empty containers make equal hashes.
ClientClasses empty1;
DUIDFactory& factory_ref) {
DuidPtr duid = factory_ref.get();
ASSERT_TRUE(duid);
- ASSERT_GE(duid->getDuid().size(), 14);
+ ASSERT_GE(duid->getDuid().size(), 14U);
std::string duid_text = toString(duid->getDuid());
// DUID type LLT
DUIDFactory& factory_ref) {
DuidPtr duid = factory_ref.get();
ASSERT_TRUE(duid);
- ASSERT_GE(duid->getDuid().size(), 8);
+ ASSERT_GE(duid->getDuid().size(), 8U);
std::string duid_text = toString(duid->getDuid());
// DUID type EN.
DUIDFactory& factory_ref) {
DuidPtr duid = factory_ref.get();
ASSERT_TRUE(duid);
- ASSERT_GE(duid->getDuid().size(), 8);
+ ASSERT_GE(duid->getDuid().size(), 8U);
std::string duid_text = toString(duid->getDuid());
// DUID type LL
TEST(DuidTest, size) {
// Ensure that our size constant is RFC-compliant.
- ASSERT_EQ(130, DUID::MAX_DUID_LEN);
+ ASSERT_EQ(130U, DUID::MAX_DUID_LEN);
uint8_t data[DUID::MAX_DUID_LEN + 1];
vector<uint8_t> data2;
// Ok, technically empty is not really empty, it's just type 0 (DUID_UNKNOWN)
// followed by a single byte with value of 0.
- EXPECT_EQ(empty->getDuid().size(), 3);
+ EXPECT_EQ(empty->getDuid().size(), 3U);
EXPECT_EQ(empty->getDuid(), std::vector<uint8_t>({0, 0, 0}));
EXPECT_EQ("00:00:00", empty->toText());
// Check that client-id sizes are reasonable
TEST(ClientIdTest, size) {
// Ensure that our size constant is RFC-compliant.
- ASSERT_EQ(255, ClientId::MAX_CLIENT_ID_LEN);
+ ASSERT_EQ(255U, ClientId::MAX_CLIENT_ID_LEN);
uint8_t data[ClientId::MAX_CLIENT_ID_LEN + 1];
vector<uint8_t> data2;
EXPECT_TRUE(data2 == hwaddr2->hwaddr_);
EXPECT_EQ(htype, hwaddr2->htype_);
- EXPECT_EQ(0, hwaddr3->hwaddr_.size());
+ EXPECT_EQ(0U, hwaddr3->hwaddr_.size());
EXPECT_EQ(htype, hwaddr3->htype_);
// Check that over the limit data length throws exception
Iface iface("em0", 0);
// The size of read buffer should initially be 0 and the returned
// pointer should be NULL.
- ASSERT_EQ(0, iface.getReadBufferSize());
- EXPECT_EQ(NULL, iface.getReadBuffer());
+ ASSERT_EQ(0U, iface.getReadBufferSize());
+ EXPECT_EQ(0, iface.getReadBuffer());
// Let's resize the buffer.
iface.resizeReadBuffer(256);
// Check that the buffer has expected size.
- ASSERT_EQ(256, iface.getReadBufferSize());
+ ASSERT_EQ(256U, iface.getReadBufferSize());
// The returned pointer should now be non-NULL.
uint8_t* buf_ptr = iface.getReadBuffer();
- ASSERT_FALSE(buf_ptr == NULL);
+ ASSERT_FALSE(buf_ptr == 0);
// Use the pointer to set some data.
for (size_t i = 0; i < iface.getReadBufferSize(); ++i) {
// Get the pointer again and validate the data.
buf_ptr = iface.getReadBuffer();
- ASSERT_EQ(256, iface.getReadBufferSize());
+ ASSERT_EQ(256U, iface.getReadBufferSize());
for (size_t i = 0; i < iface.getReadBufferSize(); ++i) {
// Use assert so as it fails on the first failure, no need
// to continue further checks.
// works as expected.
TEST(IfaceTest, countActive4) {
Iface iface("eth0", 0);
- ASSERT_EQ(0, iface.countActive4());
+ ASSERT_EQ(0U, iface.countActive4());
iface.addAddress(IOAddress("192.168.0.2"));
- ASSERT_EQ(1, iface.countActive4());
+ ASSERT_EQ(1U, iface.countActive4());
iface.addAddress(IOAddress("2001:db8:1::1"));
- ASSERT_EQ(1, iface.countActive4());
+ ASSERT_EQ(1U, iface.countActive4());
iface.addAddress(IOAddress("192.168.0.3"));
- ASSERT_EQ(2, iface.countActive4());
+ ASSERT_EQ(2U, iface.countActive4());
ASSERT_NO_THROW(iface.setActive(IOAddress("192.168.0.2"), false));
- ASSERT_EQ(1, iface.countActive4());
+ ASSERT_EQ(1U, iface.countActive4());
ASSERT_NO_THROW(iface.setActive(IOAddress("192.168.0.3"), false));
- ASSERT_EQ(0, iface.countActive4());
+ ASSERT_EQ(0U, iface.countActive4());
}
/// Mock object implementing PktFilter class. It is used by
ASSERT_EQ(unicast_num
+ (iface.flag_multicast_ ? 2 * link_local_num : 0)
+ link_local_num,
- iface.getSockets().size())
+ static_cast<int>(iface.getSockets().size()))
<< "invalid number of sockets on interface "
<< iface.getName();
#else
// On non-Linux, there is no additional socket.
- ASSERT_EQ(unicast_num + link_local_num, iface.getSockets().size())
+ ASSERT_EQ(unicast_num + link_local_num,
+ static_cast<int>(iface.getSockets().size()))
<< "invalid number of sockets on interface "
<< iface.getName();
sendPkt->setIface(LOOPBACK_NAME);
// Send the packet.
- EXPECT_EQ(true, ifacemgr->send(sendPkt));
+ EXPECT_TRUE(ifacemgr->send(sendPkt));
// Now, let's try and receive it.
Pkt6Ptr rcvPkt;
IfaceMgr::instance().configureDHCPPacketQueue(AF_INET, data::ConstElementPtr());
}
IfaceMgr::instance().openSockets4(9999, true, IfaceMgrErrorMsgCallback(), false);
- EXPECT_EQ((boost::dynamic_pointer_cast<PktFilter4IfaceSocketTest>(filter))->socket_fds_.size(), 250);
+ EXPECT_EQ((boost::dynamic_pointer_cast<PktFilter4IfaceSocketTest>(filter))->socket_fds_.size(), 250U);
// Create first pipe and register it as extra socket
int pipefd[2];
IfaceMgr::instance().configureDHCPPacketQueue(AF_INET6, data::ConstElementPtr());
}
IfaceMgr::instance().openSockets6(9999, IfaceMgrErrorMsgCallback(), false);
- EXPECT_EQ((boost::dynamic_pointer_cast<PktFilter6IfaceSocketTest>(filter))->socket_fds_.size(), 250);
+ EXPECT_EQ((boost::dynamic_pointer_cast<PktFilter6IfaceSocketTest>(filter))->socket_fds_.size(), 250U);
// Create first pipe and register it as extra socket
int pipefd[2];
IfaceMgr::instance().configureDHCPPacketQueue(AF_INET, data::ConstElementPtr());
}
IfaceMgr::instance().openSockets4(9999, true, IfaceMgrErrorMsgCallback(), false);
- EXPECT_EQ((boost::dynamic_pointer_cast<PktFilter4IfaceSocketTest>(filter))->socket_fds_.size(), 250);
+ EXPECT_EQ((boost::dynamic_pointer_cast<PktFilter4IfaceSocketTest>(filter))->socket_fds_.size(), 250U);
Pkt4Ptr pkt0(new Pkt4(DHCPDISCOVER, 1234));
pkt0->setIface("eth0");
pkt0->setIndex(0);
IfaceMgr::instance().configureDHCPPacketQueue(AF_INET6, data::ConstElementPtr());
}
IfaceMgr::instance().openSockets6(9999, IfaceMgrErrorMsgCallback(), false);
- EXPECT_EQ((boost::dynamic_pointer_cast<PktFilter6IfaceSocketTest>(filter))->socket_fds_.size(), 250);
+ EXPECT_EQ((boost::dynamic_pointer_cast<PktFilter6IfaceSocketTest>(filter))->socket_fds_.size(), 250U);
Pkt6Ptr pkt0(new Pkt6(DHCPV6_SOLICIT, 1234));
pkt0->setIface("eth0");
pkt0->setIndex(0);
"Interface name must not be empty");
EXPECT_NO_THROW(iface.reset(new Iface("big-index", 66666)));
- EXPECT_EQ(66666, iface->getIndex());
+ EXPECT_EQ(66666U, iface->getIndex());
}
// This test checks the getIface by index method.
ASSERT_TRUE(tmp);
EXPECT_EQ("en99", tmp->getName());
- EXPECT_EQ(102, tmp->getIndex());
+ EXPECT_EQ(102U, tmp->getIndex());
// Check that interface can be retrieved by name
tmp = ifacemgr->getIface("lo1");
ASSERT_TRUE(tmp);
EXPECT_EQ("lo1", tmp->getName());
- EXPECT_EQ(100, tmp->getIndex());
+ EXPECT_EQ(100U, tmp->getIndex());
// Check that non-existing interfaces are not returned
EXPECT_FALSE(ifacemgr->getIface("wifi15") );
ifacemgr.clearIfaces();
- EXPECT_EQ(0, ifacemgr.countIfaces());
+ EXPECT_EQ(0U, ifacemgr.countIfaces());
}
// Verify that we have the expected default DHCPv4 packet queue.
// be on the list. Here we start to test if all expected sockets
// are on the list and no other (unexpected) socket is there.
Iface::SocketCollection sockets = iface_ptr->getSockets();
- int matched_sockets = 0;
+ size_t matched_sockets = 0;
for (std::list<uint16_t>::iterator init_sockets_it =
init_sockets.begin();
init_sockets_it != init_sockets.end(); ++init_sockets_it) {
// Closed sockets are supposed to be removed from the list
sockets = iface_ptr->getSockets();
- ASSERT_EQ(0, sockets.size());
+ ASSERT_EQ(0U, sockets.size());
// We are still in possession of socket descriptors that we created
// on the beginning of this test. We can use them to check whether
ASSERT_NO_THROW(ifacemgr.openSockets4(DHCP4_SERVER_PORT, true, 0));
// Expect that the sockets are open on both eth0 and eth1.
- EXPECT_EQ(1, ifacemgr.getIface("eth0")->getSockets().size());
- EXPECT_EQ(1, ifacemgr.getIface(ETH0_INDEX)->getSockets().size());
- EXPECT_EQ(1, ifacemgr.getIface("eth1")->getSockets().size());
- EXPECT_EQ(1, ifacemgr.getIface(ETH1_INDEX)->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface("eth0")->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface(ETH0_INDEX)->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface("eth1")->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface(ETH1_INDEX)->getSockets().size());
// Socket shouldn't have been opened on loopback.
EXPECT_TRUE(ifacemgr.getIface("lo")->getSockets().empty());
EXPECT_TRUE(ifacemgr.getIface(LO_INDEX)->getSockets().empty());
ASSERT_NO_THROW(ifacemgr.openSockets4(DHCP4_SERVER_PORT, true, 0));
// Expect that the sockets are open on all interfaces.
- EXPECT_EQ(1, ifacemgr.getIface("eth0")->getSockets().size());
- EXPECT_EQ(1, ifacemgr.getIface(ETH0_INDEX)->getSockets().size());
- EXPECT_EQ(1, ifacemgr.getIface("eth1")->getSockets().size());
- EXPECT_EQ(1, ifacemgr.getIface(ETH1_INDEX)->getSockets().size());
- EXPECT_EQ(1, ifacemgr.getIface("lo")->getSockets().size());
- EXPECT_EQ(1, ifacemgr.getIface(LO_INDEX)->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface("eth0")->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface(ETH0_INDEX)->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface("eth1")->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface(ETH1_INDEX)->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface("lo")->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface(LO_INDEX)->getSockets().size());
}
// This test verifies that the socket is not open on the interface which is
// Expecting that the socket is open on eth1 because it was up, running
// and active.
- EXPECT_EQ(2, IfaceMgr::instance().getIface("eth1")->getSockets().size());
- EXPECT_EQ(2, IfaceMgr::instance().getIface(ETH1_INDEX)->getSockets().size());
+ EXPECT_EQ(2U, IfaceMgr::instance().getIface("eth1")->getSockets().size());
+ EXPECT_EQ(2U, IfaceMgr::instance().getIface(ETH1_INDEX)->getSockets().size());
// Same for eth1961.
- EXPECT_EQ(1, IfaceMgr::instance().getIface("eth1961")->getSockets().size());
- EXPECT_EQ(1, IfaceMgr::instance().getIface(ETH1961_INDEX)->getSockets().size());
+ EXPECT_EQ(1U, IfaceMgr::instance().getIface("eth1961")->getSockets().size());
+ EXPECT_EQ(1U, IfaceMgr::instance().getIface(ETH1961_INDEX)->getSockets().size());
// Never open socket on loopback interface.
EXPECT_TRUE(IfaceMgr::instance().getIface("lo")->getSockets().empty());
EXPECT_TRUE(IfaceMgr::instance().getIface(LO_INDEX)->getSockets().empty());
// The socket on eth0 should be open because interface is up, running and
// active (not disabled through DHCP configuration, for example).
- EXPECT_EQ(1, ifacemgr.getIface("eth0")->getSockets().size());
- EXPECT_EQ(1, ifacemgr.getIface(ETH0_INDEX)->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface("eth0")->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface(ETH0_INDEX)->getSockets().size());
// There should be no socket open on eth1 because it was marked inactive.
EXPECT_TRUE(ifacemgr.getIface("eth1")->getSockets().empty());
EXPECT_TRUE(ifacemgr.getIface(ETH1_INDEX)->getSockets().empty());
ASSERT_NO_THROW(ifacemgr.openSockets4(DHCP4_SERVER_PORT, true, 0));
// Expect that the sockets are open on both eth0 and eth1.
- ASSERT_EQ(1, ifacemgr.getIface("eth0")->getSockets().size());
- ASSERT_EQ(1, ifacemgr.getIface(ETH0_INDEX)->getSockets().size());
- ASSERT_EQ(1, ifacemgr.getIface("eth1")->getSockets().size());
- ASSERT_EQ(1, ifacemgr.getIface(ETH1_INDEX)->getSockets().size());
+ ASSERT_EQ(1U, ifacemgr.getIface("eth0")->getSockets().size());
+ ASSERT_EQ(1U, ifacemgr.getIface(ETH0_INDEX)->getSockets().size());
+ ASSERT_EQ(1U, ifacemgr.getIface("eth1")->getSockets().size());
+ ASSERT_EQ(1U, ifacemgr.getIface(ETH1_INDEX)->getSockets().size());
// Socket shouldn't have been opened on loopback.
ASSERT_TRUE(ifacemgr.getIface("lo")->getSockets().empty());
ASSERT_TRUE(ifacemgr.getIface(LO_INDEX)->getSockets().empty());
EXPECT_TRUE(success);
// Check that the loopback interface has at least an open socket.
- EXPECT_EQ(1, ifacemgr.getIface("lo")->getSockets().size());
- EXPECT_EQ(1, ifacemgr.getIface(LO_INDEX)->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface("lo")->getSockets().size());
+ EXPECT_EQ(1U, ifacemgr.getIface(LO_INDEX)->getSockets().size());
// This socket should be bound to ::1
EXPECT_TRUE(ifacemgr.isBound("lo", "::1"));
EXPECT_NO_THROW(iface.reset(new Iface("eth0",1)));
EXPECT_EQ("eth0", iface->getName());
- EXPECT_EQ(1, iface->getIndex());
+ EXPECT_EQ(1U, iface->getIndex());
EXPECT_EQ("eth0/1", iface->getFullName());
// Let's make a copy of this address collection.
Iface::AddressCollection addrs = iface->getAddresses();
- EXPECT_EQ(0, addrs.size());
+ EXPECT_EQ(0U, addrs.size());
IOAddress addr1("192.0.2.6");
iface->addAddress(addr1);
addrs = iface->getAddresses();
- ASSERT_EQ(1, addrs.size());
+ ASSERT_EQ(1U, addrs.size());
EXPECT_EQ("192.0.2.6", addrs.begin()->get().toText());
// No such address, should return false.
// usage code as well.
addrs = iface->getAddresses();
- EXPECT_EQ(0, addrs.size());
+ EXPECT_EQ(0U, addrs.size());
EXPECT_NO_THROW(iface.reset());
}
Iface iface("foo", 1234);
iface.setHWType(42);
- EXPECT_EQ(42, iface.getHWType());
+ EXPECT_EQ(42U, iface.getHWType());
- ASSERT_LT(Iface::MAX_MAC_LEN + 10, 255);
+ ASSERT_LT(Iface::MAX_MAC_LEN + 10, 255U);
- uint8_t mac[Iface::MAX_MAC_LEN+10];
+ uint8_t mac[Iface::MAX_MAC_LEN + 10];
for (uint8_t i = 0; i < Iface::MAX_MAC_LEN + 10; i++) {
mac[i] = 255 - i;
}
EXPECT_EQ("foo", iface.getName());
- EXPECT_EQ(1234, iface.getIndex());
+ EXPECT_EQ(1234U, iface.getIndex());
// MAC is too long. Exception should be thrown and
// MAC length should not be set.
);
// MAC length should stay not set as exception was thrown.
- EXPECT_EQ(0, iface.getMacLen());
+ EXPECT_EQ(0U, iface.getMacLen());
// Setting maximum length MAC should be ok.
iface.setMac(mac, Iface::MAX_MAC_LEN);
// This will work
pkt6->setIndex(LOOPBACK_INDEX);
- EXPECT_EQ(9, ifacemgr->getSocket(pkt6));
+ EXPECT_EQ(9U, ifacemgr->getSocket(pkt6));
bool deleted = false;
EXPECT_NO_THROW(
deleted = ifacemgr->getIface(LOOPBACK_NAME)->delSocket(9);
);
- EXPECT_EQ(true, deleted);
+ EXPECT_TRUE(deleted);
// It should throw again, there's no usable socket anymore
EXPECT_THROW(
ASSERT_TRUE(ifacemgr_->getCheckThreadId());
testThread();
- EXPECT_EQ(1, countFile("DHCP_ADD_EXTERNAL_SOCKET_BAD_THREAD"));
- EXPECT_EQ(1, countFile("DHCP_DELETE_EXTERNAL_SOCKET_BAD_THREAD"));
- EXPECT_EQ(1, countFile("DHCP_DELETE_ALL_EXTERNAL_SOCKETS_BAD_THREAD"));
+ EXPECT_EQ(1U, countFile("DHCP_ADD_EXTERNAL_SOCKET_BAD_THREAD"));
+ EXPECT_EQ(1U, countFile("DHCP_DELETE_EXTERNAL_SOCKET_BAD_THREAD"));
+ EXPECT_EQ(1U, countFile("DHCP_DELETE_ALL_EXTERNAL_SOCKETS_BAD_THREAD"));
}
// Tests that errors are logged only when enabled.
ASSERT_FALSE(ifacemgr_->getCheckThreadId());
testThread();
- EXPECT_EQ(0, countFile("DHCP"));
+ EXPECT_EQ(0U, countFile("DHCP"));
}
// Tests that calling twice addExternalSocket on the same value warns.
TEST_F(IfaceMgrLogTest, addExternalSocketAlreadyExists) {
ASSERT_TRUE(ifacemgr_);
ASSERT_NO_THROW(ifacemgr_->addExternalSocket(100, 0));
- EXPECT_EQ(0, countFile("DHCP_ADD_EXTERNAL_SOCKET_ALREADY_EXISTS"));
+ EXPECT_EQ(0U, countFile("DHCP_ADD_EXTERNAL_SOCKET_ALREADY_EXISTS"));
ASSERT_NO_THROW(ifacemgr_->addExternalSocket(100, 0));
- EXPECT_EQ(1, countFile("DHCP_ADD_EXTERNAL_SOCKET_ALREADY_EXISTS"));
+ EXPECT_EQ(1U, countFile("DHCP_ADD_EXTERNAL_SOCKET_ALREADY_EXISTS"));
}
// Tests that calling twice deleteExternalSocket on the same value warns.
ASSERT_NO_THROW(ifacemgr_->addExternalSocket(100, 0));
EXPECT_TRUE(ifacemgr_->isExternalSocket(100));
ASSERT_NO_THROW(ifacemgr_->deleteExternalSocket(100));
- EXPECT_EQ(0, countFile("DHCP_DELETE_EXTERNAL_SOCKET_NOT_FOUND"));
+ EXPECT_EQ(0U, countFile("DHCP_DELETE_EXTERNAL_SOCKET_NOT_FOUND"));
EXPECT_FALSE(ifacemgr_->isExternalSocket(100));
ASSERT_NO_THROW(ifacemgr_->deleteExternalSocket(100));
- EXPECT_EQ(1, countFile("DHCP_DELETE_EXTERNAL_SOCKET_NOT_FOUND"));
+ EXPECT_EQ(1U, countFile("DHCP_DELETE_EXTERNAL_SOCKET_NOT_FOUND"));
}
// Test checks if the unicast sockets can be opened.
EXPECT_TRUE(ifacemgr->openSockets6(PORT1));
const Iface::SocketCollection& sockets = iface->getSockets();
- ASSERT_GE(2, sockets.size());
+ ASSERT_GE(2U, sockets.size());
// Global unicast should be first
EXPECT_TRUE(getSocketByAddr(sockets, IOAddress("2001:db8::1")));
ASSERT_NO_THROW(LibDHCP::packOptions4(buf, col, true));
ASSERT_NE(expected, pkt->toText());
- ASSERT_EQ(64, col.size());
+ ASSERT_EQ(64U, col.size());
uint8_t index = 0;
for (auto const& opt : col) {
- ASSERT_EQ(opt.first, 231);
- ASSERT_EQ(1, opt.second->getData().size());
+ ASSERT_EQ(opt.first, 231U);
+ ASSERT_EQ(1U, opt.second->getData().size());
ASSERT_EQ(index, opt.second->getData()[0]);
index++;
}
top_opt->getHeaderLen() + bottom_size + middle_size + top_size,
buf.getLength());
- ASSERT_EQ(3, col.size());
+ ASSERT_EQ(3U, col.size());
for (auto const& bottom_subopt : col) {
- ASSERT_EQ(bottom_subopt.second->getType(), 170);
+ ASSERT_EQ(bottom_subopt.second->getType(), 170U);
if (opt_count == 0) {
// First option contains only data (0..127) and no suboptions.
ASSERT_EQ(bottom_subopt.second->getData().size(), bottom_size);
ASSERT_EQ(value, static_cast<uint8_t>(index));
index++;
}
- ASSERT_EQ(bottom_subopt.second->getOptions().size(), 0);
+ ASSERT_EQ(bottom_subopt.second->getOptions().size(), 0U);
} else {
// All other options contain no data and suboption 171.
- ASSERT_EQ(bottom_subopt.second->getOptions().size(), 1);
+ ASSERT_EQ(bottom_subopt.second->getOptions().size(), 1U);
for (auto const& middle_subopt : bottom_subopt.second->getOptions()) {
- ASSERT_EQ(middle_subopt.first, 171);
+ ASSERT_EQ(middle_subopt.first, 171U);
if (opt_count == 1) {
// First suboption 171 contains only data (0) and no suboptions.
ASSERT_EQ(middle_subopt.second->getData().size(), middle_size);
ASSERT_EQ(value, static_cast<uint8_t>(index));
index++;
}
- ASSERT_EQ(middle_subopt.second->getOptions().size(), 0);
+ ASSERT_EQ(middle_subopt.second->getOptions().size(), 0U);
} else {
// Second suboption 171 contains no data and suboption 172.
- ASSERT_EQ(middle_subopt.second->getData().size(), 0);
- ASSERT_EQ(middle_subopt.second->getOptions().size(), 1);
+ ASSERT_EQ(middle_subopt.second->getData().size(), 0U);
+ ASSERT_EQ(middle_subopt.second->getOptions().size(), 1U);
auto const& top_subopt = middle_subopt.second->getOptions().find(172);
ASSERT_NE(top_subopt, middle_subopt.second->getOptions().end());
- ASSERT_EQ(top_subopt->second->getType(), 172);
+ ASSERT_EQ(top_subopt->second->getType(), 172U);
// Suboption 172 contains only data (0..248) and no suboptions.
ASSERT_EQ(top_subopt->second->getData().size(), top_size);
index = 0;
ASSERT_EQ(value, static_cast<uint8_t>(index));
index++;
}
- ASSERT_EQ(top_subopt->second->getOptions().size(), 0);
+ ASSERT_EQ(top_subopt->second->getOptions().size(), 0U);
}
}
}
ASSERT_NO_THROW(LibDHCP::unpackOptions4(opts_buffer, DHCP4_OPTION_SPACE,
col_back, deferred_options));
- ASSERT_EQ(1, col_back.size());
- EXPECT_EQ(170, col_back.begin()->first);
+ ASSERT_EQ(1U, col_back.size());
+ EXPECT_EQ(170U, col_back.begin()->first);
OptionPtr opt_back = col_back.begin()->second;
ASSERT_TRUE(opt_back);
// Using unpackOptions4 will not create suboptions, so entire
// data is serialized in the option buffer.
- ASSERT_EQ(opt_back->getOptions().size(), 0);
+ ASSERT_EQ(opt_back->getOptions().size(), 0U);
OptionBuffer opt_data;
// Data 0..127
index = 0;
ASSERT_NO_THROW(LibDHCP::packOptions4(buf, col, true));
ASSERT_NE(expected, pkt->toText());
- ASSERT_EQ(11, col.size());
- ASSERT_EQ(2560 + 11 * option->getHeaderLen(), buf.getLength());
+ ASSERT_EQ(11U, col.size());
+ ASSERT_EQ(2560U + 11 * option->getHeaderLen(), buf.getLength());
}
ASSERT_EQ(expected, pkt->toText());
ASSERT_NO_THROW(LibDHCP::unpackOptions4(opts_buffer, DHCP4_OPTION_SPACE,
col_back, deferred_options));
- ASSERT_EQ(1, col_back.size());
- EXPECT_EQ(231, col_back.begin()->first);
+ ASSERT_EQ(1U, col_back.size());
+ EXPECT_EQ(231U, col_back.begin()->first);
OptionPtr opt_back = col_back.begin()->second;
ASSERT_TRUE(opt_back);
EXPECT_TRUE(option->equals(*opt_back));
ASSERT_NO_THROW(LibDHCP::packOptions4(buf, col, true));
ASSERT_NE(expected, pkt->toText());
- ASSERT_EQ(3, col.size());
+ ASSERT_EQ(3U, col.size());
ASSERT_EQ(3 * rai->getHeaderLen() + circuit_id_opt->getHeaderLen() +
remote_id_opt->getHeaderLen() + subscriber_id_opt->getHeaderLen() +
- 3 * 128, buf.getLength());
+ 3 * 128, static_cast<long>(buf.getLength()));
}
ASSERT_EQ(expected, pkt->toText());
ASSERT_NO_THROW(LibDHCP::unpackOptions4(opts_buffer, DHCP4_OPTION_SPACE,
col_back, deferred_options));
- ASSERT_EQ(1, col_back.size());
+ ASSERT_EQ(1U, col_back.size());
EXPECT_EQ(DHO_DHCP_AGENT_OPTIONS, col_back.begin()->first);
OptionPtr opt_back = col_back.begin()->second;
ASSERT_TRUE(opt_back);
uint8_t opt_number = 0;
uint32_t opt_type = RAI_OPTION_AGENT_CIRCUIT_ID;
OptionCollection subs_back = opt_back->getOptions();
- ASSERT_EQ(3, subs_back.size());
+ ASSERT_EQ(3U, subs_back.size());
for (auto const& sub_option : subs_back) {
if (sub_option.first != opt_type) {
opt_type = sub_option.first;
index++;
}
}
- ASSERT_EQ(index, 128);
+ ASSERT_EQ(index, 128U);
}
/// @brief Test which verifies that split options for v4 is working correctly.
ASSERT_NO_THROW(LibDHCP::packOptions4(buf, col, true));
ASSERT_NE(expected, pkt->toText());
- ASSERT_EQ(23, col.size());
+ ASSERT_EQ(23U, col.size());
ASSERT_EQ((11 + 1 + 11) * rai->getHeaderLen() + 11 * circuit_id_opt->getHeaderLen() +
remote_id_opt->getHeaderLen() + 11 * subscriber_id_opt->getHeaderLen() +
- 2560 + 64 + 2560, buf.getLength());
+ 2560 + 64 + 2560U, buf.getLength());
}
ASSERT_EQ(expected, pkt->toText());
ASSERT_NO_THROW(LibDHCP::unpackOptions4(opts_buffer, DHCP4_OPTION_SPACE,
col_back, deferred_options));
- ASSERT_EQ(1, col_back.size());
+ ASSERT_EQ(1U, col_back.size());
EXPECT_EQ(DHO_DHCP_AGENT_OPTIONS, col_back.begin()->first);
OptionPtr opt_back = col_back.begin()->second;
ASSERT_TRUE(opt_back);
uint8_t opt_number = 0;
uint32_t opt_type = RAI_OPTION_AGENT_CIRCUIT_ID;
OptionCollection subs_back = opt_back->getOptions();
- ASSERT_EQ(3, subs_back.size());
+ ASSERT_EQ(3U, subs_back.size());
for (auto const& sub_option : subs_back) {
if (sub_option.first != opt_type) {
opt_type = sub_option.first;
if (opt_number == 0) {
- ASSERT_EQ(index, 2560);
+ ASSERT_EQ(index, 2560U);
} else if (opt_number == 1) {
- ASSERT_EQ(index, 64);
+ ASSERT_EQ(index, 64U);
} else if (opt_number == 2){
- ASSERT_EQ(index, 2560);
+ ASSERT_EQ(index, 2560U);
}
index = 0;
opt_number++;
index++;
}
}
- ASSERT_EQ(index, 2560);
+ ASSERT_EQ(index, 2560U);
}
private:
// Validate if option length, type and universe is correct.
EXPECT_EQ(Option::V4, opt_time_offset->getUniverse());
EXPECT_EQ(DHO_TIME_OFFSET, opt_time_offset->getType());
- EXPECT_EQ(time_offset_buf.size(),
+ EXPECT_EQ(static_cast<long>(time_offset_buf.size()),
opt_time_offset->len() - opt_time_offset->getHeaderLen());
// Validate data in the option.
EXPECT_TRUE(std::equal(time_offset_buf.begin(), time_offset_buf.end(),
// Validate if option length, type and universe is correct.
EXPECT_EQ(Option::V6, opt_clientid->getUniverse());
EXPECT_EQ(D6O_CLIENTID, opt_clientid->getType());
- EXPECT_EQ(clientid_buf.size(), opt_clientid->len() - opt_clientid->getHeaderLen());
+ EXPECT_EQ(static_cast<int>(clientid_buf.size()),
+ opt_clientid->len() - opt_clientid->getHeaderLen());
// Validate data in the option.
EXPECT_TRUE(std::equal(clientid_buf.begin(), clientid_buf.end(),
opt_clientid->getData().begin()));
DHCP6_OPTION_SPACE, options);
});
- EXPECT_EQ(options.size(), 6); // there should be 5 options
+ EXPECT_EQ(options.size(), 6U); // there should be 5 options
isc::dhcp::OptionCollection::const_iterator x = options.find(1);
ASSERT_FALSE(x == options.end()); // option 1 should exist
- EXPECT_EQ(1, x->second->getType()); // this should be option 1
- ASSERT_EQ(9, x->second->len()); // it should be of length 9
- ASSERT_EQ(5, x->second->getData().size());
+ EXPECT_EQ(1U, x->second->getType()); // this should be option 1
+ ASSERT_EQ(9U, x->second->len()); // it should be of length 9
+ ASSERT_EQ(5U, x->second->getData().size());
EXPECT_EQ(0, memcmp(&x->second->getData()[0], v6packed + 4, 5)); // data len=5
x = options.find(2);
ASSERT_FALSE(x == options.end()); // option 2 should exist
- EXPECT_EQ(2, x->second->getType()); // this should be option 2
- ASSERT_EQ(7, x->second->len()); // it should be of length 7
- ASSERT_EQ(3, x->second->getData().size());
+ EXPECT_EQ(2U, x->second->getType()); // this should be option 2
+ ASSERT_EQ(7U, x->second->len()); // it should be of length 7
+ ASSERT_EQ(3U, x->second->getData().size());
EXPECT_EQ(0, memcmp(&x->second->getData()[0], v6packed + 13, 3)); // data len=3
x = options.find(14);
ASSERT_FALSE(x == options.end()); // option 14 should exist
- EXPECT_EQ(14, x->second->getType()); // this should be option 14
- ASSERT_EQ(4, x->second->len()); // it should be of length 4
- EXPECT_EQ(0, x->second->getData().size()); // data len = 0
+ EXPECT_EQ(14U, x->second->getType()); // this should be option 14
+ ASSERT_EQ(4U, x->second->len()); // it should be of length 4
+ EXPECT_EQ(0U, x->second->getData().size()); // data len = 0
x = options.find(6);
ASSERT_FALSE(x == options.end()); // option 6 should exist
- EXPECT_EQ(6, x->second->getType()); // this should be option 6
- ASSERT_EQ(8, x->second->len()); // it should be of length 8
+ EXPECT_EQ(6U, x->second->getType()); // this should be option 6
+ ASSERT_EQ(8U, x->second->len()); // it should be of length 8
// Option with code 6 is the OPTION_ORO. This option is
// represented by the OptionIntArray<uint16_t> class which
// comprises the set of uint16_t values. We need to cast the
x = options.find(8);
ASSERT_FALSE(x == options.end()); // option 8 should exist
- EXPECT_EQ(8, x->second->getType()); // this should be option 8
- ASSERT_EQ(6, x->second->len()); // it should be of length 9
+ EXPECT_EQ(8U, x->second->getType()); // this should be option 8
+ ASSERT_EQ(6U, x->second->len()); // it should be of length 9
// Option with code 8 is OPTION_ELAPSED_TIME. This option is
// represented by Option6Int<uint16_t> value that holds single
// uint16_t value.
// when returned option has different type than expected.
ASSERT_TRUE(opt_elapsed_time);
// Returned value should be equivalent to two byte values: 112, 113
- EXPECT_EQ(0x7071, opt_elapsed_time->getValue());
+ EXPECT_EQ(0x7071U, opt_elapsed_time->getValue());
// Check if Vendor Specific Information Option along with suboptions
// have been parsed correctly.
x = options.find(D6O_VENDOR_OPTS);
EXPECT_FALSE(x == options.end());
EXPECT_EQ(D6O_VENDOR_OPTS, x->second->getType());
- EXPECT_EQ(26, x->second->len());
+ EXPECT_EQ(26U, x->second->len());
OptionVendorPtr vendor = boost::dynamic_pointer_cast<OptionVendor>(x->second);
ASSERT_TRUE(vendor);
OptionPtr cm_mac = vendor->getOption(OPTION_CM_MAC);
ASSERT_TRUE(cm_mac);
EXPECT_EQ(OPTION_CM_MAC, cm_mac->getType());
- ASSERT_EQ(10, cm_mac->len());
+ ASSERT_EQ(10U, cm_mac->len());
EXPECT_EQ(0, memcmp(&cm_mac->getData()[0], v6packed + 54, 6));
// CMTS Capabilities
OptionPtr cmts_caps = vendor->getOption(OPTION_CMTS_CAPS);
ASSERT_TRUE(cmts_caps);
EXPECT_EQ(OPTION_CMTS_CAPS, cmts_caps->getType());
- ASSERT_EQ(8, cmts_caps->len());
+ ASSERT_EQ(8U, cmts_caps->len());
EXPECT_EQ(0, memcmp(&cmts_caps->getData()[0], v6packed + 46, 4));
x = options.find(0);
options));
// There should be one option.
- ASSERT_EQ(1, options.size());
+ ASSERT_EQ(1U, options.size());
OptionPtr option_empty = options.begin()->second;
ASSERT_TRUE(option_empty);
- EXPECT_EQ(1024, option_empty->getType());
- EXPECT_EQ(4, option_empty->len());
+ EXPECT_EQ(1024U, option_empty->getType());
+ EXPECT_EQ(4U, option_empty->len());
EXPECT_TRUE(option_empty->getEncapsulatedSpace().empty());
}
ASSERT_NO_THROW(LibDHCP::unpackOptions6(buf, "space-foobar", options, 0, 0));
// There should be one top level option.
- ASSERT_EQ(1, options.size());
+ ASSERT_EQ(1U, options.size());
boost::shared_ptr<OptionInt<uint32_t> > option_foobar =
boost::dynamic_pointer_cast<OptionInt<uint32_t> >(options.begin()->
second);
ASSERT_TRUE(option_foobar);
- EXPECT_EQ(1, option_foobar->getType());
- EXPECT_EQ(0x00010203, option_foobar->getValue());
+ EXPECT_EQ(1U, option_foobar->getType());
+ EXPECT_EQ(0x00010203U, option_foobar->getValue());
// There should be a middle level option held in option_foobar.
boost::shared_ptr<OptionInt<uint16_t> > option_foo =
boost::dynamic_pointer_cast<OptionInt<uint16_t> >(option_foobar->
getOption(1));
ASSERT_TRUE(option_foo);
- EXPECT_EQ(1, option_foo->getType());
- EXPECT_EQ(0x0102, option_foo->getValue());
+ EXPECT_EQ(1U, option_foo->getType());
+ EXPECT_EQ(0x0102U, option_foo->getValue());
// Finally, there should be a low level option under option_foo.
boost::shared_ptr<OptionInt<uint8_t> > option_bar =
boost::dynamic_pointer_cast<OptionInt<uint8_t> >(option_foo->getOption(1));
ASSERT_TRUE(option_bar);
- EXPECT_EQ(1, option_bar->getType());
- EXPECT_EQ(0x0, option_bar->getValue());
+ EXPECT_EQ(1U, option_bar->getType());
+ EXPECT_EQ(0U, option_bar->getValue());
}
/// V4 Options being used to test pack/unpack operations.
ASSERT_TRUE(option);
col.insert(std::make_pair(231, option));
}
- ASSERT_EQ(256, col.size());
+ ASSERT_EQ(256U, col.size());
isc::util::OutputBuffer buf(0);
ASSERT_NO_THROW(LibDHCP::packOptions4(buf, col, true));
ASSERT_NO_THROW(LibDHCP::unpackOptions4(opts_buffer, DHCP4_OPTION_SPACE,
col_back, deferred_options));
- ASSERT_EQ(1, col_back.size());
+ ASSERT_EQ(1U, col_back.size());
uint8_t index = 0;
for (auto const& option : col_back) {
- EXPECT_EQ(231, option.first);
+ EXPECT_EQ(231U, option.first);
for (auto const& value : option.second->getData()) {
EXPECT_EQ(index, value);
index++;
rai->addOption(circuit_id_opt);
}
col.insert(std::make_pair(213, rai));
- ASSERT_EQ(1, col.size());
- ASSERT_EQ(256, col.begin()->second->getOptions().size());
+ ASSERT_EQ(1U, col.size());
+ ASSERT_EQ(256U, col.begin()->second->getOptions().size());
isc::util::OutputBuffer buf(0);
ManagedScopedOptionsCopyContainer scoped_options;
ASSERT_NO_THROW(LibDHCP::splitOptions4(col, scoped_options.scoped_options_, 0));
ASSERT_NO_THROW(LibDHCP::unpackOptions4(opts_buffer, DHCP4_OPTION_SPACE,
col_back, deferred_options));
- ASSERT_EQ(1, col_back.size());
- ASSERT_EQ(1, col_back.begin()->second->getOptions().size());
+ ASSERT_EQ(1U, col_back.size());
+ ASSERT_EQ(1U, col_back.begin()->second->getOptions().size());
uint8_t index = 0;
auto const& options = col_back.begin()->second->getOptions();
for (auto const& option : options) {
std::list<uint16_t> deferred_options;
ASSERT_NO_THROW(LibDHCP::unpackOptions4(buf, DHCP4_OPTION_SPACE, options,
deferred_options));
- ASSERT_EQ(2, options.size());
+ ASSERT_EQ(2U, options.size());
bool seen_subnet(false);
bool seen_vci(false);
for (auto const& option : options) {
options.insert(make_pair(DHO_VIVCO_SUBOPTIONS, opt1));
options.insert(make_pair(DHO_VIVCO_SUBOPTIONS, opt2));
options.insert(make_pair(DHO_VIVCO_SUBOPTIONS, opt3));
- EXPECT_EQ(options.size(), 3);
+ EXPECT_EQ(options.size(), 3U);
// Fuse options.
isc::util::OutputBuffer buf(0);
ASSERT_NO_THROW(LibDHCP::unpackOptions4(opts_buffer, DHCP4_OPTION_SPACE,
options, deferred_options));
- EXPECT_EQ(options.size(), 1);
+ EXPECT_EQ(options.size(), 1U);
EXPECT_NO_THROW(LibDHCP::extendVendorOptions4(options));
- EXPECT_EQ(options.size(), 2);
- EXPECT_EQ(options.count(DHO_VIVCO_SUBOPTIONS), 2);
+ EXPECT_EQ(options.size(), 2U);
+ EXPECT_EQ(options.count(DHO_VIVCO_SUBOPTIONS), 2U);
for (auto const& option : options) {
ASSERT_EQ(option.second->getType(), DHO_VIVCO_SUBOPTIONS);
OptionVendorClassPtr vendor =
boost::dynamic_pointer_cast<OptionVendorClass>(option.second);
ASSERT_TRUE(vendor);
if (vendor->getVendorId() == 1) {
- ASSERT_EQ(vendor->getTuplesNum(), 3);
+ ASSERT_EQ(vendor->getTuplesNum(), 3U);
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
ASSERT_NO_THROW(tuple = vendor->getTuple(0));
- EXPECT_EQ(5, tuple.getLength());
+ EXPECT_EQ(5U, tuple.getLength());
EXPECT_EQ("first", tuple.getText());
ASSERT_NO_THROW(tuple = vendor->getTuple(1));
- EXPECT_EQ(6, tuple.getLength());
+ EXPECT_EQ(6U, tuple.getLength());
EXPECT_EQ("second", tuple.getText());
ASSERT_NO_THROW(tuple = vendor->getTuple(2));
- EXPECT_EQ(5, tuple.getLength());
+ EXPECT_EQ(5U, tuple.getLength());
EXPECT_EQ("third", tuple.getText());
} else if (vendor->getVendorId() == 2) {
- ASSERT_EQ(vendor->getTuplesNum(), 1);
+ ASSERT_EQ(vendor->getTuplesNum(), 1U);
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
ASSERT_NO_THROW(tuple = vendor->getTuple(0));
- EXPECT_EQ(5, tuple.getLength());
+ EXPECT_EQ(5U, tuple.getLength());
EXPECT_EQ("extra", tuple.getText());
} else {
FAIL() << "unexpected vendor type: " << vendor->getVendorId();
ASSERT_NO_THROW(LibDHCP::unpackOptions4(opts_buffer, DHCP4_OPTION_SPACE,
options, deferred_options));
- ASSERT_EQ(options.size(), 1);
- ASSERT_EQ(options.count(DHO_VIVSO_SUBOPTIONS), 1);
+ ASSERT_EQ(options.size(), 1U);
+ ASSERT_EQ(options.count(DHO_VIVSO_SUBOPTIONS), 1U);
ASSERT_EQ(options.find(DHO_VIVSO_SUBOPTIONS)->second->getType(), DHO_VIVSO_SUBOPTIONS);
container.clear();
container.insert(make_pair(DHO_VIVSO_SUBOPTIONS, options.begin()->second));
container.insert(make_pair(DHO_VIVSO_SUBOPTIONS, opt3));
container.insert(make_pair(DHO_VIVSO_SUBOPTIONS, opt4));
- ASSERT_EQ(container.size(), 3);
+ ASSERT_EQ(container.size(), 3U);
options.clear();
for (auto const& option : container) {
const OptionBuffer& buffer = option.second->toBinary();
option.second->getType(),
buffer))));
}
- ASSERT_EQ(options.size(), 3);
+ ASSERT_EQ(options.size(), 3U);
LibDHCP::extendVendorOptions4(options);
- ASSERT_EQ(options.size(), 2);
- ASSERT_EQ(options.count(DHO_VIVSO_SUBOPTIONS), 2);
+ ASSERT_EQ(options.size(), 2U);
+ ASSERT_EQ(options.count(DHO_VIVSO_SUBOPTIONS), 2U);
for (auto const& option : options) {
ASSERT_EQ(option.second->getType(), DHO_VIVSO_SUBOPTIONS);
OptionCollection suboptions = option.second->getOptions();
OptionVendorPtr vendor = boost::dynamic_pointer_cast<OptionVendor>(option.second);
ASSERT_TRUE(vendor);
if (vendor->getVendorId() == 1) {
- ASSERT_EQ(suboptions.size(), 3);
+ ASSERT_EQ(suboptions.size(), 3U);
subopt = option.second->getOption(16);
ASSERT_TRUE(subopt);
subopt = option.second->getOption(32);
subopt = option.second->getOption(64);
ASSERT_TRUE(subopt);
} else if (vendor->getVendorId() == 2) {
- ASSERT_EQ(suboptions.size(), 1);
+ ASSERT_EQ(suboptions.size(), 1U);
subopt = option.second->getOption(128);
ASSERT_TRUE(subopt);
} else {
// Option 12 holds a string so let's cast it to an appropriate type.
OptionStringPtr option12 = boost::static_pointer_cast<OptionString>(x->second);
ASSERT_TRUE(option12);
- EXPECT_EQ(12, option12->getType()); // this should be option 12
- ASSERT_EQ(3, option12->getValue().length()); // it should be of length 3
- EXPECT_EQ(5, option12->len()); // total option length 5
+ EXPECT_EQ(12U, option12->getType()); // this should be option 12
+ ASSERT_EQ(3U, option12->getValue().length()); // it should be of length 3
+ EXPECT_EQ(5U, option12->len()); // total option length 5
EXPECT_EQ(0, memcmp(&option12->getValue()[0], v4_opts + 2, 3)); // data len=3
x = options.find(60);
ASSERT_FALSE(x == options.end()); // option 2 should exist
- EXPECT_EQ(60, x->second->getType()); // this should be option 60
- ASSERT_EQ(3, x->second->getData().size()); // it should be of length 3
- EXPECT_EQ(5, x->second->len()); // total option length 5
+ EXPECT_EQ(60U, x->second->getType()); // this should be option 60
+ ASSERT_EQ(3U, x->second->getData().size()); // it should be of length 3
+ EXPECT_EQ(5U, x->second->len()); // total option length 5
EXPECT_EQ(0, memcmp(&x->second->getData()[0], v4_opts + 7, 3)); // data len=3
x = options.find(14);
ASSERT_FALSE(x == options.end()); // option 3 should exist
OptionStringPtr option14 = boost::static_pointer_cast<OptionString>(x->second);
ASSERT_TRUE(option14);
- EXPECT_EQ(14, option14->getType()); // this should be option 14
- ASSERT_EQ(3, option14->getValue().length()); // it should be of length 3
- EXPECT_EQ(5, option14->len()); // total option length 5
+ EXPECT_EQ(14U, option14->getType()); // this should be option 14
+ ASSERT_EQ(3U, option14->getValue().length()); // it should be of length 3
+ EXPECT_EQ(5U, option14->len()); // total option length 5
EXPECT_EQ(0, memcmp(&option14->getValue()[0], v4_opts + 12, 3)); // data len=3
x = options.find(254);
ASSERT_FALSE(x == options.end()); // option 4 should exist
- EXPECT_EQ(254, x->second->getType()); // this should be option 254
- ASSERT_EQ(3, x->second->getData().size()); // it should be of length 3
- EXPECT_EQ(5, x->second->len()); // total option length 5
+ EXPECT_EQ(254U, x->second->getType()); // this should be option 254
+ ASSERT_EQ(3U, x->second->getData().size()); // it should be of length 3
+ EXPECT_EQ(5U, x->second->len()); // total option length 5
EXPECT_EQ(0, memcmp(&x->second->getData()[0], v4_opts + 17, 3)); // data len=3
x = options.find(128);
ASSERT_FALSE(x == options.end()); // option 5 should exist
- EXPECT_EQ(128, x->second->getType()); // this should be option 128
- ASSERT_EQ(3, x->second->getData().size()); // it should be of length 3
- EXPECT_EQ(5, x->second->len()); // total option length 5
+ EXPECT_EQ(128U, x->second->getType()); // this should be option 128
+ ASSERT_EQ(3U, x->second->getData().size()); // it should be of length 3
+ EXPECT_EQ(5U, x->second->len()); // total option length 5
EXPECT_EQ(0, memcmp(&x->second->getData()[0], v4_opts + 22, 3)); // data len=3
// Verify that V-I Vendor Specific Information option is parsed correctly.
OptionCollection suboptions = vivsi->getOptions();
// There should be one suboption of V-I VSI.
- ASSERT_EQ(1, suboptions.size());
+ ASSERT_EQ(1U, suboptions.size());
// This vendor option has a standard definition and thus should be
// converted to appropriate class, i.e. Option4AddrLst. If this cast
// fails, it means that its definition was not used while it was
boost::dynamic_pointer_cast<Option4AddrLst>(suboptions.begin()->second);
ASSERT_TRUE(tftp);
EXPECT_EQ(DOCSIS3_V4_TFTP_SERVERS, tftp->getType());
- EXPECT_EQ(6, tftp->len());
+ EXPECT_EQ(6U, tftp->len());
Option4AddrLst::AddressContainer addresses = tftp->getAddresses();
- ASSERT_EQ(1, addresses.size());
+ ASSERT_EQ(1U, addresses.size());
EXPECT_EQ("10.0.0.10", addresses[0].toText());
// Checking DHCP Relay Agent Information Option.
OptionPtr rai_option = rai->getOption(RAI_OPTION_AGENT_CIRCUIT_ID);
ASSERT_TRUE(rai_option);
EXPECT_EQ(RAI_OPTION_AGENT_CIRCUIT_ID, rai_option->getType());
- ASSERT_EQ(6, rai_option->len());
+ ASSERT_EQ(6U, rai_option->len());
EXPECT_EQ(0, memcmp(&rai_option->getData()[0], v4_opts + 46, 4));
// Check that Remote ID option is among parsed options.
rai_option = rai->getOption(RAI_OPTION_REMOTE_ID);
ASSERT_TRUE(rai_option);
EXPECT_EQ(RAI_OPTION_REMOTE_ID, rai_option->getType());
- ASSERT_EQ(8, rai_option->len());
+ ASSERT_EQ(8U, rai_option->len());
EXPECT_EQ(0, memcmp(&rai_option->getData()[0], v4_opts + 52, 6));
// Check that Vendor Specific Information option is among parsed options.
rai_option = rai->getOption(RAI_OPTION_VSI);
ASSERT_TRUE(rai_option);
EXPECT_EQ(RAI_OPTION_VSI, rai_option->getType());
- ASSERT_EQ(11, rai_option->len());
+ ASSERT_EQ(11U, rai_option->len());
EXPECT_EQ(0, memcmp(&rai_option->getData()[0], v4_opts + 60, 9));
// Make sure, that option other than those above is not present.
options, deferred, false));
// There should be one option.
- ASSERT_EQ(1, options.size());
+ ASSERT_EQ(1U, options.size());
OptionPtr option_empty = options.begin()->second;
ASSERT_TRUE(option_empty);
- EXPECT_EQ(254, option_empty->getType());
- EXPECT_EQ(2, option_empty->len());
+ EXPECT_EQ(254U, option_empty->getType());
+ EXPECT_EQ(2U, option_empty->len());
EXPECT_TRUE(option_empty->getEncapsulatedSpace().empty());
}
options, deferred, false));
// There should be one top level option.
- ASSERT_EQ(1, options.size());
+ ASSERT_EQ(1U, options.size());
boost::shared_ptr<OptionInt<uint32_t> > option_foobar =
boost::dynamic_pointer_cast<OptionInt<uint32_t> >(options.begin()->
second);
ASSERT_TRUE(option_foobar);
- EXPECT_EQ(1, option_foobar->getType());
- EXPECT_EQ(0x00010203, option_foobar->getValue());
+ EXPECT_EQ(1U, option_foobar->getType());
+ EXPECT_EQ(0x00010203U, option_foobar->getValue());
// There should be a middle level option held in option_foobar.
boost::shared_ptr<OptionInt<uint16_t> > option_foo =
boost::dynamic_pointer_cast<OptionInt<uint16_t> >(option_foobar->
getOption(1));
ASSERT_TRUE(option_foo);
- EXPECT_EQ(1, option_foo->getType());
- EXPECT_EQ(0x0102, option_foo->getValue());
+ EXPECT_EQ(1U, option_foo->getType());
+ EXPECT_EQ(0x0102U, option_foo->getValue());
// Finally, there should be a low level option under option_foo.
boost::shared_ptr<OptionInt<uint8_t> > option_bar =
boost::dynamic_pointer_cast<OptionInt<uint8_t> >(option_foo->getOption(1));
ASSERT_TRUE(option_bar);
- EXPECT_EQ(1, option_bar->getType());
- EXPECT_EQ(0x0, option_bar->getValue());
+ EXPECT_EQ(1U, option_bar->getType());
+ EXPECT_EQ(0U, option_bar->getValue());
}
// Verifies that options 0 (PAD) and 255 (END) are handled as PAD and END
options, deferred, false));
// Returned offset should point to the END.
- EXPECT_EQ(0xff, buf[offset]);
+ EXPECT_EQ(0xffU, buf[offset]);
// There should be one top level option.
- ASSERT_EQ(1, options.size());
+ ASSERT_EQ(1U, options.size());
// Get it.
OptionPtr option = options.begin()->second;
ASSERT_TRUE(option);
- EXPECT_EQ(200, option->getType());
+ EXPECT_EQ(200U, option->getType());
// There should be 3 suboptions.
- ASSERT_EQ(3, option->getOptions().size());
+ ASSERT_EQ(3U, option->getOptions().size());
// Get suboption 0.
boost::shared_ptr<OptionInt<uint8_t> > sub0 =
boost::dynamic_pointer_cast<OptionInt<uint8_t> >
(option->getOption(0));
ASSERT_TRUE(sub0);
- EXPECT_EQ(0, sub0->getType());
- EXPECT_EQ(0, sub0->getValue());
+ EXPECT_EQ(0U, sub0->getType());
+ EXPECT_EQ(0U, sub0->getValue());
// Get suboption 255.
boost::shared_ptr<OptionInt<uint8_t> > sub255 =
boost::dynamic_pointer_cast<OptionInt<uint8_t> >
(option->getOption(255));
ASSERT_TRUE(sub255);
- EXPECT_EQ(255, sub255->getType());
- EXPECT_EQ(255, sub255->getValue());
+ EXPECT_EQ(255U, sub255->getType());
+ EXPECT_EQ(255U, sub255->getValue());
// Get suboption 1.
boost::shared_ptr<OptionString> sub =
boost::dynamic_pointer_cast<OptionString>(option->getOption(1));
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
EXPECT_EQ("foo", sub->getValue());
}
// There should be 2 suboptions (1 and 2) because no sub-option 0
// was defined so code 0 means PAD.
- ASSERT_EQ(2, options.size());
+ ASSERT_EQ(2U, options.size());
// Get suboption 1.
OptionPtr sub1 = options.begin()->second;
ASSERT_TRUE(sub1);
- EXPECT_EQ(1, sub1->getType());
+ EXPECT_EQ(1U, sub1->getType());
EXPECT_EQ(0, sub1->len() - sub1->getHeaderLen());
// Get suboption 2.
boost::dynamic_pointer_cast<OptionInt<uint8_t> >
(options.rbegin()->second);
ASSERT_TRUE(sub2);
- EXPECT_EQ(2, sub2->getType());
- EXPECT_EQ(1, sub2->getValue());
+ EXPECT_EQ(2U, sub2->getType());
+ EXPECT_EQ(1U, sub2->getValue());
// Create option definition for option 0 and register it.
OptionDefinitionPtr opt_def0(new OptionDefinition("zero", 0, space, "uint8"));
ASSERT_NO_THROW(LibDHCP::unpackOptions4(buf, space, options, deferred, true));
// There should be 2 suboptions (0 and 1).
- EXPECT_EQ(2, options.size());
+ EXPECT_EQ(2U, options.size());
// Get suboption 0
boost::shared_ptr<OptionInt<uint8_t> > sub0 =
boost::dynamic_pointer_cast<OptionInt<uint8_t> >
(options.begin()->second);
ASSERT_TRUE(sub0);
- EXPECT_EQ(0, sub0->getType());
- EXPECT_EQ(0, sub0->getValue());
+ EXPECT_EQ(0U, sub0->getType());
+ EXPECT_EQ(0U, sub0->getValue());
// Get suboption 2.
sub2 =
boost::dynamic_pointer_cast<OptionInt<uint8_t> >
(options.rbegin()->second);
ASSERT_TRUE(sub2);
- EXPECT_EQ(2, sub2->getType());
- EXPECT_EQ(1, sub2->getValue());
+ EXPECT_EQ(2U, sub2->getType());
+ EXPECT_EQ(1U, sub2->getValue());
}
// Verifies that option 255 (END) is handled as END in option 43 (so when
options, deferred, true));
// Parsing should stop at the first byte.
- EXPECT_EQ(0, offset);
+ EXPECT_EQ(0U, offset);
// There should be 0 suboptions.
- EXPECT_EQ(0, options.size());
+ EXPECT_EQ(0U, options.size());
// Create option definition for option 255.
OptionDefinitionPtr opt_def255(new OptionDefinition("max", 255, space, "uint8"));
options, deferred, true));
// There should be 1 suboption.
- ASSERT_EQ(1, options.size());
+ ASSERT_EQ(1U, options.size());
// Get suboption 255.
boost::shared_ptr<OptionInt<uint8_t> > sub255 =
boost::dynamic_pointer_cast<OptionInt<uint8_t> >
(options.begin()->second);
ASSERT_TRUE(sub255);
- EXPECT_EQ(255, sub255->getType());
- EXPECT_EQ(2, sub255->getValue());
+ EXPECT_EQ(255U, sub255->getType());
+ EXPECT_EQ(2U, sub255->getValue());
}
// Verify the option 43 END bug is fixed (#950: option code 255 was not
EXPECT_EQ(def->getEncapsulatedSpace(), option->getEncapsulatedSpace());
// There should be 1 suboption.
- EXPECT_EQ(1, option->getOptions().size());
+ EXPECT_EQ(1U, option->getOptions().size());
// Get suboption 1.
OptionPtr sub1 = option->getOption(1);
ASSERT_TRUE(sub1);
- EXPECT_EQ(1, sub1->getType());
+ EXPECT_EQ(1U, sub1->getType());
EXPECT_EQ(0, sub1->len() - sub1->getHeaderLen());
// Of course no suboption 255.
// Verify Option 60 exists correctly
x = options.find(60);
ASSERT_FALSE(x == options.end());
- EXPECT_EQ(60, x->second->getType());
- ASSERT_EQ(3, x->second->getData().size());
- EXPECT_EQ(5, x->second->len());
+ EXPECT_EQ(60U, x->second->getType());
+ ASSERT_EQ(3U, x->second->getData().size());
+ EXPECT_EQ(5U, x->second->len());
EXPECT_EQ(0, memcmp(&x->second->getData()[0], opts + 4, 3));
};
ASSERT_TRUE(option);
OptionCustomPtr names = boost::dynamic_pointer_cast<OptionCustom>(option);
ASSERT_TRUE(names);
- EXPECT_EQ(sizeof(fqdn), names->len() - names->getHeaderLen());
- ASSERT_EQ(3, names->getDataFieldsNum());
+ EXPECT_EQ(static_cast<long>(sizeof(fqdn)),
+ names->len() - names->getHeaderLen());
+ ASSERT_EQ(3U, names->getDataFieldsNum());
EXPECT_EQ("mydomain.example.com.", names->readFqdn(0));
EXPECT_EQ("example.com.", names->readFqdn(1));
EXPECT_EQ("com.", names->readFqdn(2));
ASSERT_TRUE(names);
/* Use the uncompress length here (cf fqdnList) */
EXPECT_EQ(40, names->len() - names->getHeaderLen());
- ASSERT_EQ(3, names->getDataFieldsNum());
+ ASSERT_EQ(3U, names->getDataFieldsNum());
EXPECT_EQ("mydomain.example.com.", names->readFqdn(0));
EXPECT_EQ("example.com.", names->readFqdn(1));
EXPECT_EQ("com.", names->readFqdn(2));
LibDHCP::unpackOptions6(bin, DHCP6_OPTION_SPACE, options);
});
- EXPECT_EQ(options.size(), 1); // There should be 1 option.
+ EXPECT_EQ(options.size(), 1U); // There should be 1 option.
// Option vendor-class should be there
ASSERT_FALSE(options.find(D6O_VENDOR_CLASS) == options.end());
// 3 fields expected: vendor-id, data-len and data
EXPECT_EQ(VENDOR_ID_CABLE_LABS, vclass->getVendorId());
- EXPECT_EQ(20, vclass->len());
- ASSERT_EQ(1, vclass->getTuplesNum());
+ EXPECT_EQ(20U, vclass->len());
+ ASSERT_EQ(1U, vclass->getTuplesNum());
EXPECT_EQ("eRouter1.0", vclass->getTuple(0).getText());
}
def = LibDHCP::getLastResortOptionDef(DHCP4_OPTION_SPACE, 43);
ASSERT_TRUE(def);
EXPECT_FALSE(def->getArrayType());
- EXPECT_EQ(43, def->getCode());
+ EXPECT_EQ(43U, def->getCode());
EXPECT_EQ(VENDOR_ENCAPSULATED_OPTION_SPACE, def->getEncapsulatedSpace());
EXPECT_EQ("vendor-encapsulated-options", def->getName());
- EXPECT_EQ(0, def->getRecordFields().size());
+ EXPECT_EQ(0U, def->getRecordFields().size());
EXPECT_EQ(OptionDataType::OPT_EMPTY_TYPE, def->getType());
OptionDefinitionPtr def_by_name =
// We expect to have exactly one option (with tons of suboptions, but we'll
// get to that in a minute)
- EXPECT_EQ(1, options.size());
+ EXPECT_EQ(1U, options.size());
auto opt = options.find(D6O_S46_CONT_MAPE);
ASSERT_FALSE(opt == options.end());
shared_ptr<OptionCustom> mape = dynamic_pointer_cast<OptionCustom>(opt->second);
ASSERT_TRUE(mape);
EXPECT_EQ(D6O_S46_CONT_MAPE, mape->getType());
- EXPECT_EQ(68, mape->len());
- EXPECT_EQ(64, mape->getData().size());
+ EXPECT_EQ(68U, mape->len());
+ EXPECT_EQ(64U, mape->getData().size());
// Let's check if there's a border router option.
ASSERT_TRUE(mape->getOption(D6O_S46_BR));
// Now let's check the suboptions. There should be 3 (BR, 2x rule)
const OptionCollection& subopts = mape->getOptions();
- ASSERT_EQ(3, subopts.size());
- EXPECT_EQ(1, subopts.count(D6O_S46_BR));
- EXPECT_EQ(2, subopts.count(D6O_S46_RULE));
+ ASSERT_EQ(3U, subopts.size());
+ EXPECT_EQ(1U, subopts.count(D6O_S46_BR));
+ EXPECT_EQ(2U, subopts.count(D6O_S46_RULE));
// Let's check the rules. There should be two of them.
auto range = subopts.equal_range(D6O_S46_RULE);
ASSERT_THROW(LibDHCP::unpackOptions4(buf, DHCP4_OPTION_SPACE, options,
deferred_options), OptionParseError);
// There should be no parsed options.
- EXPECT_EQ(0, options.size());
+ EXPECT_EQ(0U, options.size());
// Now parse with lenient parsing enabled.
Option::lenient_parsing_ = true;
// We should have skipped DHO_V4_LOST and DHO_DOMAIN_SEARCH
// and parsed DHO_TIME_OFFSET.
- EXPECT_EQ(1, options.size());
+ EXPECT_EQ(1U, options.size());
auto opt = options.find(DHO_TIME_OFFSET);
ASSERT_FALSE(opt == options.end());
// Parse with lenient parsing disabled.
ASSERT_FALSE(Option::lenient_parsing_);
EXPECT_THROW(LibDHCP::unpackOptions6(buf, DHCP6_OPTION_SPACE, options), OptionParseError);
- EXPECT_EQ(0, options.size());
+ EXPECT_EQ(0U, options.size());
// There should be no parsed options.
Option::lenient_parsing_ = true;
ASSERT_NO_THROW(LibDHCP::unpackOptions6(buf, DHCP6_OPTION_SPACE, options));
// Now parse with lenient parsing enabled.
- EXPECT_EQ(1, options.size());
+ EXPECT_EQ(1U, options.size());
auto opt = options.find(D6O_ELAPSED_TIME);
ASSERT_FALSE(opt == options.end());
// and parsed D6O_ELAPSED_TIME.
auto elapsed = boost::dynamic_pointer_cast<OptionInt<uint16_t>>(opt->second);
ASSERT_TRUE(elapsed);
- EXPECT_EQ(77, elapsed->getValue());
+ EXPECT_EQ(77U, elapsed->getValue());
}
// RFC 5908 v6 NTP server option and suboptions.
EXPECT_EQ(bin.size(), parsed);
// We expect to have exactly one option with 3 suboptions.
- EXPECT_EQ(1, options.size());
+ EXPECT_EQ(1U, options.size());
auto opt = options.find(D6O_NTP_SERVER);
ASSERT_FALSE(opt == options.end());
boost::dynamic_pointer_cast<OptionCustom>(opt->second);
ASSERT_TRUE(option);
EXPECT_EQ(D6O_NTP_SERVER, option->getType());
- EXPECT_EQ(57, option->len());
- EXPECT_EQ(53, option->getData().size());
+ EXPECT_EQ(57U, option->len());
+ EXPECT_EQ(53U, option->getData().size());
// Check the address suboption.
ASSERT_TRUE(option->getOption(NTP_SUBOPTION_SRV_ADDR));
col.insert(make_pair(D6O_BOOTFILE_URL, opts));
// Split them: expect 5 options (opt1 -> 3, opt2 -> 0, opt3 -> 1 and opts).
- ASSERT_EQ(4, col.size());
+ ASSERT_EQ(4U, col.size());
ASSERT_NO_THROW(LibDHCP::splitNtpServerOptions6(col));
- EXPECT_EQ(5, col.size());
+ EXPECT_EQ(5U, col.size());
// Expected output.
string expected = "type=00056, len=00020:,\noptions:\n";
TEST(OpaqueDataTuple, constructor) {
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
// There should be no data in the tuple.
- EXPECT_EQ(0, tuple.getLength());
+ EXPECT_EQ(0U, tuple.getLength());
EXPECT_TRUE(tuple.getData().empty());
EXPECT_TRUE(tuple.getText().empty());
}
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE, wire_data.begin(),
wire_data.end());
- EXPECT_EQ(11, tuple.getLength());
+ EXPECT_EQ(11U, tuple.getLength());
EXPECT_EQ("Hello world", tuple.getText());
}
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES, wire_data.begin(),
wire_data.end());
- EXPECT_EQ(11, tuple.getLength());
+ EXPECT_EQ(11U, tuple.getLength());
EXPECT_EQ("Hello world", tuple.getText());
}
TEST(OpaqueDataTuple, assignString) {
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
// Initially, the tuple should be empty.
- ASSERT_EQ(0, tuple.getLength());
+ ASSERT_EQ(0U, tuple.getLength());
// Assign some string data.
tuple.assign("Some string");
// Verify that the data has been assigned.
- EXPECT_EQ(11, tuple.getLength());
+ EXPECT_EQ(11U, tuple.getLength());
EXPECT_EQ("Some string", tuple.getText());
// Assign some other string.
tuple.assign("Different string");
// The new string should have replaced the old string.
- EXPECT_EQ(16, tuple.getLength());
+ EXPECT_EQ(16U, tuple.getLength());
EXPECT_EQ("Different string", tuple.getText());
}
TEST(OpaqueDataTuple, appendString) {
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
// Initially the tuple should be empty.
- ASSERT_EQ(0, tuple.getLength());
+ ASSERT_EQ(0U, tuple.getLength());
// Append the string to it.
tuple.append("First part");
- ASSERT_EQ(10, tuple.getLength());
+ ASSERT_EQ(10U, tuple.getLength());
ASSERT_EQ("First part", tuple.getText());
// Now append the other string.
tuple.append(" and second part");
- EXPECT_EQ(26, tuple.getLength());
+ EXPECT_EQ(26U, tuple.getLength());
// The resulting data in the tuple should be a concatenation of both
// strings.
EXPECT_EQ("First part and second part", tuple.getText());
TEST(OpaqueDataTuple, operators) {
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
// Tuple should be empty initially.
- ASSERT_EQ(0, tuple.getLength());
+ ASSERT_EQ(0U, tuple.getLength());
// Check assignment.
EXPECT_NO_THROW(tuple = "Hello World");
- EXPECT_EQ(11, tuple.getLength());
+ EXPECT_EQ(11U, tuple.getLength());
EXPECT_TRUE(tuple == "Hello World");
EXPECT_TRUE(tuple != "Something else");
// Assign something else to make sure it affects the tuple.
EXPECT_NO_THROW(tuple = "Something else");
- EXPECT_EQ(14, tuple.getLength());
+ EXPECT_EQ(14U, tuple.getLength());
EXPECT_TRUE(tuple == "Something else");
EXPECT_TRUE(tuple != "Hello World");
}
TEST(OpaqueDataTuple, operatorOutputStream) {
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
// The tuple should be empty initially.
- ASSERT_EQ(0, tuple.getLength());
+ ASSERT_EQ(0U, tuple.getLength());
// The tuple is empty, so assigning its content to the output stream should
// be no-op and result in the same text in the stream.
std::ostringstream s;
TEST(OpaqueDataTuple, operatorInputStream) {
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
// The tuple should be empty initially.
- ASSERT_EQ(0, tuple.getLength());
+ ASSERT_EQ(0U, tuple.getLength());
// The input stream has some text. This text should be appended to the
// tuple.
std::istringstream s;
TEST(OpaqueDataTuple, pack1Byte) {
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
// Initially, the tuple should be empty.
- ASSERT_EQ(0, tuple.getLength());
+ ASSERT_EQ(0U, tuple.getLength());
// It turns out that Option 124 can be sent with 0 length Opaque Data
// See #2021 for more details
OutputBuffer out_buf(10);
ASSERT_NO_THROW(tuple.pack(out_buf));
- ASSERT_EQ(1, out_buf.getLength());
+ ASSERT_EQ(1U, out_buf.getLength());
const uint8_t* zero_len = out_buf.getData();
ASSERT_EQ(0, *zero_len);
// Reset the output buffer for another test.
ASSERT_NO_THROW(tuple.pack(out_buf));
// The rendered buffer should be 101 bytes long - 1 byte for length,
// 100 bytes for the actual data.
- ASSERT_EQ(101, out_buf.getLength());
+ ASSERT_EQ(101U, out_buf.getLength());
// Get the rendered data into the vector for convenience.
std::vector<uint8_t>
render_data(out_buf.getData(), out_buf.getData() + 101);
// The first byte is a length byte. It should hold the length of 100.
- EXPECT_EQ(100, render_data[0]);
+ EXPECT_EQ(100U, render_data[0]);
// Verify that the rendered data is correct.
EXPECT_TRUE(std::equal(render_data.begin() + 1, render_data.end(),
data.begin()));
for (uint8_t i = 100; i < 255; ++i) {
data.push_back(i);
}
- ASSERT_EQ(255, data.size());
+ ASSERT_EQ(255U, data.size());
tuple.assign(data.begin(), data.size());
// The pack() should be successful again.
ASSERT_NO_THROW(tuple.pack(out_buf));
// The rendered buffer should be 256 bytes long. The first byte holds the
// opaque data length, the remaining bytes hold the actual data.
- ASSERT_EQ(256, out_buf.getLength());
+ ASSERT_EQ(256U, out_buf.getLength());
// Check that the data is correct.
render_data.assign(out_buf.getData(), out_buf.getData() + 256);
- EXPECT_EQ(255, render_data[0]);
+ EXPECT_EQ(255U, render_data[0]);
EXPECT_TRUE(std::equal(render_data.begin() + 1, render_data.end(),
data.begin()));
// Clear output buffer for another test.
TEST(OpaqueDataTuple, pack2Bytes) {
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
// Initially, the tuple should be empty.
- ASSERT_EQ(0, tuple.getLength());
+ ASSERT_EQ(0U, tuple.getLength());
// It turns out that Option 124 can be sent with 0 length Opaque Data
// See #2021 for more details
OutputBuffer out_buf(10);
ASSERT_NO_THROW(tuple.pack(out_buf));
- ASSERT_EQ(2, out_buf.getLength());
+ ASSERT_EQ(2U, out_buf.getLength());
const uint8_t* out_data = out_buf.getData();
ASSERT_LE(sizeof(uint16_t), out_buf.getLength());
- ASSERT_EQ(0, out_data[0]);
- ASSERT_EQ(0, out_data[1]);
+ ASSERT_EQ(0U, out_data[0]);
+ ASSERT_EQ(0U, out_data[1]);
// Reset the output buffer for another test.
out_buf.clear();
// Set the data for tuple.
ASSERT_NO_THROW(tuple.pack(out_buf));
// The rendered buffer should be 514 bytes long - 2 bytes for length,
// 512 bytes for the actual data.
- ASSERT_EQ(514, out_buf.getLength());
+ ASSERT_EQ(514U, out_buf.getLength());
// Get the rendered data into the vector for convenience.
std::vector<uint8_t>
render_data(out_buf.getData(), out_buf.getData() + 514);
// The first two bytes hold the length of 512.
uint16_t len = (render_data[0] << 8) + render_data[1];
- EXPECT_EQ(512, len);
+ EXPECT_EQ(512U, len);
// Verify that the rendered data is correct.
EXPECT_TRUE(std::equal(render_data.begin() + 2, render_data.end(),
data.begin()));
// Without clearing the output buffer, try to do it again. The pack should
// append the data to the current buffer.
ASSERT_NO_THROW(tuple.pack(out_buf));
- EXPECT_EQ(1028, out_buf.getLength());
+ EXPECT_EQ(1028U, out_buf.getLength());
// Check that we can render the buffer of the maximal allowed size.
data.assign(65535, 1);
};
ASSERT_NO_THROW(tuple.unpack(wire_data.begin(), wire_data.end()));
- EXPECT_EQ(11, tuple.getLength());
+ EXPECT_EQ(11U, tuple.getLength());
EXPECT_EQ("Hello world", tuple.getText());
}
TEST(OpaqueDataTuple, unpack1ByteZeroLength) {
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
EXPECT_NO_THROW(tuple = "Hello world");
- ASSERT_NE(tuple.getLength(), 0);
+ ASSERT_NE(tuple.getLength(), 0U);
OpaqueDataTuple::Buffer wire_data = {
0
};
ASSERT_NO_THROW(tuple.unpack(wire_data.begin(), wire_data.end()));
- EXPECT_EQ(0, tuple.getLength());
+ EXPECT_EQ(0U, tuple.getLength());
}
// This test verifies that the tuple having a length of 0, followed by no
// The unpack should succeed.
ASSERT_NO_THROW(tuple.unpack(wire_data.begin(), wire_data.end()));
// The decoded length should be 400.
- ASSERT_EQ(400, tuple.getLength());
+ ASSERT_EQ(400U, tuple.getLength());
// And the data should match.
EXPECT_TRUE(std::equal(wire_data.begin() + 2, wire_data.end(),
tuple.getData().begin()));
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
// Set some data for the tuple.
EXPECT_NO_THROW(tuple = "Hello world");
- ASSERT_NE(tuple.getLength(), 0);
+ ASSERT_NE(tuple.getLength(), 0U);
// The buffer holds just a length field with the value of 0.
OpaqueDataTuple::Buffer wire_data = {
0, 0
// The empty tuple should be successfully decoded.
ASSERT_NO_THROW(tuple.unpack(wire_data.begin(), wire_data.end()));
// The data should be replaced with an empty buffer.
- EXPECT_EQ(0, tuple.getLength());
+ EXPECT_EQ(0U, tuple.getLength());
}
// This test verifies that exception is thrown if the empty buffer is being
EXPECT_EQ(Option::V4, opt1->getUniverse());
EXPECT_EQ(DHO_DOMAIN_NAME_SERVERS, opt1->getType());
- EXPECT_EQ(6, opt1->len()); // 2 (header) + 4 (1x IPv4 addr)
+ EXPECT_EQ(6U, opt1->len()); // 2 (header) + 4 (1x IPv4 addr)
Option4AddrLst::AddressContainer addrs = opt1->getAddresses();
- ASSERT_EQ(1, addrs.size());
+ ASSERT_EQ(1U, addrs.size());
EXPECT_EQ("192.0.2.3", addrs[0].toText());
EXPECT_EQ(Option::V4, opt4->getUniverse());
- EXPECT_EQ(254, opt4->getType());
- EXPECT_EQ(18, opt4->len()); // 2 (header) + 16 (4x IPv4 addrs)
+ EXPECT_EQ(254U, opt4->getType());
+ EXPECT_EQ(18U, opt4->len()); // 2 (header) + 16 (4x IPv4 addrs)
Option4AddrLst::AddressContainer addrs = opt4->getAddresses();
- ASSERT_EQ(4, addrs.size());
+ ASSERT_EQ(4U, addrs.size());
EXPECT_EQ("192.0.2.3", addrs[0].toText());
EXPECT_EQ("255.255.255.0", addrs[1].toText());
EXPECT_EQ(DHO_DOMAIN_NAME_SERVERS, opt->getType());
Option4AddrLst::AddressContainer addrs = opt->getAddresses();
- ASSERT_EQ(1, addrs.size() );
+ ASSERT_EQ(1U, addrs.size() );
EXPECT_EQ("192.0.2.3", addrs[0].toText());
OutputBuffer buf(100);
opt->pack(buf);
);
- ASSERT_EQ(6, opt->len());
- ASSERT_EQ(6, buf.getLength());
+ ASSERT_EQ(6U, opt->len());
+ ASSERT_EQ(6U, buf.getLength());
EXPECT_EQ(0, memcmp(expected1, buf.getData(), 6));
opt.reset(new Option4AddrLst(254, sampleAddrs_));
);
EXPECT_EQ(Option::V4, opt->getUniverse());
- EXPECT_EQ(254, opt->getType());
+ EXPECT_EQ(254U, opt->getType());
Option4AddrLst::AddressContainer addrs = opt->getAddresses();
- ASSERT_EQ(4, addrs.size() );
+ ASSERT_EQ(4U, addrs.size() );
EXPECT_EQ("192.0.2.3", addrs[0].toText());
EXPECT_EQ("255.255.255.0", addrs[1].toText());
EXPECT_EQ("0.0.0.0", addrs[2].toText());
opt->pack(buf);
);
- ASSERT_EQ(18, opt->len()); // 2(header) + 4xsizeof(IPv4addr)
- ASSERT_EQ(18, buf.getLength());
+ ASSERT_EQ(18U, opt->len()); // 2(header) + 4xsizeof(IPv4addr)
+ ASSERT_EQ(18U, buf.getLength());
ASSERT_EQ(0, memcmp(expected4, buf.getData(), 18));
// the mobile-ip-home-agent option can be empty
EXPECT_NO_THROW(opt.reset(new Option4AddrLst(DHO_HOME_AGENT_ADDRS)));
Option4AddrLst::AddressContainer addrs = opt->getAddresses();
- ASSERT_EQ(0, addrs.size());
+ ASSERT_EQ(0U, addrs.size());
EXPECT_NO_THROW(opt.reset());
}
opt->setAddress(IOAddress("192.0.255.255"));
Option4AddrLst::AddressContainer addrs = opt->getAddresses();
- ASSERT_EQ(1, addrs.size() );
+ ASSERT_EQ(1U, addrs.size() );
EXPECT_EQ("192.0.255.255", addrs[0].toText());
// We should accept IPv4-only addresses.
opt->setAddresses(sampleAddrs_);
Option4AddrLst::AddressContainer addrs = opt->getAddresses();
- ASSERT_EQ(4, addrs.size() );
+ ASSERT_EQ(4U, addrs.size() );
EXPECT_EQ("192.0.2.3", addrs[0].toText());
EXPECT_EQ("255.255.255.0", addrs[1].toText());
EXPECT_EQ("0.0.0.0", addrs[2].toText());
ASSERT_TRUE(option);
// Check if member variables were correctly set inside DNR instances.
- EXPECT_EQ(1, option->getDnrInstances().size());
- EXPECT_EQ(1, option->getDnrInstances()[0].getServicePriority());
- EXPECT_EQ(21, option->getDnrInstances()[0].getAdnLength());
+ EXPECT_EQ(1U, option->getDnrInstances().size());
+ EXPECT_EQ(1U, option->getDnrInstances()[0].getServicePriority());
+ EXPECT_EQ(21U, option->getDnrInstances()[0].getAdnLength());
EXPECT_EQ("myhost1.example.com.", option->getDnrInstances()[0].getAdnAsText());
// This is ADN only mode, so Addr Length and SvcParams Length
// are both expected to be zero.
- EXPECT_EQ(0, option->getDnrInstances()[0].getAddrLength());
- EXPECT_EQ(0, option->getDnrInstances()[0].getSvcParamsLength());
+ EXPECT_EQ(0U, option->getDnrInstances()[0].getAddrLength());
+ EXPECT_EQ(0U, option->getDnrInstances()[0].getSvcParamsLength());
// BTW let's check if len() works ok. In ADN only mode, DNR Instance Data Len
// is set to ADN Len (21) + 3 = 24.
// expected len: 1x(24 (ADN+ADN Len+Service priority) + 2 (DNR Instance Data Len)) + 2 (headers)
// = 28
- EXPECT_EQ(28, option->len());
+ EXPECT_EQ(28U, option->len());
// BTW let's check if toText() works ok.
// toText() len does not count in headers len.
EXPECT_EQ(DHO_V4_DNR, option->getType());
// Check if member variables were correctly set inside DNR instances.
- EXPECT_EQ(3, option->getDnrInstances().size());
- EXPECT_EQ(1, option->getDnrInstances()[0].getServicePriority());
- EXPECT_EQ(2, option->getDnrInstances()[1].getServicePriority());
- EXPECT_EQ(3, option->getDnrInstances()[2].getServicePriority());
- EXPECT_EQ(21, option->getDnrInstances()[0].getAdnLength());
- EXPECT_EQ(21, option->getDnrInstances()[1].getAdnLength());
- EXPECT_EQ(21, option->getDnrInstances()[2].getAdnLength());
+ EXPECT_EQ(3U, option->getDnrInstances().size());
+ EXPECT_EQ(1U, option->getDnrInstances()[0].getServicePriority());
+ EXPECT_EQ(2U, option->getDnrInstances()[1].getServicePriority());
+ EXPECT_EQ(3U, option->getDnrInstances()[2].getServicePriority());
+ EXPECT_EQ(21U, option->getDnrInstances()[0].getAdnLength());
+ EXPECT_EQ(21U, option->getDnrInstances()[1].getAdnLength());
+ EXPECT_EQ(21U, option->getDnrInstances()[2].getAdnLength());
EXPECT_EQ("myhost1.example.com.", option->getDnrInstances()[0].getAdnAsText());
EXPECT_EQ("myhost2.example.com.", option->getDnrInstances()[1].getAdnAsText());
EXPECT_EQ("myhost3.example.com.", option->getDnrInstances()[2].getAdnAsText());
// This is ADN only mode, so Addr Length and SvcParams Length
// are both expected to be zero.
- EXPECT_EQ(0, option->getDnrInstances()[0].getAddrLength());
- EXPECT_EQ(0, option->getDnrInstances()[0].getSvcParamsLength());
- EXPECT_EQ(0, option->getDnrInstances()[1].getAddrLength());
- EXPECT_EQ(0, option->getDnrInstances()[1].getSvcParamsLength());
- EXPECT_EQ(0, option->getDnrInstances()[2].getAddrLength());
- EXPECT_EQ(0, option->getDnrInstances()[2].getSvcParamsLength());
+ EXPECT_EQ(0U, option->getDnrInstances()[0].getAddrLength());
+ EXPECT_EQ(0U, option->getDnrInstances()[0].getSvcParamsLength());
+ EXPECT_EQ(0U, option->getDnrInstances()[1].getAddrLength());
+ EXPECT_EQ(0U, option->getDnrInstances()[1].getSvcParamsLength());
+ EXPECT_EQ(0U, option->getDnrInstances()[2].getAddrLength());
+ EXPECT_EQ(0U, option->getDnrInstances()[2].getSvcParamsLength());
// BTW let's check if len() works ok. In ADN only mode, DNR Instance Data Len
// is set to ADN Len (21) + 3 = 24.
// expected len: 3x(24 (ADN+ADN Len+Service priority) + 2 (DNR Instance Data Len)) + 2 (headers)
// = 78 + 2 = 80
- EXPECT_EQ(80, option->len());
+ EXPECT_EQ(80U, option->len());
// BTW let's check if toText() works ok.
// toText() len does not count in headers len.
ASSERT_TRUE(option);
// Check if member variables were correctly set inside DNR instances.
- EXPECT_EQ(2, option->getDnrInstances().size());
- EXPECT_EQ(1, option->getDnrInstances()[0].getServicePriority());
- EXPECT_EQ(21, option->getDnrInstances()[0].getAdnLength());
+ EXPECT_EQ(2U, option->getDnrInstances().size());
+ EXPECT_EQ(1U, option->getDnrInstances()[0].getServicePriority());
+ EXPECT_EQ(21U, option->getDnrInstances()[0].getAdnLength());
EXPECT_EQ("myhost1.example.com.", option->getDnrInstances()[0].getAdnAsText());
- EXPECT_EQ(2, option->getDnrInstances()[1].getServicePriority());
- EXPECT_EQ(21, option->getDnrInstances()[1].getAdnLength());
+ EXPECT_EQ(2U, option->getDnrInstances()[1].getServicePriority());
+ EXPECT_EQ(21U, option->getDnrInstances()[1].getAdnLength());
EXPECT_EQ("myhost2.example.com.", option->getDnrInstances()[1].getAdnAsText());
- EXPECT_EQ(0, option->getDnrInstances()[0].getAddrLength());
- EXPECT_EQ(0, option->getDnrInstances()[0].getSvcParamsLength());
- EXPECT_EQ(2, option->getDnrInstances()[1].getAddresses().size());
- EXPECT_EQ(8, option->getDnrInstances()[1].getAddrLength());
+ EXPECT_EQ(0U, option->getDnrInstances()[0].getAddrLength());
+ EXPECT_EQ(0U, option->getDnrInstances()[0].getSvcParamsLength());
+ EXPECT_EQ(2U, option->getDnrInstances()[1].getAddresses().size());
+ EXPECT_EQ(8U, option->getDnrInstances()[1].getAddrLength());
EXPECT_EQ("192.168.0.1", option->getDnrInstances()[1].getAddresses()[0].toText());
EXPECT_EQ("192.168.0.2", option->getDnrInstances()[1].getAddresses()[1].toText());
// + 24 (ADN+ADN Len+Service priority) + 2 (DNR Instance Data Len) + 1 (Addr Len)
// + 8 (IP addresses) + 25 (svc params)
// = 88
- EXPECT_EQ(88, option->len());
+ EXPECT_EQ(88U, option->len());
// BTW let's check if toText() works ok.
// toText() len does not count in headers len.
EXPECT_EQ(DHO_V4_DNR, option->getType());
// Check if data was unpacked correctly from wire data.
- EXPECT_EQ(24, option->getDnrInstances()[0].getDnrInstanceDataLength());
- EXPECT_EQ(1, option->getDnrInstances()[0].getServicePriority());
- EXPECT_EQ(21, option->getDnrInstances()[0].getAdnLength());
+ EXPECT_EQ(24U, option->getDnrInstances()[0].getDnrInstanceDataLength());
+ EXPECT_EQ(1U, option->getDnrInstances()[0].getServicePriority());
+ EXPECT_EQ(21U, option->getDnrInstances()[0].getAdnLength());
EXPECT_EQ("myhost1.example.com.", option->getDnrInstances()[0].getAdnAsText());
// This is ADN only mode, so Addr Length and SvcParams Length
// are both expected to be zero.
- EXPECT_EQ(0, option->getDnrInstances()[0].getAddrLength());
- EXPECT_EQ(0, option->getDnrInstances()[0].getSvcParamsLength());
+ EXPECT_EQ(0U, option->getDnrInstances()[0].getAddrLength());
+ EXPECT_EQ(0U, option->getDnrInstances()[0].getSvcParamsLength());
// BTW let's check if len() works ok. In ADN only mode, DNR Instance Data Len
// is set to ADN Len (21) + 3 = 24.
// expected len: 1x(24 (ADN+ADN Len+Service priority) + 2 (DNR Instance Data Len)) + 2 (headers)
// = 28
- EXPECT_EQ(28, option->len());
+ EXPECT_EQ(28U, option->len());
// BTW let's check if toText() works ok.
// toText() len does not count in headers len.
// Check if data was unpacked correctly from wire data.
const DnrInstance& dnr_i = option->getDnrInstances()[0];
- EXPECT_EQ(45, dnr_i.getDnrInstanceDataLength());
- EXPECT_EQ(1, dnr_i.getServicePriority());
- EXPECT_EQ(21, dnr_i.getAdnLength());
+ EXPECT_EQ(45U, dnr_i.getDnrInstanceDataLength());
+ EXPECT_EQ(1U, dnr_i.getServicePriority());
+ EXPECT_EQ(21U, dnr_i.getAdnLength());
EXPECT_EQ("myhost1.example.com.", dnr_i.getAdnAsText());
- EXPECT_EQ(8, dnr_i.getAddrLength());
- EXPECT_EQ(2, dnr_i.getAddresses().size());
+ EXPECT_EQ(8U, dnr_i.getAddrLength());
+ EXPECT_EQ(2U, dnr_i.getAddresses().size());
EXPECT_EQ("192.168.0.1", dnr_i.getAddresses()[0].toText());
EXPECT_EQ("192.168.0.2", dnr_i.getAddresses()[1].toText());
EXPECT_EQ(svc_params, dnr_i.getSvcParams());
EXPECT_EQ(svc_params.size(), dnr_i.getSvcParamsLength());
- EXPECT_EQ(49, option->len());
+ EXPECT_EQ(49U, option->len());
}
// This test verifies option constructor from wire data in terms
// Check if data was unpacked correctly from wire data.
const DnrInstance& dnr_1 = option->getDnrInstances()[0];
- EXPECT_EQ(24, dnr_1.getDnrInstanceDataLength());
- EXPECT_EQ(1, dnr_1.getServicePriority());
- EXPECT_EQ(21, dnr_1.getAdnLength());
+ EXPECT_EQ(24U, dnr_1.getDnrInstanceDataLength());
+ EXPECT_EQ(1U, dnr_1.getServicePriority());
+ EXPECT_EQ(21U, dnr_1.getAdnLength());
EXPECT_EQ("myhost1.example.com.", dnr_1.getAdnAsText());
- EXPECT_EQ(0, dnr_1.getAddrLength());
- EXPECT_EQ(0, dnr_1.getSvcParamsLength());
+ EXPECT_EQ(0U, dnr_1.getAddrLength());
+ EXPECT_EQ(0U, dnr_1.getSvcParamsLength());
const DnrInstance& dnr_2 = option->getDnrInstances()[1];
- EXPECT_EQ(58, dnr_2.getDnrInstanceDataLength());
- EXPECT_EQ(2, dnr_2.getServicePriority());
- EXPECT_EQ(21, dnr_2.getAdnLength());
+ EXPECT_EQ(58U, dnr_2.getDnrInstanceDataLength());
+ EXPECT_EQ(2U, dnr_2.getServicePriority());
+ EXPECT_EQ(21U, dnr_2.getAdnLength());
EXPECT_EQ("myhost2.example.com.", dnr_2.getAdnAsText());
- EXPECT_EQ(8, dnr_2.getAddrLength());
- EXPECT_EQ(2, dnr_2.getAddresses().size());
+ EXPECT_EQ(8U, dnr_2.getAddrLength());
+ EXPECT_EQ(2U, dnr_2.getAddresses().size());
EXPECT_EQ("192.168.0.1", dnr_2.getAddresses()[0].toText());
EXPECT_EQ("192.168.0.2", dnr_2.getAddresses()[1].toText());
EXPECT_EQ(svc_params, dnr_2.getSvcParams());
EXPECT_EQ(svc_params.size(), dnr_2.getSvcParamsLength());
- EXPECT_EQ(88, option->len());
+ EXPECT_EQ(88U, option->len());
}
// Test checks that exception is thrown when trying to unpack malformed wire data
EXPECT_EQ(expected, option->toText(indent));
}
-} // namespace
\ No newline at end of file
+} // namespace
EXPECT_EQ(Option::V6, opt1->getUniverse());
EXPECT_EQ(D6O_NAME_SERVERS, opt1->getType());
- EXPECT_EQ(20, opt1->len());
+ EXPECT_EQ(20U, opt1->len());
Option6AddrLst::AddressContainer addrs = opt1->getAddresses();
- ASSERT_EQ(1, addrs.size());
+ ASSERT_EQ(1U, addrs.size());
IOAddress addr = addrs[0];
EXPECT_EQ("2001:db8:1::dead:beef", addr.toText());
// Pack this option
opt1->pack(out_buf_);
- EXPECT_EQ(20, out_buf_.getLength());
+ EXPECT_EQ(20U, out_buf_.getLength());
EXPECT_EQ(0, memcmp(expected1, out_buf_.getData(), 20));
// Two addresses
buf_.begin(), buf_.begin() + 32));
);
EXPECT_EQ(D6O_SIP_SERVERS_ADDR, opt2->getType());
- EXPECT_EQ(36, opt2->len());
+ EXPECT_EQ(36U, opt2->len());
addrs = opt2->getAddresses();
- ASSERT_EQ(2, addrs.size());
+ ASSERT_EQ(2U, addrs.size());
EXPECT_EQ("2001:db8:1::dead:beef", addrs[0].toText());
EXPECT_EQ("ff02::face:b00c", addrs[1].toText());
out_buf_.clear();
opt2->pack(out_buf_);
- EXPECT_EQ(36, out_buf_.getLength() );
+ EXPECT_EQ(36U, out_buf_.getLength() );
EXPECT_EQ(0, memcmp(expected2, out_buf_.getData(), 36));
// Three addresses
);
EXPECT_EQ(D6O_NIS_SERVERS, opt3->getType());
- EXPECT_EQ(52, opt3->len());
+ EXPECT_EQ(52U, opt3->len());
addrs = opt3->getAddresses();
- ASSERT_EQ(3, addrs.size());
+ ASSERT_EQ(3U, addrs.size());
EXPECT_EQ("2001:db8:1::dead:beef", addrs[0].toText());
EXPECT_EQ("ff02::face:b00c", addrs[1].toText());
EXPECT_EQ("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", addrs[2].toText());
out_buf_.clear();
opt3->pack(out_buf_);
- EXPECT_EQ(52, out_buf_.getLength());
+ EXPECT_EQ(52U, out_buf_.getLength());
EXPECT_EQ(0, memcmp(expected3, out_buf_.getData(), 52));
EXPECT_NO_THROW(opt1.reset());
opt1.reset(new Option6AddrLst(1234, IOAddress("::1")));
);
EXPECT_EQ(Option::V6, opt1->getUniverse());
- EXPECT_EQ(1234, opt1->getType());
+ EXPECT_EQ(1234U, opt1->getType());
Option6AddrLst::AddressContainer addrs = opt1->getAddresses();
- ASSERT_EQ(1, addrs.size() );
+ ASSERT_EQ(1U, addrs.size() );
EXPECT_EQ("::1", addrs[0].toText());
addrs.clear();
);
Option6AddrLst::AddressContainer check = opt2->getAddresses();
- ASSERT_EQ(2, check.size() );
+ ASSERT_EQ(2U, check.size());
EXPECT_EQ("fe80::1234", check[0].toText());
EXPECT_EQ("2001:db8:1::baca", check[1].toText());
/// a test for IOAddress)
Option6AddrLst::AddressContainer addrs = opt1->getAddresses();
- ASSERT_EQ(1, addrs.size());
+ ASSERT_EQ(1U, addrs.size());
EXPECT_EQ("2001:db8:1::2", addrs[0].toText());
EXPECT_NO_THROW(opt1.reset());
D6O_DHCPV4_O_DHCPV6_SERVER/256, D6O_DHCPV4_O_DHCPV6_SERVER%256,
0, 0
};
- EXPECT_EQ(4, addrs.len()); // just 2-byte type and 2-byte len fields
+ EXPECT_EQ(4U, addrs.len()); // just 2-byte type and 2-byte len fields
EXPECT_EQ("type=00088, len=00000:", addrs.toText());
OutputBuffer out_buf(255);
addrs.pack(out_buf);
- EXPECT_EQ(4, out_buf.getLength());
+ EXPECT_EQ(4U, out_buf.getLength());
EXPECT_EQ(0, memcmp(expected, out_buf.getData(), 4));
}
scoped_ptr<Option6Auth> auth;
ASSERT_NO_THROW(auth.reset(new Option6Auth(1,2,0,0x9000,{'a','b','c','d'})));
- ASSERT_EQ(1, auth->getProtocol());
- ASSERT_EQ(2, auth->getHashAlgo());
- ASSERT_EQ(0, auth->getReplyDetectionMethod());
- ASSERT_EQ(0x9000, auth->getReplyDetectionValue());
+ ASSERT_EQ(1U, auth->getProtocol());
+ ASSERT_EQ(2U, auth->getHashAlgo());
+ ASSERT_EQ(0U, auth->getReplyDetectionMethod());
+ ASSERT_EQ(0x9000U, auth->getReplyDetectionValue());
std::vector<uint8_t> test_buf = {'a','b','c','d'};
ASSERT_EQ(test_buf, auth->getAuthInfo());
auth->setReplyDetectionValue(109034830);
auth->setAuthInfo({1,2,3,4});
- ASSERT_EQ(2, auth->getProtocol());
- ASSERT_EQ(3, auth->getHashAlgo());
- ASSERT_EQ(1, auth->getReplyDetectionMethod());
- ASSERT_EQ(109034830, auth->getReplyDetectionValue());
+ ASSERT_EQ(2U, auth->getProtocol());
+ ASSERT_EQ(3U, auth->getHashAlgo());
+ ASSERT_EQ(1U, auth->getReplyDetectionMethod());
+ ASSERT_EQ(109034830U, auth->getReplyDetectionValue());
test_buf = {1,2,3,4};
ASSERT_EQ(test_buf, auth->getAuthInfo());
auth->unpack(buff_.begin(), buff_.begin()+27); //26 element is 16 byte offset from 10
std::vector<uint8_t> test_buf(16,0xa8);
- ASSERT_EQ(0xa1, auth->getProtocol());
- ASSERT_EQ(0xa2, auth->getHashAlgo());
- ASSERT_EQ(0xa3, auth->getReplyDetectionMethod());
- ASSERT_EQ(0xa4a5a6a7a8a9aaab, auth->getReplyDetectionValue());
+ ASSERT_EQ(0xa1U, auth->getProtocol());
+ ASSERT_EQ(0xa2U, auth->getHashAlgo());
+ ASSERT_EQ(0xa3U, auth->getReplyDetectionMethod());
+ ASSERT_EQ(0xa4a5a6a7a8a9aaabU, auth->getReplyDetectionValue());
ASSERT_EQ(test_buf, auth->getAuthInfo());
}
EXPECT_EQ(D6O_V6_DNR, option->getType());
// Check if data was unpacked correctly from wire data.
- EXPECT_EQ(0x8001, option->getServicePriority());
- EXPECT_EQ(20, option->getAdnLength());
+ EXPECT_EQ(0x8001U, option->getServicePriority());
+ EXPECT_EQ(20U, option->getAdnLength());
EXPECT_EQ("myhost.example.com.", option->getAdnAsText());
// This is ADN only mode, so Addr Length and SvcParams Length
// are both expected to be zero.
- EXPECT_EQ(0, option->getAddrLength());
- EXPECT_EQ(0, option->getSvcParamsLength());
+ EXPECT_EQ(0U, option->getAddrLength());
+ EXPECT_EQ(0U, option->getSvcParamsLength());
// BTW let's check if len() works ok.
// expected len: 20 (FQDN) + 2 (ADN Len) + 2 (Service priority) + 4 (headers) = 28.
- EXPECT_EQ(28, option->len());
+ EXPECT_EQ(28U, option->len());
// BTW let's check if toText() works ok.
// toText() len does not count in headers len.
EXPECT_EQ(D6O_V6_DNR, option->getType());
// Check if data was unpacked correctly from wire data.
- EXPECT_EQ(0x8001, option->getServicePriority());
- EXPECT_EQ(20, option->getAdnLength());
+ EXPECT_EQ(0x8001U, option->getServicePriority());
+ EXPECT_EQ(20U, option->getAdnLength());
EXPECT_EQ("myhost.example.com.", option->getAdnAsText());
- EXPECT_EQ(48, option->getAddrLength());
+ EXPECT_EQ(48U, option->getAddrLength());
const Option6Dnr::AddressContainer& addresses = option->getAddresses();
- EXPECT_EQ(3, addresses.size());
+ EXPECT_EQ(3U, addresses.size());
EXPECT_EQ("2001:db8:1::dead:beef", addresses[0].toText());
EXPECT_EQ("ff02::face:b00c", addresses[1].toText());
EXPECT_EQ("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", addresses[2].toText());
- EXPECT_EQ(0, option->getSvcParamsLength());
+ EXPECT_EQ(0U, option->getSvcParamsLength());
// BTW let's check if len() works ok.
// expected len: 20 (FQDN) + 2 (ADN Len) + 2 (Service priority) + 4 (headers) = 28
// + 48 (3 IP addresses) + 2 (Addr Len) = 78.
- EXPECT_EQ(78, option->len());
+ EXPECT_EQ(78U, option->len());
// BTW let's check if toText() works ok.
// toText() len does not count in headers len.
EXPECT_EQ(D6O_V6_DNR, option->getType());
// Check if data was unpacked correctly from wire data.
- EXPECT_EQ(0x8001, option->getServicePriority());
- EXPECT_EQ(20, option->getAdnLength());
+ EXPECT_EQ(0x8001U, option->getServicePriority());
+ EXPECT_EQ(20U, option->getAdnLength());
EXPECT_EQ("myhost.example.com.", option->getAdnAsText());
- EXPECT_EQ(16, option->getAddrLength());
+ EXPECT_EQ(16U, option->getAddrLength());
const Option6Dnr::AddressContainer& addresses = option->getAddresses();
- EXPECT_EQ(1, addresses.size());
+ EXPECT_EQ(1U, addresses.size());
EXPECT_EQ("2001:db8:1::dead:beef", addresses[0].toText());
// Reference SvcParams on-wire data buffer.
// BTW let's check if len() works ok.
// expected len: 20 (FQDN) + 2 (ADN Len) + 2 (Service priority) + 4 (headers) = 28
// + 16 (IP address) + 2 (Addr Len) + 12 (SvcParams) = 58.
- EXPECT_EQ(58, option->len());
+ EXPECT_EQ(58U, option->len());
// BTW let's check if toText() works ok.
// toText() len does not count in headers len.
EXPECT_EQ(0, memcmp(ref_data, buf.getData(), buf.getLength()));
}
-} // namespace
\ No newline at end of file
+} // namespace
EXPECT_EQ(Option::V6, opt->getUniverse());
EXPECT_EQ(type, opt->getType());
- EXPECT_EQ(0xa1a2a3a4, opt->getIAID());
- EXPECT_EQ(0x81020304, opt->getT1());
- EXPECT_EQ(0x84030201, opt->getT2());
+ EXPECT_EQ(0xa1a2a3a4U, opt->getIAID());
+ EXPECT_EQ(0x81020304U, opt->getT1());
+ EXPECT_EQ(0x84030201U, opt->getT2());
// Pack this option again in the same buffer, but in
// different place
EXPECT_EQ(12, opt->len() - opt->getHeaderLen());
EXPECT_EQ(type, opt->getType());
- EXPECT_EQ(16, outBuf_.getLength()); // length(IA_NA) = 16
+ EXPECT_EQ(16U, outBuf_.getLength()); // length(IA_NA) = 16
// Check if pack worked properly:
InputBuffer out(outBuf_.getData(), outBuf_.getLength());
EXPECT_EQ(type, out.readUint16());
// - if option length is correct
- EXPECT_EQ(12, out.readUint16());
+ EXPECT_EQ(12U, out.readUint16());
// - if iaid is correct
- EXPECT_EQ(0xa1a2a3a4, out.readUint32() );
+ EXPECT_EQ(0xa1a2a3a4U, out.readUint32() );
// - if T1 is correct
- EXPECT_EQ(0x81020304, out.readUint32() );
+ EXPECT_EQ(0x81020304U, out.readUint32() );
// - if T1 is correct
- EXPECT_EQ(0x84030201, out.readUint32() );
+ EXPECT_EQ(0x84030201U, out.readUint32() );
EXPECT_NO_THROW(opt.reset());
}
// Check that the values are really different than what we are about
// to set them to.
- EXPECT_NE(2345, ia->getT1());
- EXPECT_NE(3456, ia->getT2());
+ EXPECT_NE(2345U, ia->getT1());
+ EXPECT_NE(3456U, ia->getT2());
ia->setT1(2345);
ia->setT2(3456);
EXPECT_EQ(Option::V6, ia->getUniverse());
EXPECT_EQ(D6O_IA_NA, ia->getType());
- EXPECT_EQ(1234, ia->getIAID());
- EXPECT_EQ(2345, ia->getT1());
- EXPECT_EQ(3456, ia->getT2());
+ EXPECT_EQ(1234U, ia->getIAID());
+ EXPECT_EQ(2345U, ia->getT1());
+ EXPECT_EQ(3456U, ia->getT2());
ia->setIAID(890);
- EXPECT_EQ(890, ia->getIAID());
+ EXPECT_EQ(890U, ia->getIAID());
EXPECT_NO_THROW(ia.reset());
}
ia->addOption(sub1);
ia->addOption(addr1);
- ASSERT_EQ(28, addr1->len());
- ASSERT_EQ(4, sub1->len());
- ASSERT_EQ(48, ia->len());
+ ASSERT_EQ(28U, addr1->len());
+ ASSERT_EQ(4U, sub1->len());
+ ASSERT_EQ(48U, ia->len());
// This contains expected on-wire format
uint8_t expected[] = {
ia->pack(outBuf_);
- ASSERT_EQ(48, outBuf_.getLength());
+ ASSERT_EQ(48U, outBuf_.getLength());
EXPECT_EQ(0, memcmp(outBuf_.getData(), expected, 48));
EXPECT_NO_THROW(ia.reset());
}
ia->addOption(sub1);
ia->addOption(addr1);
- ASSERT_EQ(29, addr1->len());
- ASSERT_EQ(4, sub1->len());
- ASSERT_EQ(49, ia->len());
+ ASSERT_EQ(29U, addr1->len());
+ ASSERT_EQ(4U, sub1->len());
+ ASSERT_EQ(49U, ia->len());
uint8_t expected[] = {
D6O_IA_PD/256, D6O_IA_PD%256, // type
};
ia->pack(outBuf_);
- ASSERT_EQ(49, outBuf_.getLength());
+ ASSERT_EQ(49U, outBuf_.getLength());
EXPECT_EQ(0, memcmp(outBuf_.getData(), expected, 49));
0xca, 0xfe, // type
0, 0 // len
};
- ASSERT_EQ(48, sizeof(expected));
+ ASSERT_EQ(48U, sizeof(expected));
memcpy(&buf_[0], expected, sizeof(expected));
ASSERT_TRUE(ia);
EXPECT_EQ(D6O_IA_NA, ia->getType());
- EXPECT_EQ(0x13579ace, ia->getIAID());
- EXPECT_EQ(0x2345, ia->getT1());
- EXPECT_EQ(0x3456, ia->getT2());
+ EXPECT_EQ(0x13579aceU, ia->getIAID());
+ EXPECT_EQ(0x2345U, ia->getT1());
+ EXPECT_EQ(0x3456U, ia->getT2());
OptionPtr subopt = ia->getOption(D6O_IAADDR);
ASSERT_NE(OptionPtr(), subopt); // non-NULL
ASSERT_TRUE(addr);
EXPECT_EQ(D6O_IAADDR, addr->getType());
- EXPECT_EQ(28, addr->len());
- EXPECT_EQ(0x5000, addr->getPreferred());
- EXPECT_EQ(0x7000, addr->getValid());
+ EXPECT_EQ(28U, addr->len());
+ EXPECT_EQ(0x5000U, addr->getPreferred());
+ EXPECT_EQ(0x7000U, addr->getValid());
EXPECT_EQ("2001:db8:1234:5678::abcd", addr->getAddress().toText());
// Checks for dummy option
subopt = ia->getOption(0xcafe);
ASSERT_TRUE(subopt); // should be non-NULL
- EXPECT_EQ(0xcafe, subopt->getType());
- EXPECT_EQ(4, subopt->len());
+ EXPECT_EQ(0xcafeU, subopt->getType());
+ EXPECT_EQ(4U, subopt->len());
// There should be no data at all
- EXPECT_EQ(0, subopt->getData().size());
+ EXPECT_EQ(0U, subopt->getData().size());
subopt = ia->getOption(1); // get option 1
ASSERT_FALSE(subopt); // should be NULL
// Pack this option
opt->pack(outBuf_);
- EXPECT_EQ(28, outBuf_.getLength());
+ EXPECT_EQ(28U, outBuf_.getLength());
EXPECT_EQ(Option::V6, opt->getUniverse());
// 4 bytes header + 4 bytes content
EXPECT_EQ("2001:db8:1::dead:beef", opt->getAddress().toText());
- EXPECT_EQ(1000, opt->getPreferred());
+ EXPECT_EQ(1000U, opt->getPreferred());
EXPECT_EQ(3000000000U, opt->getValid());
EXPECT_EQ(D6O_IAADDR, opt->getType());
EXPECT_EQ(Option::V6, opt.getUniverse());
EXPECT_EQ(expected_type, opt.getType());
EXPECT_EQ(expected_address, opt.getAddress());
- EXPECT_EQ(1000, opt.getPreferred());
+ EXPECT_EQ(1000U, opt.getPreferred());
EXPECT_EQ(3000000000U, opt.getValid());
// uint8_t is often represented as a character type (char). Convert it
// to integer so as it is logged as a numeric value instead.
// Pack this option
opt->pack(out_buf_);
- EXPECT_EQ(29, out_buf_.getLength());
+ EXPECT_EQ(29U, out_buf_.getLength());
// The non-significant bits (above 77) of the received prefix should be
// set to zero.
// Pack this option
opt->pack(out_buf_);
- EXPECT_EQ(29, out_buf_.getLength());
+ EXPECT_EQ(29U, out_buf_.getLength());
checkOption(*opt, D6O_IAPREFIX, 128,
IOAddress("2001:db8:1:0:afaf:0:dead:beef"));
// Pack this option
opt->pack(out_buf_);
- EXPECT_EQ(29, out_buf_.getLength());
+ EXPECT_EQ(29U, out_buf_.getLength());
checkOption(*opt, D6O_IAPREFIX, 0, IOAddress("::"));
// Check if we can build it properly
EXPECT_NO_THROW(opt->pack(out_buf_));
- EXPECT_EQ(29, out_buf_.getLength());
+ EXPECT_EQ(29U, out_buf_.getLength());
checkOutputBuffer(12345);
// Check that option can be disposed safely
option->setValue(9);
// The value in the copy should not be affected.
- EXPECT_EQ(12345, option_copy->getValue());
+ EXPECT_EQ(12345U, option_copy->getValue());
}
TEST(OptionCopyTest, optionIntConstructor) {
// The values in the copy should not be affected.
std::vector<uint32_t> values_copy = option_copy->getValues();
- ASSERT_EQ(2, values_copy.size());
- EXPECT_EQ(2345, values_copy[0]);
- EXPECT_EQ(3456, values_copy[1]);
+ ASSERT_EQ(2U, values_copy.size());
+ EXPECT_EQ(2345U, values_copy[0]);
+ EXPECT_EQ(3456U, values_copy[1]);
}
TEST(OptionCopyTest, optionIntArrayConstructor) {
// The address in the copy should not be affected.
typename OptionType::AddressContainer addrs_copy = option_copy->getAddresses();
- ASSERT_EQ(1, addrs_copy.size());
+ ASSERT_EQ(1U, addrs_copy.size());
EXPECT_EQ(option_address.toText(), addrs_copy[0].toText());
}
option->setIAID(5678);
// The values in the copy should not be affected.
- EXPECT_EQ(1000, option_copy->getT1());
- EXPECT_EQ(2000, option_copy->getT2());
- EXPECT_EQ(1234, option_copy->getIAID());
+ EXPECT_EQ(1000U, option_copy->getT1());
+ EXPECT_EQ(2000U, option_copy->getT2());
+ EXPECT_EQ(1234U, option_copy->getIAID());
}
TEST(OptionCopyTest, option6IAConstructor) {
// The values in the copy should not be affected.
EXPECT_EQ("2001:db8:1::1", option_copy->getAddress().toText());
- EXPECT_EQ(60, option_copy->getPreferred());
- EXPECT_EQ(90, option_copy->getValid());
+ EXPECT_EQ(60U, option_copy->getPreferred());
+ EXPECT_EQ(90U, option_copy->getValid());
}
TEST(OptionCopyTest, option6IAAddrConstructor) {
// The values in the copy should not be affected.
EXPECT_EQ("3000::", option_copy->getAddress().toText());
- EXPECT_EQ(64, option_copy->getLength());
- EXPECT_EQ(60, option_copy->getPreferred());
- EXPECT_EQ(90, option_copy->getValid());
+ EXPECT_EQ(64U, option_copy->getLength());
+ EXPECT_EQ(60U, option_copy->getPreferred());
+ EXPECT_EQ(90U, option_copy->getValid());
}
TEST(OptionCopyTest, option6IAPrefixConstructor) {
option->setVendorId(2222);
// The vendor id in the copy should not be affected.
- EXPECT_EQ(2986, option_copy->getVendorId());
+ EXPECT_EQ(2986U, option_copy->getVendorId());
}
TEST(OptionCopyTest, optionVendorConstructor) {
// That change shouldn't affect the original option. It should still
// contain a single tuple with the original value.
- ASSERT_EQ(1, option_copy->getTuplesNum());
+ ASSERT_EQ(1U, option_copy->getTuplesNum());
tuple = option_copy->getTuple(0);
EXPECT_TRUE(tuple.equals("vendor-class-value"));
}
Option4ClientFqdnPtr option_copy4 =
boost::dynamic_pointer_cast<Option4ClientFqdn>(option_copy);
if (option_copy4) {
- EXPECT_EQ(255, option_copy4->getRcode().first.getCode());
- EXPECT_EQ(255, option_copy4->getRcode().second.getCode());
+ EXPECT_EQ(255U, option_copy4->getRcode().first.getCode());
+ EXPECT_EQ(255U, option_copy4->getRcode().second.getCode());
}
}
option->writeInteger<uint16_t>(1000);
// The copied option should not be affected.
- ASSERT_EQ(1, option_copy->getDataFieldsNum());
- EXPECT_EQ(5555, option_copy->readInteger<uint16_t>());
+ ASSERT_EQ(1U, option_copy->getDataFieldsNum());
+ EXPECT_EQ(5555U, option_copy->readInteger<uint16_t>());
}
TEST(OptionCopyTest, optionCustomConstructor) {
option->setTuple(1, tuple);
// This should not affect the values in the original option.
- ASSERT_EQ(2, option_copy->getTuplesNum());
+ ASSERT_EQ(2U, option_copy->getTuplesNum());
EXPECT_TRUE(option_copy->getTuple(0).equals("a string"));
EXPECT_TRUE(option_copy->getTuple(1).equals("another string"));
}
// Check if constructor initialized the universe and type correctly.
EXPECT_EQ(Option::V6, option->getUniverse());
- EXPECT_EQ(1000, option->getType());
+ EXPECT_EQ(1000U, option->getType());
// Do another round of testing for DHCPv4 option.
OptionDefinition opt_def2("OPTION_FOO", 232, "my-space", "boolean");
ASSERT_TRUE(option);
EXPECT_EQ(Option::V4, option->getUniverse());
- EXPECT_EQ(232, option->getType());
+ EXPECT_EQ(232U, option->getType());
// Try to create an option using 'empty data' constructor
OptionDefinition opt_def3("OPTION_FOO", 1000, "my-space", "uint32");
ASSERT_TRUE(option);
EXPECT_EQ(Option::V6, option->getUniverse());
- EXPECT_EQ(1000, option->getType());
+ EXPECT_EQ(1000U, option->getType());
}
// The purpose of this test is to verify that 'empty' option definition can
ASSERT_TRUE(option);
// Option is 'empty' so no data fields are expected.
- EXPECT_EQ(0, option->getDataFieldsNum());
+ EXPECT_EQ(0U, option->getDataFieldsNum());
// Check that suboption has been parsed.
EXPECT_TRUE(hasV4Suboption(option.get()));
ASSERT_TRUE(option);
// We should have just one data field.
- ASSERT_EQ(1, option->getDataFieldsNum());
+ ASSERT_EQ(1U, option->getDataFieldsNum());
// The custom option should hold just one buffer that can be
// accessed using index 0.
ASSERT_TRUE(option);
// We should have just one data field.
- ASSERT_EQ(1, option->getDataFieldsNum());
+ ASSERT_EQ(1U, option->getDataFieldsNum());
// Initialize the value to true because we want to make sure
// that it is modified to 'false' by readBoolean below.
ASSERT_TRUE(option);
// We should have just one data field.
- ASSERT_EQ(1, option->getDataFieldsNum());
+ ASSERT_EQ(1U, option->getDataFieldsNum());
// Check it
std::string value;
ASSERT_TRUE(option);
// We should have just one data field.
- ASSERT_EQ(1, option->getDataFieldsNum());
+ ASSERT_EQ(1U, option->getDataFieldsNum());
// Check it
std::string value;
);
ASSERT_TRUE(option);
- ASSERT_EQ(1, option->getDataFieldsNum());
+ ASSERT_EQ(1U, option->getDataFieldsNum());
std::string domain0 = option->readFqdn(0);
EXPECT_EQ("mydomain.example.com.", domain0);
ASSERT_TRUE(option);
// We should have just one data field.
- ASSERT_EQ(1, option->getDataFieldsNum());
+ ASSERT_EQ(1U, option->getDataFieldsNum());
// Initialize value to 0 explicitly to make sure that is
// modified by readInteger function to expected -234.
ASSERT_TRUE(option);
// We should have just one data field.
- ASSERT_EQ(1, option->getDataFieldsNum());
+ ASSERT_EQ(1U, option->getDataFieldsNum());
// Initialize value to 0 explicitly to make sure that is
// modified by readInteger function to expected -234.
ASSERT_TRUE(option);
// We should have just one data field.
- ASSERT_EQ(1, option->getDataFieldsNum());
+ ASSERT_EQ(1U, option->getDataFieldsNum());
IOAddress address("127.0.0.1");
// Read IPv4 address from using index 0.
ASSERT_TRUE(option);
// We should have just one data field.
- ASSERT_EQ(1, option->getDataFieldsNum());
+ ASSERT_EQ(1U, option->getDataFieldsNum());
// Custom option should comprise exactly one buffer that represents
// IPv6 address.
ASSERT_TRUE(option);
// We should have just one data field.
- ASSERT_EQ(1, option->getDataFieldsNum());
+ ASSERT_EQ(1U, option->getDataFieldsNum());
// Custom option should comprise exactly one buffer that represents
// a prefix.
ASSERT_NO_THROW(prefix = option->readPrefix(0));
// The prefix comprises a prefix length and prefix value.
- EXPECT_EQ(32, prefix.first.asUnsigned());
+ EXPECT_EQ(32U, prefix.first.asUnsigned());
EXPECT_EQ("3000:1::", prefix.second.toText());
// Parsed option should have one suboption.
ASSERT_TRUE(option);
// We should have just one data field.
- ASSERT_EQ(1, option->getDataFieldsNum());
+ ASSERT_EQ(1U, option->getDataFieldsNum());
// Custom option should comprise exactly one buffer that represents
// a PSID length / PSID value tuple.
ASSERT_NO_THROW(psid = option->readPsid(0));
// The PSID comprises a PSID length and PSID value.
- EXPECT_EQ(4, psid.first.asUnsigned());
- EXPECT_EQ(0x08, psid.second.asUint16());
+ EXPECT_EQ(4U, psid.first.asUnsigned());
+ EXPECT_EQ(0x08U, psid.second.asUint16());
// Parsed option should have one suboption.
EXPECT_TRUE(hasV6Suboption(option.get()));
ASSERT_TRUE(option);
// We should have just one data field.
- ASSERT_EQ(1, option->getDataFieldsNum());
+ ASSERT_EQ(1U, option->getDataFieldsNum());
// Custom option should now comprise single string value that
// can be accessed using index 0.
// The initial part of the string should contain the actual string.
// The rest of it is a garbage from an attempt to decode suboption
// as a string.
- ASSERT_EQ(20, value.size());
+ ASSERT_EQ(20U, value.size());
EXPECT_EQ("hello world!", value.substr(0, 12));
// No suboption should be present.
ASSERT_TRUE(option);
// We should have 5 data fields.
- ASSERT_EQ(5, option->getDataFieldsNum());
+ ASSERT_EQ(5U, option->getDataFieldsNum());
// Read values from custom option using indexes 0..4 and
// check that they are valid.
ASSERT_TRUE(option);
// We should have 3 data fields.
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// Expect only 3 values.
for (int i = 0; i < 3; ++i) {
ASSERT_TRUE(option);
// We should have 3 data fields.
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// We expect 3 IPv4 addresses being stored in the option.
for (int i = 0; i < 3; ++i) {
ASSERT_TRUE(option);
// We should have 3 data fields.
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// We expect 3 IPv6 addresses being stored in the option.
for (int i = 0; i < 3; ++i) {
// We expect that two FQDN values have been extracted
// from a buffer.
- ASSERT_EQ(2, option->getDataFieldsNum());
+ ASSERT_EQ(2U, option->getDataFieldsNum());
// Validate both values.
std::string domain0 = option->readFqdn(0);
ASSERT_TRUE(option);
// We should have 3 data fields with 3 prefixes.
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
PrefixTuple prefix0(ZERO_PREFIX_TUPLE);
PrefixTuple prefix1(ZERO_PREFIX_TUPLE);
ASSERT_NO_THROW(prefix1 = option->readPrefix(1));
ASSERT_NO_THROW(prefix2 = option->readPrefix(2));
- EXPECT_EQ(32, prefix0.first.asUnsigned());
+ EXPECT_EQ(32U, prefix0.first.asUnsigned());
EXPECT_EQ("3001:1::", prefix0.second.toText());
- EXPECT_EQ(16, prefix1.first.asUnsigned());
+ EXPECT_EQ(16U, prefix1.first.asUnsigned());
EXPECT_EQ("3000::", prefix1.second.toText());
- EXPECT_EQ(48, prefix2.first.asUnsigned());
+ EXPECT_EQ(48U, prefix2.first.asUnsigned());
EXPECT_EQ("2001:db8:1::", prefix2.second.toText());
}
ASSERT_TRUE(option);
// We should have 3 data fields with 3 PSIDs.
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
PSIDTuple psid0;
PSIDTuple psid1;
ASSERT_NO_THROW(psid2 = option->readPsid(2));
// PSID value is equal to '1000b' (8).
- EXPECT_EQ(4, psid0.first.asUnsigned());
- EXPECT_EQ(0x08, psid0.second.asUint16());
+ EXPECT_EQ(4U, psid0.first.asUnsigned());
+ EXPECT_EQ(0x08U, psid0.second.asUint16());
// PSID value is equal to '110101b' (0x35).
- EXPECT_EQ(6, psid1.first.asUnsigned());
- EXPECT_EQ(0x35, psid1.second.asUint16());
+ EXPECT_EQ(6U, psid1.first.asUnsigned());
+ EXPECT_EQ(0x35U, psid1.second.asUint16());
// PSID value is equal to '1b' (1).
- EXPECT_EQ(1, psid2.first.asUnsigned());
- EXPECT_EQ(0x01, psid2.second.asUint16());
+ EXPECT_EQ(1U, psid2.first.asUnsigned());
+ EXPECT_EQ(0x01U, psid2.second.asUint16());
}
// The purpose of this test is to verify that the data from a buffer
ASSERT_TRUE(option);
// We should have 3 data fields
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// Check them
std::string value;
ASSERT_TRUE(option);
// We should have 3 data fields
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// Check them
std::string value;
ASSERT_TRUE(option);
// We should have two data fields parsed.
- ASSERT_EQ(2, option->getDataFieldsNum());
+ ASSERT_EQ(2U, option->getDataFieldsNum());
// Validate values in fields.
uint32_t value0 = 0;
ASSERT_NO_THROW(value0 = option->readInteger<uint32_t>(0));
- EXPECT_EQ(0x01020304, value0);
+ EXPECT_EQ(0x01020304U, value0);
IOAddress value1 = 0;
ASSERT_NO_THROW(value1 = option->readAddress(1));
ASSERT_TRUE(option);
// We should have 6 data fields.
- ASSERT_EQ(7, option->getDataFieldsNum());
+ ASSERT_EQ(7U, option->getDataFieldsNum());
// Verify value in the field 0.
uint16_t value0 = 0;
ASSERT_NO_THROW(value0 = option->readInteger<uint16_t>(0));
- EXPECT_EQ(8712, value0);
+ EXPECT_EQ(8712U, value0);
// Verify value in the field 1.
bool value1 = false;
// Verify value in the field 5.
PSIDTuple value5;
ASSERT_NO_THROW(value5 = option->readPsid(5));
- EXPECT_EQ(6, value5.first.asUnsigned());
- EXPECT_EQ(0x35, value5.second.asUint16());
+ EXPECT_EQ(6U, value5.first.asUnsigned());
+ EXPECT_EQ(0x35U, value5.second.asUint16());
// Verify value in the field 6.
std::string value6;
ASSERT_TRUE(option);
// We should have 7+1 data fields.
- ASSERT_EQ(8, option->getDataFieldsNum());
+ ASSERT_EQ(8U, option->getDataFieldsNum());
// Verify value in the field 0.
uint16_t value0 = 0;
ASSERT_NO_THROW(value0 = option->readInteger<uint16_t>(0));
- EXPECT_EQ(8712, value0);
+ EXPECT_EQ(8712U, value0);
// Verify value in the field 1.
bool value1 = false;
// Verify value in the field 5.
PSIDTuple value5;
ASSERT_NO_THROW(value5 = option->readPsid(5));
- EXPECT_EQ(6, value5.first.asUnsigned());
- EXPECT_EQ(0x35, value5.second.asUint16());
+ EXPECT_EQ(6U, value5.first.asUnsigned());
+ EXPECT_EQ(0x35U, value5.second.asUint16());
// Verify value in the field 6.
uint32_t value6;
ASSERT_NO_THROW(value6 = option->readInteger<uint32_t>(6));
- EXPECT_EQ(12345678, value6);
+ EXPECT_EQ(12345678U, value6);
// Verify value in the extra field 7.
uint32_t value7;
ASSERT_NO_THROW(value7 = option->readInteger<uint32_t>(7));
- EXPECT_EQ(87654321, value7);
+ EXPECT_EQ(87654321U, value7);
}
// The purpose of this test is to verify that truncated buffer
// The default value for integer data fields is 0.
uint32_t value = 0;
ASSERT_NO_THROW(option->readInteger<uint32_t>());
- EXPECT_EQ(0, value);
+ EXPECT_EQ(0U, value);
// Try to set the data field value to something different
// than 0.
// Verify that it has been set.
ASSERT_NO_THROW(value = option->readInteger<uint32_t>());
- EXPECT_EQ(1234, value);
+ EXPECT_EQ(1234U, value);
}
// The purpose of this test is to verify that an option comprising
// Make sure the default prefix is set.
PrefixTuple prefix(ZERO_PREFIX_TUPLE);
ASSERT_NO_THROW(prefix = option->readPrefix());
- EXPECT_EQ(0, prefix.first.asUnsigned());
+ EXPECT_EQ(0U, prefix.first.asUnsigned());
EXPECT_EQ("::", prefix.second.toText());
// Write prefix.
// Read prefix back and make sure it is the one we just set.
ASSERT_NO_THROW(prefix = option->readPrefix());
- EXPECT_EQ(48, prefix.first.asUnsigned());
+ EXPECT_EQ(48U, prefix.first.asUnsigned());
EXPECT_EQ("2001:db8:1::", prefix.second.toText());
}
// Make sure the default PSID is set.
PSIDTuple psid;
ASSERT_NO_THROW(psid = option->readPsid());
- EXPECT_EQ(0, psid.first.asUnsigned());
- EXPECT_EQ(0, psid.second.asUint16());
+ EXPECT_EQ(0U, psid.first.asUnsigned());
+ EXPECT_EQ(0U, psid.second.asUint16());
// Write PSID.
ASSERT_NO_THROW(option->writePsid(PSIDLen(4), PSID(8)));
// Read PSID back and make sure it is the one we just set.
ASSERT_NO_THROW(psid = option->readPsid());
- EXPECT_EQ(4, psid.first.asUnsigned());
- EXPECT_EQ(8, psid.second.asUint16());
+ EXPECT_EQ(4U, psid.first.asUnsigned());
+ EXPECT_EQ(8U, psid.second.asUint16());
}
// The purpose of this test is to verify that an option comprising
ASSERT_TRUE(option);
// Initially, the array should contain no values.
- ASSERT_EQ(0, option->getDataFieldsNum());
+ ASSERT_EQ(0U, option->getDataFieldsNum());
// Add some boolean values to it.
ASSERT_NO_THROW(option->addArrayDataField(true));
ASSERT_TRUE(option);
// Initially, the array should contain no values.
- ASSERT_EQ(0, option->getDataFieldsNum());
+ ASSERT_EQ(0U, option->getDataFieldsNum());
// Add 3 new data fields holding integer values.
ASSERT_NO_THROW(option->addArrayDataField<uint16_t>(67));
ASSERT_NO_THROW(option->addArrayDataField<uint16_t>(32222));
// We should now have 3 data fields.
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// Check that the values have been correctly set.
uint16_t value0 = 0;
ASSERT_NO_THROW(value0 = option->readInteger<uint16_t>(0));
- EXPECT_EQ(67, value0);
+ EXPECT_EQ(67U, value0);
uint16_t value1 = 0;
ASSERT_NO_THROW(value1 = option->readInteger<uint16_t>(1));
- EXPECT_EQ(876, value1);
+ EXPECT_EQ(876U, value1);
uint16_t value2 = 0;
ASSERT_NO_THROW(value2 = option->readInteger<uint16_t>(2));
- EXPECT_EQ(32222, value2);
+ EXPECT_EQ(32222U, value2);
}
/// The purpose of this test is to verify that an option comprising
ASSERT_TRUE(option);
// Expect that the array does not contain any data fields yet.
- ASSERT_EQ(0, option->getDataFieldsNum());
+ ASSERT_EQ(0U, option->getDataFieldsNum());
// Add 3 IPv4 addresses.
ASSERT_NO_THROW(option->addArrayDataField(IOAddress("192.168.0.1")));
ASSERT_NO_THROW(option->addArrayDataField(IOAddress("192.168.0.2")));
ASSERT_NO_THROW(option->addArrayDataField(IOAddress("192.168.0.3")));
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// Check that all IP addresses have been set correctly.
IOAddress address0("127.0.0.1");
ASSERT_TRUE(option);
// Initially, the array does not contain any data fields.
- ASSERT_EQ(0, option->getDataFieldsNum());
+ ASSERT_EQ(0U, option->getDataFieldsNum());
// Add 3 new IPv6 addresses into the array.
ASSERT_NO_THROW(option->addArrayDataField(IOAddress("2001:db8:1::1")));
ASSERT_NO_THROW(option->addArrayDataField(IOAddress("2001:db8:1::3")));
// We should have now 3 addresses added.
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// Check that they have correct values set.
IOAddress address0("::1");
ASSERT_TRUE(option);
// Initially, the array does not contain any data fields.
- ASSERT_EQ(0, option->getDataFieldsNum());
+ ASSERT_EQ(0U, option->getDataFieldsNum());
// Add 3 new PSIDs
ASSERT_NO_THROW(option->addArrayDataField(PSIDLen(4), PSID(1)));
// Verify the stored values.
ASSERT_NO_THROW({
PSIDTuple psid0 = option->readPsid(0);
- EXPECT_EQ(4, psid0.first.asUnsigned());
- EXPECT_EQ(1, psid0.second.asUint16());
+ EXPECT_EQ(4U, psid0.first.asUnsigned());
+ EXPECT_EQ(1U, psid0.second.asUint16());
});
ASSERT_NO_THROW({
PSIDTuple psid1 = option->readPsid(1);
- EXPECT_EQ(0, psid1.first.asUnsigned());
- EXPECT_EQ(0, psid1.second.asUint16());
+ EXPECT_EQ(0U, psid1.first.asUnsigned());
+ EXPECT_EQ(0U, psid1.second.asUint16());
});
ASSERT_NO_THROW({
PSIDTuple psid2 = option->readPsid(2);
- EXPECT_EQ(1, psid2.first.asUnsigned());
- EXPECT_EQ(1, psid2.second.asUint16());
+ EXPECT_EQ(1U, psid2.first.asUnsigned());
+ EXPECT_EQ(1U, psid2.second.asUint16());
});
}
ASSERT_TRUE(option);
// Initially, the array does not contain any data fields.
- ASSERT_EQ(0, option->getDataFieldsNum());
+ ASSERT_EQ(0U, option->getDataFieldsNum());
// Add 3 new IPv6 prefixes into the array.
ASSERT_NO_THROW(option->addArrayDataField(PrefixLen(64),
IOAddress("3000::")));
// We should have now 3 addresses added.
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// Verify the stored values.
ASSERT_NO_THROW({
PrefixTuple prefix0 = option->readPrefix(0);
- EXPECT_EQ(64, prefix0.first.asUnsigned());
+ EXPECT_EQ(64U, prefix0.first.asUnsigned());
EXPECT_EQ("2001:db8:1::", prefix0.second.toText());
});
ASSERT_NO_THROW({
PrefixTuple prefix1 = option->readPrefix(1);
- EXPECT_EQ(32, prefix1.first.asUnsigned());
+ EXPECT_EQ(32U, prefix1.first.asUnsigned());
EXPECT_EQ("3001:1::", prefix1.second.toText());
});
ASSERT_NO_THROW({
PrefixTuple prefix2 = option->readPrefix(2);
- EXPECT_EQ(16, prefix2.first.asUnsigned());
+ EXPECT_EQ(16U, prefix2.first.asUnsigned());
EXPECT_EQ("3000::", prefix2.second.toText());
});
}
ASSERT_TRUE(option);
// Initially, the array does not contain any data fields.
- ASSERT_EQ(0, option->getDataFieldsNum());
+ ASSERT_EQ(0U, option->getDataFieldsNum());
// Add 3 new DHCPv4 tuple into the array.
ASSERT_NO_THROW(option->addArrayDataField(std::string("hello")));
ASSERT_NO_THROW(option->addArrayDataField(tuple));
// We should have now 3 tuples added.
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// Verify the stored values.
ASSERT_NO_THROW({
ASSERT_TRUE(option);
// Initially, the array does not contain any data fields.
- ASSERT_EQ(0, option->getDataFieldsNum());
+ ASSERT_EQ(0U, option->getDataFieldsNum());
// Add 3 new DHCPv6 tuple into the array.
ASSERT_NO_THROW(option->addArrayDataField(std::string("hello")));
ASSERT_NO_THROW(option->addArrayDataField(tuple));
// We should have now 3 tuples added.
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// Verify the stored values.
ASSERT_NO_THROW({
// The number of elements should be equal to number of elements
// in the record.
- ASSERT_EQ(9, option->getDataFieldsNum());
+ ASSERT_EQ(9U, option->getDataFieldsNum());
// Check that the default values have been correctly set.
uint16_t value0 = 0;
ASSERT_NO_THROW(value0 = option->readInteger<uint16_t>(0));
- EXPECT_EQ(0, value0);
+ EXPECT_EQ(0U, value0);
bool value1 = true;
ASSERT_NO_THROW(value1 = option->readBoolean(1));
EXPECT_FALSE(value1);
EXPECT_EQ("::", value4.toText());
PSIDTuple value5;
ASSERT_NO_THROW(value5 = option->readPsid(5));
- EXPECT_EQ(0, value5.first.asUnsigned());
- EXPECT_EQ(0, value5.second.asUint16());
+ EXPECT_EQ(0U, value5.first.asUnsigned());
+ EXPECT_EQ(0U, value5.second.asUint16());
PrefixTuple value6(ZERO_PREFIX_TUPLE);
ASSERT_NO_THROW(value6 = option->readPrefix(6));
- EXPECT_EQ(0, value6.first.asUnsigned());
+ EXPECT_EQ(0U, value6.first.asUnsigned());
EXPECT_EQ("::", value6.second.toText());
std::string value7 = "abc";
// Tuple has no default value
// Check that the new values have been correctly set.
ASSERT_NO_THROW(value0 = option->readInteger<uint16_t>(0));
- EXPECT_EQ(1234, value0);
+ EXPECT_EQ(1234U, value0);
ASSERT_NO_THROW(value1 = option->readBoolean(1));
EXPECT_TRUE(value1);
ASSERT_NO_THROW(value2 = option->readFqdn(2));
ASSERT_NO_THROW(value4 = option->readAddress(4));
EXPECT_EQ("2001:db8:1::100", value4.toText());
ASSERT_NO_THROW(value5 = option->readPsid(5));
- EXPECT_EQ(4, value5.first.asUnsigned());
- EXPECT_EQ(8, value5.second.asUint16());
+ EXPECT_EQ(4U, value5.first.asUnsigned());
+ EXPECT_EQ(8U, value5.second.asUint16());
ASSERT_NO_THROW(value6 = option->readPrefix(6));
- EXPECT_EQ(48, value6.first.asUnsigned());
+ EXPECT_EQ(48U, value6.first.asUnsigned());
EXPECT_EQ("2001:db8:1::", value6.second.toText());
ASSERT_NO_THROW(value7 = option->readTuple(7));
EXPECT_EQ(value7, "foobar");
// The number of elements should be equal to number of elements
// in the record.
- ASSERT_EQ(9, option->getDataFieldsNum());
+ ASSERT_EQ(9U, option->getDataFieldsNum());
// Check that the default values have been correctly set.
uint16_t value0 = 0;
ASSERT_NO_THROW(value0 = option->readInteger<uint16_t>(0));
- EXPECT_EQ(0, value0);
+ EXPECT_EQ(0U, value0);
bool value1 = true;
ASSERT_NO_THROW(value1 = option->readBoolean(1));
EXPECT_FALSE(value1);
EXPECT_EQ("::", value4.toText());
PSIDTuple value5;
ASSERT_NO_THROW(value5 = option->readPsid(5));
- EXPECT_EQ(0, value5.first.asUnsigned());
- EXPECT_EQ(0, value5.second.asUint16());
+ EXPECT_EQ(0U, value5.first.asUnsigned());
+ EXPECT_EQ(0U, value5.second.asUint16());
PrefixTuple value6(ZERO_PREFIX_TUPLE);
ASSERT_NO_THROW(value6 = option->readPrefix(6));
- EXPECT_EQ(0, value6.first.asUnsigned());
+ EXPECT_EQ(0U, value6.first.asUnsigned());
EXPECT_EQ("::", value6.second.toText());
std::string value7 = "abc";
// Tuple has no default value
EXPECT_THROW(option->readTuple(7), BadDataTypeCast);
uint32_t value8;
ASSERT_NO_THROW(value8 = option->readInteger<uint32_t>(8));
- EXPECT_EQ(0, value8);
+ EXPECT_EQ(0U, value8);
// Override each value with a new value.
ASSERT_NO_THROW(option->writeInteger<uint16_t>(1234, 0));
ASSERT_NO_THROW(option->addArrayDataField<uint32_t>(87654321));
// Check that the new values have been correctly set.
- ASSERT_EQ(10, option->getDataFieldsNum());
+ ASSERT_EQ(10U, option->getDataFieldsNum());
ASSERT_NO_THROW(value0 = option->readInteger<uint16_t>(0));
- EXPECT_EQ(1234, value0);
+ EXPECT_EQ(1234U, value0);
ASSERT_NO_THROW(value1 = option->readBoolean(1));
EXPECT_TRUE(value1);
ASSERT_NO_THROW(value2 = option->readFqdn(2));
ASSERT_NO_THROW(value4 = option->readAddress(4));
EXPECT_EQ("2001:db8:1::100", value4.toText());
ASSERT_NO_THROW(value5 = option->readPsid(5));
- EXPECT_EQ(4, value5.first.asUnsigned());
- EXPECT_EQ(8, value5.second.asUint16());
+ EXPECT_EQ(4U, value5.first.asUnsigned());
+ EXPECT_EQ(8U, value5.second.asUint16());
ASSERT_NO_THROW(value6 = option->readPrefix(6));
- EXPECT_EQ(48, value6.first.asUnsigned());
+ EXPECT_EQ(48U, value6.first.asUnsigned());
EXPECT_EQ("2001:db8:1::", value6.second.toText());
ASSERT_NO_THROW(value7 = option->readTuple(7));
EXPECT_EQ(value7, "foobar");
ASSERT_NO_THROW(value8 = option->readInteger<uint32_t>(8));
- EXPECT_EQ(12345678, value8);
+ EXPECT_EQ(12345678U, value8);
uint32_t value9;
ASSERT_NO_THROW(value9 = option->readInteger<uint32_t>(9));
- EXPECT_EQ(87654321, value9);
+ EXPECT_EQ(87654321U, value9);
}
// The purpose of this test is to verify that pack function for
util::OutputBuffer buf_out(7);
ASSERT_NO_THROW(option->pack(buf_out));
- ASSERT_EQ(9, buf_out.getLength());
+ ASSERT_EQ(9U, buf_out.getLength());
// The original buffer holds the option data but it lacks a header.
// We append data length and option code so as it can be directly
ASSERT_TRUE(option);
// We should have 3 data fields.
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// We expect 3 IPv4 addresses being stored in the option.
for (int i = 0; i < 3; ++i) {
ASSERT_NO_THROW(option->unpack(buf.begin(), buf.end()));
// Now we should have only 2 data fields.
- ASSERT_EQ(2, option->getDataFieldsNum());
+ ASSERT_EQ(2U, option->getDataFieldsNum());
// Verify that the addresses have been overwritten.
for (int i = 0; i < 2; ++i) {
ASSERT_TRUE(option);
// We should have 4 data fields.
- ASSERT_EQ(4, option->getDataFieldsNum());
+ ASSERT_EQ(4U, option->getDataFieldsNum());
// We expect a 16 bit integer
uint16_t value0 = 0;
ASSERT_NO_THROW(value0 = option->readInteger<uint16_t>(0));
- EXPECT_EQ(8712, value0);
+ EXPECT_EQ(8712U, value0);
// ... and 3 IPv4 addresses being stored in the option.
for (int i = 0; i < 3; ++i) {
ASSERT_TRUE(option);
// We should have 3 data fields.
- ASSERT_EQ(3, option->getDataFieldsNum());
+ ASSERT_EQ(3U, option->getDataFieldsNum());
// We expect 3 IPv6 addresses being stored in the option.
for (int i = 0; i < 3; ++i) {
ASSERT_NO_THROW(option->initialize(buf.begin(), buf.end()));
// Now we should have only 2 data fields.
- ASSERT_EQ(2, option->getDataFieldsNum());
+ ASSERT_EQ(2U, option->getDataFieldsNum());
// Check that it has been replaced.
for (int i = 0; i < 2; ++i) {
// correct number of labels in the domain name specified as a string
// parameter.
TEST_F(OptionDataTypesTest, getLabelCount) {
- EXPECT_EQ(0, OptionDataTypeUtil::getLabelCount(""));
- EXPECT_EQ(1, OptionDataTypeUtil::getLabelCount("."));
- EXPECT_EQ(2, OptionDataTypeUtil::getLabelCount("example"));
- EXPECT_EQ(3, OptionDataTypeUtil::getLabelCount("example.com"));
- EXPECT_EQ(3, OptionDataTypeUtil::getLabelCount("example.com."));
- EXPECT_EQ(4, OptionDataTypeUtil::getLabelCount("myhost.example.com"));
+ EXPECT_EQ(0U, OptionDataTypeUtil::getLabelCount(""));
+ EXPECT_EQ(1U, OptionDataTypeUtil::getLabelCount("."));
+ EXPECT_EQ(2U, OptionDataTypeUtil::getLabelCount("example"));
+ EXPECT_EQ(3U, OptionDataTypeUtil::getLabelCount("example.com"));
+ EXPECT_EQ(3U, OptionDataTypeUtil::getLabelCount("example.com."));
+ EXPECT_EQ(4U, OptionDataTypeUtil::getLabelCount("myhost.example.com"));
EXPECT_THROW(OptionDataTypeUtil::getLabelCount(".abc."),
isc::dhcp::BadDataTypeCast);
}
// Do similar test for IPv4 address.
address = asiolink::IOAddress("192.168.0.1");
ASSERT_NO_THROW(OptionDataTypeUtil::writeAddress(address, buf_out));
- ASSERT_EQ(4, buf_out.size());
+ ASSERT_EQ(4U, buf_out.size());
// Verify that the IP address has been written correctly.
- EXPECT_EQ(192, buf_out[0]);
- EXPECT_EQ(168, buf_out[1]);
- EXPECT_EQ(0, buf_out[2]);
- EXPECT_EQ(1, buf_out[3]);
+ EXPECT_EQ(192U, buf_out[0]);
+ EXPECT_EQ(168U, buf_out[1]);
+ EXPECT_EQ(0U, buf_out[2]);
+ EXPECT_EQ(1U, buf_out[3]);
}
// The purpose of this test is to verify that binary data represented
// Write the 'true' value to the buffer.
ASSERT_NO_THROW(OptionDataTypeUtil::writeBool(true, buf));
// We should now have 'true' value stored in a buffer.
- ASSERT_EQ(1, buf.size());
- EXPECT_EQ(buf[0], 1);
+ ASSERT_EQ(1U, buf.size());
+ EXPECT_EQ(buf[0], 1U);
// Let's append another value to make sure that it is not always
// 'true' value being written.
ASSERT_NO_THROW(OptionDataTypeUtil::writeBool(false, buf));
- ASSERT_EQ(2, buf.size());
+ ASSERT_EQ(2U, buf.size());
// Check that the first value has not changed.
- EXPECT_EQ(buf[0], 1);
+ EXPECT_EQ(buf[0], 1U);
// Check the second value is correct.
- EXPECT_EQ(buf[1], 0);
+ EXPECT_EQ(buf[1], 0U);
}
// The purpose of this test is to verify that the integer values
ASSERT_NO_THROW(
valueUint8 = OptionDataTypeUtil::readInt<uint8_t>(buf);
);
- EXPECT_EQ(129, valueUint8);
+ EXPECT_EQ(129U, valueUint8);
// Try to read 16-bit value from a buffer holding 8-bit value.
// This should result in an exception.
ASSERT_NO_THROW(
valueUint16 = OptionDataTypeUtil::readInt<uint16_t>(buf);
);
- EXPECT_EQ(1234, valueUint16);
+ EXPECT_EQ(1234U, valueUint16);
// Try to read 32-bit value from a buffer holding 16-bit value.
// This should result in an exception.
ASSERT_NO_THROW(
valueUint32 = OptionDataTypeUtil::readInt<uint32_t>(buf);
);
- EXPECT_EQ(56789, valueUint32);
+ EXPECT_EQ(56789U, valueUint32);
buf.clear();
// Test int8_t value.
// 7 bytes for "example" label, 3 bytes for "com" label and
// finally 4 bytes positions between labels where length
// information is stored.
- ASSERT_EQ(22, buf.size());
+ ASSERT_EQ(22U, buf.size());
// Verify that length fields between labels hold valid values.
- EXPECT_EQ(8, buf[0]); // length of "mydomain"
- EXPECT_EQ(7, buf[9]); // length of "example"
- EXPECT_EQ(3, buf[17]); // length of "com"
- EXPECT_EQ(0, buf[21]); // zero byte at the end.
+ EXPECT_EQ(8U, buf[0]); // length of "mydomain"
+ EXPECT_EQ(7U, buf[9]); // length of "example"
+ EXPECT_EQ(3U, buf[17]); // length of "com"
+ EXPECT_EQ(0U, buf[21]); // zero byte at the end.
// Verify that labels are valid.
std::string label0(buf.begin() + 1, buf.begin() + 9);
OptionDataTypeUtil::writeFqdn("hello.net", buf);
// The buffer length should be now longer.
- ASSERT_EQ(33, buf.size());
+ ASSERT_EQ(33U, buf.size());
// Check the length fields for new labels being appended.
- EXPECT_EQ(5, buf[22]);
- EXPECT_EQ(3, buf[28]);
+ EXPECT_EQ(5U, buf[22]);
+ EXPECT_EQ(3U, buf[28]);
// And check that labels are ok.
std::string label3(buf.begin() + 23, buf.begin() + 28);
PrefixTuple prefix(ZERO_PREFIX_TUPLE);
ASSERT_NO_THROW(prefix = OptionDataTypeUtil::readPrefix(buf));
- EXPECT_EQ(64, prefix.first.asUnsigned());
+ EXPECT_EQ(64U, prefix.first.asUnsigned());
EXPECT_EQ("2001:db8::", prefix.second.toText());
buf.clear();
writeInt<uint32_t>(0, buf);
ASSERT_NO_THROW(prefix = OptionDataTypeUtil::readPrefix(buf));
- EXPECT_EQ(63, prefix.first.asUnsigned());
+ EXPECT_EQ(63U, prefix.first.asUnsigned());
EXPECT_EQ("2001:db8::", prefix.second.toText());
buf.clear();
writeInt<uint32_t>(0xFFFFFFFF, buf);
ASSERT_NO_THROW(prefix = OptionDataTypeUtil::readPrefix(buf));
- EXPECT_EQ(34, prefix.first.asUnsigned());
+ EXPECT_EQ(34U, prefix.first.asUnsigned());
EXPECT_EQ("2001:db8:c000::", prefix.second.toText());
buf.clear();
writeInt<uint16_t>(0x2001, buf);
ASSERT_NO_THROW(prefix = OptionDataTypeUtil::readPrefix(buf));
- EXPECT_EQ(0, prefix.first.asUnsigned());
+ EXPECT_EQ(0U, prefix.first.asUnsigned());
EXPECT_EQ("::", prefix.second.toText());
buf.clear();
buf.insert(buf.end(), 16, 0x11);
ASSERT_NO_THROW(prefix = OptionDataTypeUtil::readPrefix(buf));
- EXPECT_EQ(128, prefix.first.asUnsigned());
+ EXPECT_EQ(128U, prefix.first.asUnsigned());
EXPECT_EQ("1111:1111:1111:1111:1111:1111:1111:1111",
prefix.second.toText());
ASSERT_NO_THROW(OptionDataTypeUtil::writePrefix(PrefixLen(34),
IOAddress("2001:db8:FFFF::"),
buf));
- ASSERT_EQ(7, buf.size());
+ ASSERT_EQ(7U, buf.size());
- EXPECT_EQ(1, static_cast<unsigned>(buf[0]));
- EXPECT_EQ(34, static_cast<unsigned>(buf[1]));
- EXPECT_EQ(0x20, static_cast<unsigned>(buf[2]));
- EXPECT_EQ(0x01, static_cast<unsigned>(buf[3]));
- EXPECT_EQ(0x0D, static_cast<unsigned>(buf[4]));
- EXPECT_EQ(0xB8, static_cast<unsigned>(buf[5]));
- EXPECT_EQ(0xC0, static_cast<unsigned>(buf[6]));
+ EXPECT_EQ(1U, static_cast<unsigned>(buf[0]));
+ EXPECT_EQ(34U, static_cast<unsigned>(buf[1]));
+ EXPECT_EQ(0x20U, static_cast<unsigned>(buf[2]));
+ EXPECT_EQ(0x01U, static_cast<unsigned>(buf[3]));
+ EXPECT_EQ(0x0DU, static_cast<unsigned>(buf[4]));
+ EXPECT_EQ(0xB8U, static_cast<unsigned>(buf[5]));
+ EXPECT_EQ(0xC0U, static_cast<unsigned>(buf[6]));
buf.clear();
ASSERT_NO_THROW(OptionDataTypeUtil::writePrefix(PrefixLen(0),
IOAddress("2001:db8:FFFF::"),
buf));
- ASSERT_EQ(1, buf.size());
- EXPECT_EQ(0, static_cast<unsigned>(buf[0]));
+ ASSERT_EQ(1U, buf.size());
+ EXPECT_EQ(0U, static_cast<unsigned>(buf[0]));
buf.clear();
// We should now have a 17 bytes long buffer. 1 byte goes for a prefix
// length field, the remaining ones hold the prefix.
- ASSERT_EQ(17, buf.size());
+ ASSERT_EQ(17U, buf.size());
// Because the prefix is 16 bytes long, we can simply use the
// IOAddress convenience function to read it back and compare
// it with the textual representation. This is simpler than
PSIDTuple psid;
ASSERT_NO_THROW(psid = OptionDataTypeUtil::readPsid(buf));
- EXPECT_EQ(6, psid.first.asUnsigned());
- EXPECT_EQ(0x29, psid.second.asUint16());
+ EXPECT_EQ(6U, psid.first.asUnsigned());
+ EXPECT_EQ(0x29U, psid.second.asUint16());
buf.clear();
writeInt<uint16_t>(0xF000, buf);
ASSERT_NO_THROW(psid = OptionDataTypeUtil::readPsid(buf));
- EXPECT_EQ(16, psid.first.asUnsigned());
- EXPECT_EQ(0xF000, psid.second.asUint16());
+ EXPECT_EQ(16U, psid.first.asUnsigned());
+ EXPECT_EQ(0xF000U, psid.second.asUint16());
buf.clear();
// be ignored.
writeInt<uint16_t>(0x1234, buf);
ASSERT_NO_THROW(psid = OptionDataTypeUtil::readPsid(buf));
- EXPECT_EQ(0, psid.first.asUnsigned());
- EXPECT_EQ(0, psid.second.asUint16());
+ EXPECT_EQ(0U, psid.first.asUnsigned());
+ EXPECT_EQ(0U, psid.second.asUint16());
buf.clear();
std::vector<uint8_t> buf(1, 1);
// PSID length is 4 (bits), PSID value is 8.
ASSERT_NO_THROW(OptionDataTypeUtil::writePsid(PSIDLen(4), PSID(8), buf));
- ASSERT_EQ(4, buf.size());
+ ASSERT_EQ(4U, buf.size());
// The byte which existed in the buffer should still hold the
// same value.
- EXPECT_EQ(1, static_cast<unsigned>(buf[0]));
+ EXPECT_EQ(1U, static_cast<unsigned>(buf[0]));
// PSID length should be written as specified in the function call.
- EXPECT_EQ(4, static_cast<unsigned>(buf[1]));
+ EXPECT_EQ(4U, static_cast<unsigned>(buf[1]));
// The PSID structure is as follows:
// UUUUPPPPPPPPPPPP, where "U" are useful bits on which we code
// the PSID. "P" are zero padded bits. The PSID value 8 is coded
// on four useful bits as '1000b'. That means that the PSID value
// encoded in the PSID field is: '1000000000000000b', which is
// 0x8000. The next two EXPECT_EQ statements verify that.
- EXPECT_EQ(0x80, static_cast<unsigned>(buf[2]));
- EXPECT_EQ(0x00, static_cast<unsigned>(buf[3]));
+ EXPECT_EQ(0x80U, static_cast<unsigned>(buf[2]));
+ EXPECT_EQ(0x00U, static_cast<unsigned>(buf[3]));
// Clear the buffer to make sure we don't append to the
// existing data.
// The PSID length of 0 causes the PSID value (of 6) to be ignored.
// As a result, the buffer should hold only zeros.
ASSERT_NO_THROW(OptionDataTypeUtil::writePsid(PSIDLen(0), PSID(6), buf));
- ASSERT_EQ(3, buf.size());
- EXPECT_EQ(0, static_cast<unsigned>(buf[0]));
- EXPECT_EQ(0, static_cast<unsigned>(buf[1]));
- EXPECT_EQ(0, static_cast<unsigned>(buf[2]));
+ ASSERT_EQ(3U, buf.size());
+ EXPECT_EQ(0U, static_cast<unsigned>(buf[0]));
+ EXPECT_EQ(0U, static_cast<unsigned>(buf[1]));
+ EXPECT_EQ(0U, static_cast<unsigned>(buf[2]));
buf.clear();
// Another test case, to verify that we can use the maximum length
// of PSID (16 bits).
ASSERT_NO_THROW(OptionDataTypeUtil::writePsid(PSIDLen(16), PSID(5), buf));
- ASSERT_EQ(3, buf.size());
+ ASSERT_EQ(3U, buf.size());
// PSID length should be written with no change.
- EXPECT_EQ(16, static_cast<unsigned>(buf[0]));
+ EXPECT_EQ(16U, static_cast<unsigned>(buf[0]));
// Check PSID value.
- EXPECT_EQ(0x00, static_cast<unsigned>(buf[1]));
- EXPECT_EQ(0x05, static_cast<unsigned>(buf[2]));
+ EXPECT_EQ(0x00U, static_cast<unsigned>(buf[1]));
+ EXPECT_EQ(0x05U, static_cast<unsigned>(buf[2]));
// PSID length of 17 exceeds the maximum allowed value of 16.
EXPECT_THROW(OptionDataTypeUtil::writePsid(PSIDLen(17), PSID(1), buf),
// One trailing null should trim off.
buffer = {'o', 'n', 'e', 0 };
ASSERT_NO_THROW(value = OptionDataTypeUtil::readString(buffer));
- EXPECT_EQ(3, value.length());
+ EXPECT_EQ(3U, value.length());
EXPECT_EQ(value, std::string("one"));
// More than one trailing null should trim off.
buffer = { 't', 'h', 'r', 'e', 'e', 0, 0, 0 };
ASSERT_NO_THROW(value = OptionDataTypeUtil::readString(buffer));
- EXPECT_EQ(5, value.length());
+ EXPECT_EQ(5U, value.length());
EXPECT_EQ(value, std::string("three"));
// Embedded null should be left in place.
buffer = { 'e', 'm', 0, 'b', 'e', 'd' };
ASSERT_NO_THROW(value = OptionDataTypeUtil::readString(buffer));
- EXPECT_EQ(6, value.length());
+ EXPECT_EQ(6U, value.length());
EXPECT_EQ(value, (std::string{"em\0bed", 6}));
// Leading null should be left in place.
buffer = { 0, 'l', 'e', 'a', 'd', 'i', 'n', 'g' };
ASSERT_NO_THROW(value = OptionDataTypeUtil::readString(buffer));
- EXPECT_EQ(8, value.length());
+ EXPECT_EQ(8U, value.length());
EXPECT_EQ(value, (std::string{"\0leading", 8}));
}
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(1U, opt_def1.getCode());
EXPECT_EQ(DHCP6_OPTION_SPACE, opt_def1.getOptionSpaceName());
EXPECT_EQ(OPT_STRING_TYPE, opt_def1.getType());
EXPECT_FALSE(opt_def1.getArrayType());
OptionDefinition opt_def2("OPTION_RAPID_COMMIT", D6O_RAPID_COMMIT,
DHCP6_OPTION_SPACE, OPT_EMPTY_TYPE);
EXPECT_EQ("OPTION_RAPID_COMMIT", opt_def2.getName());
- EXPECT_EQ(14, opt_def2.getCode());
+ EXPECT_EQ(14U, opt_def2.getCode());
EXPECT_EQ(DHCP6_OPTION_SPACE, opt_def2.getOptionSpaceName());
EXPECT_EQ(OPT_EMPTY_TYPE, opt_def2.getType());
EXPECT_FALSE(opt_def2.getArrayType());
OPT_IPV6_ADDRESS_TYPE,
true);
EXPECT_EQ("OPTION_NIS_SERVERS", opt_def5.getName());
- EXPECT_EQ(27, opt_def5.getCode());
+ EXPECT_EQ(27U, 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());
OptionDefinition opt_def_copy(opt_def);
EXPECT_EQ("option-foo", opt_def_copy.getName());
- EXPECT_EQ(27, opt_def_copy.getCode());
+ EXPECT_EQ(27U, 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());
const OptionDefinition::RecordFieldsCollection fields =
opt_def_copy.getRecordFields();
- ASSERT_EQ(2, fields.size());
+ ASSERT_EQ(2U, fields.size());
EXPECT_EQ(OPT_UINT16_TYPE, fields[0]);
EXPECT_EQ(OPT_STRING_TYPE, fields[1]);
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(30U, 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());
ASSERT_TRUE(def);
EXPECT_EQ("option-foo", def->getName());
- EXPECT_EQ(123, def->getCode());
+ EXPECT_EQ(123U, def->getCode());
EXPECT_EQ("my-space", def->getOptionSpaceName());
EXPECT_EQ(OPT_UINT16_TYPE, def->getType());
EXPECT_FALSE(def->getArrayType());
ASSERT_TRUE(def);
EXPECT_EQ("option-foo", def->getName());
- EXPECT_EQ(123, def->getCode());
+ EXPECT_EQ(123U, def->getCode());
EXPECT_EQ("my-space", def->getOptionSpaceName());
EXPECT_EQ(OPT_UINT16_TYPE, def->getType());
EXPECT_FALSE(def->getArrayType());
ASSERT_TRUE(def);
EXPECT_EQ("option-foo", def->getName());
- EXPECT_EQ(123, def->getCode());
+ EXPECT_EQ(123U, def->getCode());
EXPECT_EQ("my-space", def->getOptionSpaceName());
EXPECT_EQ(OPT_UINT16_TYPE, def->getType());
EXPECT_TRUE(def->getArrayType());
ASSERT_TRUE(def);
EXPECT_EQ("option-foo", def->getName());
- EXPECT_EQ(123, def->getCode());
+ EXPECT_EQ(123U, def->getCode());
EXPECT_EQ("my-space", def->getOptionSpaceName());
EXPECT_EQ(OPT_UINT16_TYPE, def->getType());
EXPECT_TRUE(def->getArrayType());
// Check what we have actually added.
OptionDefinition::RecordFieldsCollection fields = opt_def.getRecordFields();
- ASSERT_EQ(3, fields.size());
+ ASSERT_EQ(3U, fields.size());
EXPECT_EQ(OPT_IPV6_ADDRESS_TYPE, fields[0]);
EXPECT_EQ(OPT_UINT32_TYPE, fields[1]);
EXPECT_EQ(OPT_UINT32_TYPE, fields[2]);
ASSERT_TRUE(typeid(*optptr) == typeid(Option));
// Expect 'empty' DHCPv6 option.
EXPECT_EQ(Option::V6, option_v6->getUniverse());
- EXPECT_EQ(4, option_v6->getHeaderLen());
- EXPECT_EQ(0, option_v6->getData().size());
+ EXPECT_EQ(4U, option_v6->getHeaderLen());
+ EXPECT_EQ(0U, option_v6->getData().size());
// Repeat the same test scenario for DHCPv4 option.
OptionPtr option_v4;
ASSERT_NO_THROW(option_v4 = opt_def.optionFactory(Option::V4, 214, OptionBuffer()));
// Expect 'empty' DHCPv4 option.
EXPECT_EQ(Option::V4, option_v4->getUniverse());
- EXPECT_EQ(2, option_v4->getHeaderLen());
- EXPECT_EQ(0, option_v4->getData().size());
+ EXPECT_EQ(2U, option_v4->getHeaderLen());
+ EXPECT_EQ(0U, option_v4->getData().size());
}
// The purpose of this test is to verify that when the empty option encapsulates
ASSERT_TRUE(typeid(*optptr) == typeid(OptionCustom));
// Sanity-check length, universe etc.
EXPECT_EQ(Option::V6, option_v6->getUniverse());
- EXPECT_EQ(4, option_v6->getHeaderLen());
+ EXPECT_EQ(4U, option_v6->getHeaderLen());
// This option should have one suboption with the code of 1025.
OptionPtr subopt_v6 = option_v6->getOption(1025);
EXPECT_TRUE(subopt_v6);
// Check that this suboption holds valid data.
- EXPECT_EQ(1025, subopt_v6->getType());
+ EXPECT_EQ(1025U, subopt_v6->getType());
EXPECT_EQ(Option::V6, subopt_v6->getUniverse());
EXPECT_EQ(0, memcmp(&subopt_v6->getData()[0], subopt_data + 4, 4));
// Sanity check on universe, length and size. These are
// the basic parameters identifying any option.
EXPECT_EQ(Option::V6, option_v6->getUniverse());
- EXPECT_EQ(4, option_v6->getHeaderLen());
+ EXPECT_EQ(4U, option_v6->getHeaderLen());
ASSERT_EQ(buf.size(), option_v6->getData().size());
// Get the server id data from the option and compare
ASSERT_NO_THROW(option_v4 = opt_def.optionFactory(Option::V4, 214, buf));
// Expect 'empty' DHCPv4 option.
EXPECT_EQ(Option::V4, option_v4->getUniverse());
- EXPECT_EQ(2, option_v4->getHeaderLen());
+ EXPECT_EQ(2U, option_v4->getHeaderLen());
ASSERT_EQ(buf.size(), option_v4->getData().size());
EXPECT_TRUE(std::equal(option_v6->getData().begin(),
ASSERT_TRUE(typeid(*optptr) == typeid(Option6IA));
boost::shared_ptr<Option6IA> option_cast_v6 =
boost::static_pointer_cast<Option6IA>(option_v6);
- EXPECT_EQ(0x00010203, option_cast_v6->getIAID());
- EXPECT_EQ(0x04050607, option_cast_v6->getT1());
- EXPECT_EQ(0x08090A0B, option_cast_v6->getT2());
+ EXPECT_EQ(0x00010203U, option_cast_v6->getIAID());
+ EXPECT_EQ(0x04050607U, option_cast_v6->getT1());
+ EXPECT_EQ(0x08090A0BU, option_cast_v6->getT2());
// The length of the buffer must be at least 12 bytes.
// Check too short buffer.
boost::shared_ptr<Option6IAAddr> option_cast_v6 =
boost::static_pointer_cast<Option6IAAddr>(option_v6);
EXPECT_EQ(addr_v6, option_cast_v6->getAddress());
- EXPECT_EQ(0x00010203, option_cast_v6->getPreferred());
- EXPECT_EQ(0x04050607, option_cast_v6->getValid());
+ EXPECT_EQ(0x00010203U, option_cast_v6->getPreferred());
+ EXPECT_EQ(0x04050607U, option_cast_v6->getValid());
// The length of the buffer must be at least 12 bytes.
// Check too short buffer.
boost::shared_ptr<Option6IAAddr> option_cast_v6 =
boost::static_pointer_cast<Option6IAAddr>(option_v6);
EXPECT_EQ("2001:db8::ff00:42:8329", option_cast_v6->getAddress().toText());
- EXPECT_EQ(1234, option_cast_v6->getPreferred());
- EXPECT_EQ(5678, option_cast_v6->getValid());
+ EXPECT_EQ(1234U, option_cast_v6->getPreferred());
+ EXPECT_EQ(5678U, option_cast_v6->getValid());
}
// The purpose of this test is to verify that the definition for option
// Validate the value.
boost::shared_ptr<OptionInt<uint8_t> > option_cast_v6 =
boost::static_pointer_cast<OptionInt<uint8_t> >(option_v6);
- EXPECT_EQ(1, option_cast_v6->getValue());
+ EXPECT_EQ(1U, option_cast_v6->getValue());
// Try to provide zero-length buffer. Expect exception.
EXPECT_THROW(
// Validate the value.
boost::shared_ptr<OptionInt<uint8_t> > option_cast_v6 =
boost::static_pointer_cast<OptionInt<uint8_t> >(option_v6);
- EXPECT_EQ(123, option_cast_v6->getValue());
+ EXPECT_EQ(123U, option_cast_v6->getValue());
// @todo Add more cases for DHCPv4
}
// Validate the value.
boost::shared_ptr<OptionInt<uint16_t> > option_cast_v6 =
boost::static_pointer_cast<OptionInt<uint16_t> >(option_v6);
- EXPECT_EQ(0x0102, option_cast_v6->getValue());
+ EXPECT_EQ(0x0102U, option_cast_v6->getValue());
// Try to provide zero-length buffer. Expect exception.
EXPECT_THROW(
// Validate the value.
boost::shared_ptr<OptionInt<uint16_t> > option_cast_v6 =
boost::static_pointer_cast<OptionInt<uint16_t> >(option_v6);
- EXPECT_EQ(1234, option_cast_v6->getValue());
+ EXPECT_EQ(1234U, option_cast_v6->getValue());
// @todo Add more cases for DHCPv4
// Validate the value.
boost::shared_ptr<OptionInt<uint32_t> > option_cast_v6 =
boost::static_pointer_cast<OptionInt<uint32_t> >(option_v6);
- EXPECT_EQ(0x01020304, option_cast_v6->getValue());
+ EXPECT_EQ(0x01020304U, option_cast_v6->getValue());
// Try to provide too short buffer. Expect exception.
EXPECT_THROW(
// Validate the value.
boost::shared_ptr<OptionInt<uint32_t> > option_cast_v6 =
boost::static_pointer_cast<OptionInt<uint32_t> >(option_v6);
- EXPECT_EQ(123456, option_cast_v6->getValue());
+ EXPECT_EQ(123456U, option_cast_v6->getValue());
// @todo Add more cases for DHCPv4
}
boost::static_pointer_cast<OptionIntArray<uint16_t> >(option_v6);
// Get the values from the initiated options and validate.
std::vector<uint16_t> values = option_cast_v6->getValues();
- EXPECT_EQ(12345, values[0]);
- EXPECT_EQ(5679, values[1]);
- EXPECT_EQ(12, values[2]);
+ EXPECT_EQ(12345U, values[0]);
+ EXPECT_EQ(5679U, values[1]);
+ EXPECT_EQ(12U, values[2]);
}
// The purpose of this test is to verify that definition for option that
boost::static_pointer_cast<OptionIntArray<uint32_t> >(option_v6);
// Get the values from the initiated options and validate.
std::vector<uint32_t> values = option_cast_v6->getValues();
- EXPECT_EQ(123456, values[0]);
- EXPECT_EQ(7, values[1]);
- EXPECT_EQ(256, values[2]);
- EXPECT_EQ(1111, values[3]);
+ EXPECT_EQ(123456U, values[0]);
+ EXPECT_EQ(7U, values[1]);
+ EXPECT_EQ(256U, values[2]);
+ EXPECT_EQ(1111U, values[3]);
}
// The purpose of this test is to verify that the definition can be created
// Validate the value.
OptionCustomPtr option_cast_v6 =
boost::dynamic_pointer_cast<OptionCustom>(option_v6);
- ASSERT_EQ(1, option_cast_v6->getDataFieldsNum());
+ ASSERT_EQ(1U, option_cast_v6->getDataFieldsNum());
PrefixTuple prefix = option_cast_v6->readPrefix();
- EXPECT_EQ(32, prefix.first.asUnsigned());
+ EXPECT_EQ(32U, prefix.first.asUnsigned());
EXPECT_EQ("3000::", prefix.second.toText());
}
// Validate the value.
OptionCustomPtr option_cast_v6 =
boost::dynamic_pointer_cast<OptionCustom>(option_v6);
- ASSERT_EQ(1, option_cast_v6->getDataFieldsNum());
+ ASSERT_EQ(1U, option_cast_v6->getDataFieldsNum());
PrefixTuple prefix = option_cast_v6->readPrefix();
- EXPECT_EQ(64, prefix.first.asUnsigned());
+ EXPECT_EQ(64U, prefix.first.asUnsigned());
EXPECT_EQ("2001:db8:1::", prefix.second.toText());
}
boost::dynamic_pointer_cast<OptionCustom>(option_v6);
// There should be 3 prefixes in this option.
- ASSERT_EQ(3, option_cast_v6->getDataFieldsNum());
+ ASSERT_EQ(3U, option_cast_v6->getDataFieldsNum());
ASSERT_NO_THROW({
PrefixTuple prefix0 = option_cast_v6->readPrefix(0);
- EXPECT_EQ(64, prefix0.first.asUnsigned());
+ EXPECT_EQ(64U, prefix0.first.asUnsigned());
EXPECT_EQ("2001:db8:1::", prefix0.second.toText());
});
ASSERT_NO_THROW({
PrefixTuple prefix1 = option_cast_v6->readPrefix(1);
- EXPECT_EQ(32, prefix1.first.asUnsigned());
+ EXPECT_EQ(32U, prefix1.first.asUnsigned());
EXPECT_EQ("3000::", prefix1.second.toText());
});
ASSERT_NO_THROW({
PrefixTuple prefix2 = option_cast_v6->readPrefix(2);
- EXPECT_EQ(48, prefix2.first.asUnsigned());
+ EXPECT_EQ(48U, prefix2.first.asUnsigned());
EXPECT_EQ("3001:1::", prefix2.second.toText());
});
}
// Validate the value.
OptionCustomPtr option_cast_v6 =
boost::dynamic_pointer_cast<OptionCustom>(option_v6);
- ASSERT_EQ(1, option_cast_v6->getDataFieldsNum());
+ ASSERT_EQ(1U, option_cast_v6->getDataFieldsNum());
PSIDTuple psid = option_cast_v6->readPsid();
- EXPECT_EQ(6, psid.first.asUnsigned());
- EXPECT_EQ(1, psid.second.asUint16());
+ EXPECT_EQ(6U, psid.first.asUnsigned());
+ EXPECT_EQ(1U, psid.second.asUint16());
}
// This test verifies that a definition of an option with a single PSID
// Validate the value.
OptionCustomPtr option_cast_v6 =
boost::dynamic_pointer_cast<OptionCustom>(option_v6);
- ASSERT_EQ(1, option_cast_v6->getDataFieldsNum());
+ ASSERT_EQ(1U, option_cast_v6->getDataFieldsNum());
PSIDTuple psid = option_cast_v6->readPsid();
- EXPECT_EQ(6, psid.first.asUnsigned());
- EXPECT_EQ(3, psid.second.asUint16());
+ EXPECT_EQ(6U, psid.first.asUnsigned());
+ EXPECT_EQ(3U, psid.second.asUint16());
}
// This test verifies that a definition of an option with an array
boost::dynamic_pointer_cast<OptionCustom>(option_v6);
// There should be 3 PSIDs in this option.
- ASSERT_EQ(3, option_cast_v6->getDataFieldsNum());
+ ASSERT_EQ(3U, option_cast_v6->getDataFieldsNum());
// Check their values.
PSIDTuple psid0;
PSIDTuple psid2;
psid0 = option_cast_v6->readPsid(0);
- EXPECT_EQ(6, psid0.first.asUnsigned());
- EXPECT_EQ(3, psid0.second.asUint16());
+ EXPECT_EQ(6U, psid0.first.asUnsigned());
+ EXPECT_EQ(3U, psid0.second.asUint16());
psid1 = option_cast_v6->readPsid(1);
- EXPECT_EQ(1, psid1.first.asUnsigned());
- EXPECT_EQ(0, psid1.second.asUint16());
+ EXPECT_EQ(1U, psid1.first.asUnsigned());
+ EXPECT_EQ(0U, psid1.second.asUint16());
psid2 = option_cast_v6->readPsid(2);
- EXPECT_EQ(3, psid2.first.asUnsigned());
- EXPECT_EQ(7, psid2.second.asUint16());
+ EXPECT_EQ(3U, psid2.first.asUnsigned());
+ EXPECT_EQ(7U, psid2.second.asUint16());
}
// This test verifies that a definition of an option with a single DHCPv4
// Validate the value.
OptionCustomPtr option_cast =
boost::dynamic_pointer_cast<OptionCustom>(option);
- ASSERT_EQ(1, option_cast->getDataFieldsNum());
+ ASSERT_EQ(1U, option_cast->getDataFieldsNum());
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
ASSERT_NO_THROW(option_cast->readTuple(tuple));
EXPECT_EQ("foobar", tuple.getText());
// Validate the value.
OptionCustomPtr option_cast =
boost::dynamic_pointer_cast<OptionCustom>(option);
- ASSERT_EQ(1, option_cast->getDataFieldsNum());
+ ASSERT_EQ(1U, option_cast->getDataFieldsNum());
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
ASSERT_NO_THROW(option_cast->readTuple(tuple));
EXPECT_EQ("foobar", tuple.getText());
// Validate the value.
OptionCustomPtr option_cast =
boost::dynamic_pointer_cast<OptionCustom>(option);
- ASSERT_EQ(1, option_cast->getDataFieldsNum());
+ ASSERT_EQ(1U, option_cast->getDataFieldsNum());
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
ASSERT_NO_THROW(option_cast->readTuple(tuple));
EXPECT_EQ("foobar", tuple.getText());
// Validate the value.
OptionCustomPtr option_cast =
boost::dynamic_pointer_cast<OptionCustom>(option);
- ASSERT_EQ(1, option_cast->getDataFieldsNum());
+ ASSERT_EQ(1U, option_cast->getDataFieldsNum());
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
ASSERT_NO_THROW(option_cast->readTuple(tuple));
EXPECT_EQ("foobar", tuple.getText());
boost::dynamic_pointer_cast<OptionOpaqueDataTuples>(option);
// There should be 3 tuples in this option.
- ASSERT_EQ(3, option_cast->getTuplesNum());
+ ASSERT_EQ(3U, option_cast->getTuplesNum());
// Check their values.
OpaqueDataTuple tuple0 = option_cast->getTuple(0);
boost::dynamic_pointer_cast<OptionOpaqueDataTuples>(option);
// There should be 3 tuples in this option.
- ASSERT_EQ(3, option_cast->getTuplesNum());
+ ASSERT_EQ(3U, option_cast->getTuplesNum());
// Check their values.
OpaqueDataTuple tuple0 = option_cast->getTuple(0);
auto dnr_instances = option_cast->getDnrInstances();
// Only one DNR instance is expected.
- ASSERT_EQ(1, dnr_instances.size());
+ ASSERT_EQ(1U, dnr_instances.size());
DnrInstance& dnr = dnr_instances[0];
- ASSERT_EQ(26, dnr.getDnrInstanceDataLength());
- ASSERT_EQ(1234, dnr.getServicePriority());
+ ASSERT_EQ(26U, dnr.getDnrInstanceDataLength());
+ ASSERT_EQ(1234U, dnr.getServicePriority());
ASSERT_EQ(true, dnr.isAdnOnlyMode());
ASSERT_EQ("example.some.host.org.", dnr.getAdnAsText());
- ASSERT_EQ(23, dnr.getAdnLength());
- ASSERT_EQ(0, dnr.getAddrLength());
- ASSERT_EQ(0, dnr.getSvcParamsLength());
+ ASSERT_EQ(23U, dnr.getAdnLength());
+ ASSERT_EQ(0U, dnr.getAddrLength());
+ ASSERT_EQ(0U, dnr.getSvcParamsLength());
}
// The purpose of this test is to verify that definition can be created
auto dnr_instances = option_cast->getDnrInstances();
// Two DNR instances are expected.
- ASSERT_EQ(2, dnr_instances.size());
+ ASSERT_EQ(2U, dnr_instances.size());
// Let's check 1st DNR instance.
DnrInstance& dnr_1 = dnr_instances[0];
- ASSERT_EQ(53, dnr_1.getDnrInstanceDataLength());
- ASSERT_EQ(1234, dnr_1.getServicePriority());
+ ASSERT_EQ(53U, dnr_1.getDnrInstanceDataLength());
+ ASSERT_EQ(1234U, dnr_1.getServicePriority());
ASSERT_EQ(false, dnr_1.isAdnOnlyMode());
- ASSERT_EQ(23, dnr_1.getAdnLength());
+ ASSERT_EQ(23U, dnr_1.getAdnLength());
ASSERT_EQ("example.some.host.org.", dnr_1.getAdnAsText());
- ASSERT_EQ(8, dnr_1.getAddrLength());
- ASSERT_EQ(18, dnr_1.getSvcParamsLength());
+ ASSERT_EQ(8U, dnr_1.getAddrLength());
+ ASSERT_EQ(18U, dnr_1.getSvcParamsLength());
auto addresses_1 = dnr_1.getAddresses();
- ASSERT_EQ(2, addresses_1.size());
+ ASSERT_EQ(2U, addresses_1.size());
ASSERT_EQ("192.168.0.1", addresses_1[0].toText());
ASSERT_EQ("192.168.0.2", addresses_1[1].toText());
// Let's check 2nd DNR instance.
DnrInstance& dnr_2 = dnr_instances[1];
- ASSERT_EQ(60, dnr_2.getDnrInstanceDataLength());
- ASSERT_EQ(4321, dnr_2.getServicePriority());
+ ASSERT_EQ(60U, dnr_2.getDnrInstanceDataLength());
+ ASSERT_EQ(4321U, dnr_2.getServicePriority());
ASSERT_EQ(false, dnr_2.isAdnOnlyMode());
- ASSERT_EQ(21, dnr_2.getAdnLength());
+ ASSERT_EQ(21U, dnr_2.getAdnLength());
ASSERT_EQ("myhost1.example.com.", dnr_2.getAdnAsText());
- ASSERT_EQ(8, dnr_2.getAddrLength());
- ASSERT_EQ(27, dnr_2.getSvcParamsLength());
+ ASSERT_EQ(8U, dnr_2.getAddrLength());
+ ASSERT_EQ(27U, dnr_2.getSvcParamsLength());
auto addresses_2 = dnr_2.getAddresses();
- ASSERT_EQ(2, addresses_2.size());
+ ASSERT_EQ(2U, addresses_2.size());
ASSERT_EQ("192.169.0.1", addresses_2[0].toText());
ASSERT_EQ("192.169.0.2", addresses_2[1].toText());
}
// Validate that option's fields were correctly parsed from strings.
Option6DnrPtr option_cast = boost::dynamic_pointer_cast<Option6Dnr>(option);
- ASSERT_EQ(1234, option_cast->getServicePriority());
+ ASSERT_EQ(1234U, option_cast->getServicePriority());
ASSERT_EQ(true, option_cast->isAdnOnlyMode());
ASSERT_EQ("example.some.host.org.", option_cast->getAdnAsText());
- ASSERT_EQ(23, option_cast->getAdnLength());
- ASSERT_EQ(0, option_cast->getAddrLength());
- ASSERT_EQ(0, option_cast->getSvcParamsLength());
+ ASSERT_EQ(23U, option_cast->getAdnLength());
+ ASSERT_EQ(0U, option_cast->getAddrLength());
+ ASSERT_EQ(0U, option_cast->getSvcParamsLength());
}
// The purpose of this test is to verify that definition can be created
// Validate that option's fields were correctly parsed from strings.
Option6DnrPtr option_cast = boost::dynamic_pointer_cast<Option6Dnr>(option);
- ASSERT_EQ(1234, option_cast->getServicePriority());
+ ASSERT_EQ(1234U, option_cast->getServicePriority());
ASSERT_EQ(false, option_cast->isAdnOnlyMode());
ASSERT_EQ("example.some.host.org.", option_cast->getAdnAsText());
- ASSERT_EQ(23, option_cast->getAdnLength());
- ASSERT_EQ(32, option_cast->getAddrLength());
- ASSERT_EQ(27, option_cast->getSvcParamsLength());
+ ASSERT_EQ(23U, option_cast->getAdnLength());
+ ASSERT_EQ(32U, option_cast->getAddrLength());
+ ASSERT_EQ(27U, option_cast->getSvcParamsLength());
auto addresses = option_cast->getAddresses();
- ASSERT_EQ(2, addresses.size());
+ ASSERT_EQ(2U, addresses.size());
ASSERT_EQ("2001:db8:1::dead:beef", addresses[0].toText());
ASSERT_EQ("ff02::face:b00c", addresses[1].toText());
}
boost::dynamic_pointer_cast<OptionOpaqueDataTuples>(option);
// There should be 3 tuples in this option.
- ASSERT_EQ(3, option_cast->getTuplesNum());
+ ASSERT_EQ(3U, option_cast->getTuplesNum());
// Check their values.
OpaqueDataTuple tuple0 = option_cast->getTuple(0);
// Expected len: 2 (option code + option len headers) + 5 (1 dest descriptor + 4 router addr)
// + 9 (5 dest descriptor + 4 router addr) + 8 (4 dest descriptor + 4 router addr).
- EXPECT_EQ(24, option_cast->len());
+ EXPECT_EQ(24U, option_cast->len());
// Verify toText() is working fine.
EXPECT_EQ("type=121(CLASSLESS_STATIC_ROUTE), len=22, "
// Sanity check on universe and header length.
EXPECT_EQ(Option::V4, option->getUniverse());
- EXPECT_EQ(2, option->getHeaderLen());
+ EXPECT_EQ(2U, option->getHeaderLen());
// Validate parsed values.
OptionClasslessStaticRoutePtr option_cast = boost::dynamic_pointer_cast<OptionClasslessStaticRoute>(option);
// Expected len: 2 (option code + option len headers) + 5 (1 dest descriptor + 4 router addr)
// + 9 (5 dest descriptor + 4 router addr) + 8 (4 dest descriptor + 4 router addr).
- EXPECT_EQ(24, option_cast->len());
+ EXPECT_EQ(24U, option_cast->len());
// Verify toText() is working fine.
EXPECT_EQ("type=121(CLASSLESS_STATIC_ROUTE), len=22, "
// However, since we allow using uint8_t types with this template
// class we have to test it here.
boost::shared_ptr<OptionIntArray<T> > opt;
- const int opt_len = 10;
+ const unsigned opt_len = 10;
const uint16_t opt_code = 80;
// Constructor throws exception if provided buffer is empty.
// We need to copy values from the buffer to apply sign if signed
// type is used.
std::vector<T> reference_values;
- for (int i = 0; i < opt_len; ++i) {
+ for (unsigned i = 0; i < opt_len; ++i) {
// Values have been read from the buffer in network
// byte order. We put them back in the same order here.
reference_values.push_back(static_cast<T>(buf_[i]));
if (u == Option::V4) {
// The total length is 10 bytes for data and 2 bytes for a header.
- ASSERT_EQ(12, out_buf_.getLength());
+ ASSERT_EQ(12U, out_buf_.getLength());
// if option type is correct
EXPECT_EQ(opt_code, out.readUint8());
// if option length is correct
- EXPECT_EQ(10, out.readUint8());
+ EXPECT_EQ(10U, out.readUint8());
} else {
// The total length is 10 bytes for data and 4 bytes for a header.
- ASSERT_EQ(14, out_buf_.getLength());
+ ASSERT_EQ(14U, out_buf_.getLength());
// if option type is correct
EXPECT_EQ(opt_code, out.readUint16());
// if option length is correct
- EXPECT_EQ(10, out.readUint16());
+ EXPECT_EQ(10U, out.readUint16());
}
// if data is correct
void bufferToIntTest16(const Option::Universe u) {
// Create option that conveys array of multiple uint16_t or int16_t values.
boost::shared_ptr<OptionIntArray<T> > opt;
- const int opt_len = 20;
+ const unsigned opt_len = 20;
const uint16_t opt_code = 81;
// Constructor throws exception if provided buffer is empty.
// Create reference values from the buffer so as we can
// simply compare two vectors.
std::vector<T> reference_values;
- for (int i = 0; i < opt_len; i += 2) {
+ for (unsigned i = 0; i < opt_len; i += 2) {
reference_values.push_back((buf_[i] << 8) |
buf_[i + 1]);
}
if (u == Option::V4) {
// The total length is 20 bytes for data and 2 bytes for a header.
- ASSERT_EQ(22, out_buf_.getLength());
+ ASSERT_EQ(22U, out_buf_.getLength());
// if option type is correct
EXPECT_EQ(opt_code, out.readUint8());
// if option length is correct
- EXPECT_EQ(20, out.readUint8());
+ EXPECT_EQ(20U, out.readUint8());
} else {
// The total length is 20 bytes for data and 4 bytes for a header.
- ASSERT_EQ(24, out_buf_.getLength());
+ ASSERT_EQ(24U, out_buf_.getLength());
// if option type is correct
EXPECT_EQ(opt_code, out.readUint16());
// if option length is correct
- EXPECT_EQ(20, out.readUint16());
+ EXPECT_EQ(20U, out.readUint16());
}
// if data is correct
std::vector<uint8_t> out_data;
void bufferToIntTest32(const Option::Universe u) {
// Create option that conveys array of multiple uint16_t values.
boost::shared_ptr<OptionIntArray<T> > opt;
- const int opt_len = 40;
+ const unsigned opt_len = 40;
const uint16_t opt_code = 82;
// Constructor throws exception if provided buffer is empty.
// Create reference values from the buffer so as we can
// simply compare two vectors.
std::vector<T> reference_values;
- for (int i = 0; i < opt_len; i += 4) {
+ for (unsigned i = 0; i < opt_len; i += 4) {
reference_values.push_back((buf_[i] << 24) |
(buf_[i + 1] << 16 & 0x00FF0000) |
(buf_[i + 2] << 8 & 0xFF00) |
if (u == Option::V4) {
// The total length is 40 bytes for data and 2 bytes for a header.
- ASSERT_EQ(42, out_buf_.getLength());
+ ASSERT_EQ(42U, out_buf_.getLength());
// if option type is correct
EXPECT_EQ(opt_code, out.readUint8());
// if option length is correct
- EXPECT_EQ(40, out.readUint8());
+ EXPECT_EQ(40U, out.readUint8());
} else {
// The total length is 40 bytes for data and 4 bytes for a header.
- ASSERT_EQ(44, out_buf_.getLength());
+ ASSERT_EQ(44U, out_buf_.getLength());
// if option type is correct
EXPECT_EQ(opt_code, out.readUint16());
// if option length is correct
- EXPECT_EQ(40, out.readUint16());
+ EXPECT_EQ(40U, out.readUint16());
}
// if data is correct
option.toText());
}
-
-
} // anonymous namespace
// The total length is 1 byte for data and 2 bytes or 4 bytes
// for option code and option length.
if (u == Option::V4) {
- EXPECT_EQ(3, out_buf_.getLength());
+ EXPECT_EQ(3U, out_buf_.getLength());
} else {
- EXPECT_EQ(5, out_buf_.getLength());
+ EXPECT_EQ(5U, out_buf_.getLength());
}
// Check if pack worked properly:
// if option type is correct
EXPECT_EQ(TEST_OPT_CODE, out.readUint16());
// if option length is correct
- EXPECT_EQ(1, out.readUint16());
+ EXPECT_EQ(1U, out.readUint16());
}
// if data is correct
- EXPECT_EQ(0xa1, out.readUint8() );
+ EXPECT_EQ(0xa1U, out.readUint8() );
}
/// @brief Basic test for int16 and uint16 types.
EXPECT_EQ(TEST_OPT_CODE, opt->getType());
// The total length is 2 bytes for data and 2 or 4 bytes for a header.
if (u == Option::V4) {
- EXPECT_EQ(4, out_buf_.getLength());
+ EXPECT_EQ(4U, out_buf_.getLength());
} else {
- EXPECT_EQ(6, out_buf_.getLength());
+ EXPECT_EQ(6U, out_buf_.getLength());
}
// Check if pack worked properly:
// if option type is correct
EXPECT_EQ(TEST_OPT_CODE, out.readUint8());
// if option length is correct
- EXPECT_EQ(2, out.readUint8());
+ EXPECT_EQ(2U, out.readUint8());
} else {
// if option type is correct
EXPECT_EQ(TEST_OPT_CODE, out.readUint16());
// if option length is correct
- EXPECT_EQ(2, out.readUint16());
+ EXPECT_EQ(2U, out.readUint16());
}
// if data is correct
- EXPECT_EQ(0xa1a2, out.readUint16() );
+ EXPECT_EQ(0xa1a2U, out.readUint16() );
}
/// @brief Basic test for int32 and uint32 types.
EXPECT_EQ(TEST_OPT_CODE, opt->getType());
// The total length is 4 bytes for data and 2 or 4 bytes for a header.
if (u == Option::V4) {
- EXPECT_EQ(6, out_buf_.getLength());
+ EXPECT_EQ(6U, out_buf_.getLength());
} else {
- EXPECT_EQ(8, out_buf_.getLength());
+ EXPECT_EQ(8U, out_buf_.getLength());
}
// Check if pack worked properly:
// if option type is correct
EXPECT_EQ(TEST_OPT_CODE, out.readUint8());
// if option length is correct
- EXPECT_EQ(4, out.readUint8());
+ EXPECT_EQ(4U, out.readUint8());
} else {
// if option type is correct
EXPECT_EQ(TEST_OPT_CODE, out.readUint16());
// if option length is correct
- EXPECT_EQ(4, out.readUint16());
+ EXPECT_EQ(4U, out.readUint16());
}
// if data is correct
- EXPECT_EQ(0xa1a2a3a4, out.readUint32());
+ EXPECT_EQ(0xa1a2a3a4U, out.readUint32());
}
OptionBuffer buf_; ///< Option buffer
boost::shared_ptr<OptionInt<uint8_t> > opt(new OptionInt<uint8_t>(Option::V6,
D6O_PREFERENCE, 123));
// Check if constructor initialized the option value correctly.
- EXPECT_EQ(123, opt->getValue());
+ EXPECT_EQ(123U, opt->getValue());
// Override the value.
opt->setValue(111);
EXPECT_EQ(Option::V6, opt->getUniverse());
EXPECT_EQ(D6O_PREFERENCE, opt->getType());
// Check if the value has been overridden.
- EXPECT_EQ(111, opt->getValue());
+ EXPECT_EQ(111U, opt->getValue());
}
TEST_F(OptionIntTest, setValueInt8) {
boost::shared_ptr<OptionInt<uint16_t> > opt(new OptionInt<uint16_t>(Option::V6,
D6O_ELAPSED_TIME, 123));
// Check if constructor initialized the option value correctly.
- EXPECT_EQ(123, opt->getValue());
+ EXPECT_EQ(123U, opt->getValue());
// Override the value.
opt->setValue(0x0102);
EXPECT_EQ(Option::V6, opt->getUniverse());
EXPECT_EQ(D6O_ELAPSED_TIME, opt->getType());
// Check if the value has been overridden.
- EXPECT_EQ(0x0102, opt->getValue());
+ EXPECT_EQ(0x0102U, opt->getValue());
}
TEST_F(OptionIntTest, setValueInt16) {
boost::shared_ptr<OptionInt<uint32_t> > opt(new OptionInt<uint32_t>(Option::V6,
D6O_CLT_TIME, 123));
// Check if constructor initialized the option value correctly.
- EXPECT_EQ(123, opt->getValue());
+ EXPECT_EQ(123U, opt->getValue());
// Override the value.
opt->setValue(0x01020304);
EXPECT_EQ(Option::V6, opt->getUniverse());
EXPECT_EQ(D6O_CLT_TIME, opt->getType());
// Check if the value has been overridden.
- EXPECT_EQ(0x01020304, opt->getValue());
+ EXPECT_EQ(0x01020304U, opt->getValue());
}
TEST_F(OptionIntTest, setValueInt32) {
opt->addOption(sub1);
opt->addOption(addr1);
- ASSERT_EQ(28, addr1->len());
- ASSERT_EQ(4, sub1->len());
- ASSERT_EQ(40, opt->len());
+ ASSERT_EQ(28U, addr1->len());
+ ASSERT_EQ(4U, sub1->len());
+ ASSERT_EQ(40U, opt->len());
uint8_t expected[] = {
0, opt_code, // type
// Create on-wire format of option and suboptions.
opt->pack(out_buf_);
// Compare the on-wire data with the reference buffer.
- ASSERT_EQ(40, out_buf_.getLength());
+ ASSERT_EQ(40U, out_buf_.getLength());
EXPECT_EQ(0, memcmp(out_buf_.getData(), expected, 40));
}
// Verify that it has expected type and data.
EXPECT_EQ(TEST_OPT_CODE, opt->getType());
- EXPECT_EQ(0x01020304, opt->getValue());
+ EXPECT_EQ(0x01020304U, opt->getValue());
// Expect that there is the sub option with the particular
// option code added.
EXPECT_EQ(TEST_OPT_CODE + 1, subopt->getType());
// Check the sub option's data.
OptionBuffer subopt_buf = subopt->getData();
- ASSERT_EQ(4, subopt_buf.size());
+ ASSERT_EQ(4U, subopt_buf.size());
// The data in the input buffer starts at offset 8.
EXPECT_TRUE(std::equal(subopt_buf.begin(), subopt_buf.end(), buf_.begin() + 8));
}
0xca, 0xfe, // type
0, 0 // len
};
- ASSERT_EQ(38, sizeof(expected));
+ ASSERT_EQ(38U, sizeof(expected));
// Make sure that the buffer's size is sufficient to
// copy the elements from the array.
ASSERT_TRUE(opt);
EXPECT_EQ(opt_code, opt->getType());
- EXPECT_EQ(0x0102, opt->getValue());
+ EXPECT_EQ(0x0102U, opt->getValue());
// Checks for address option
OptionPtr subopt = opt->getOption(D6O_IAADDR);
ASSERT_TRUE(addr);
EXPECT_EQ(D6O_IAADDR, addr->getType());
- EXPECT_EQ(28, addr->len());
- EXPECT_EQ(0x5000, addr->getPreferred());
- EXPECT_EQ(0x7000, addr->getValid());
+ EXPECT_EQ(28U, addr->len());
+ EXPECT_EQ(0x5000U, addr->getPreferred());
+ EXPECT_EQ(0x7000U, addr->getValid());
EXPECT_EQ("2001:db8:1234:5678::abcd", addr->getAddress().toText());
// Checks for dummy option
subopt = opt->getOption(0xcafe);
ASSERT_TRUE(subopt); // should be non-NULL
- EXPECT_EQ(0xcafe, subopt->getType());
- EXPECT_EQ(4, subopt->len());
+ EXPECT_EQ(0xcafeU, subopt->getType());
+ EXPECT_EQ(4U, subopt->len());
// There should be no data at all
- EXPECT_EQ(0, subopt->getData().size());
+ EXPECT_EQ(0U, subopt->getData().size());
// Try to get non-existent option.
subopt = opt->getOption(1);
TEST(OptionOpaqueDataTuples, constructor4) {
OptionOpaqueDataTuples data_tuple(Option::V4, DHO_VIVCO_SUBOPTIONS);
// Option length is 1 byte for option code + 1 byte for option size
- EXPECT_EQ(2, data_tuple.len());
+ EXPECT_EQ(2U, data_tuple.len());
// There should be no tuples.
- EXPECT_EQ(0, data_tuple.getTuplesNum());
+ EXPECT_EQ(0U, data_tuple.getTuplesNum());
}
// This test checks that the DHCPv4 option constructor sets the default
OptionOpaqueDataTuples data_tuple(Option::V4, DHO_V4_SZTP_REDIRECT,
OpaqueDataTuple::LENGTH_2_BYTES);
// Option length is 1 byte for option code + 1 byte for option size
- EXPECT_EQ(2, data_tuple.len());
+ EXPECT_EQ(2U, data_tuple.len());
// There should be no tuples.
- EXPECT_EQ(0, data_tuple.getTuplesNum());
+ EXPECT_EQ(0U, data_tuple.getTuplesNum());
}
// This test checks that the DHCPv6 option constructor sets the default
TEST(OptionOpaqueDataTuples, constructor6) {
OptionOpaqueDataTuples data_tuple(Option::V6, D6O_BOOTFILE_PARAM);
// Option length is 2 bytes for option code + 2 bytes for option size
- EXPECT_EQ(4, data_tuple.len());
+ EXPECT_EQ(4U, data_tuple.len());
// There should be no tuples.
- EXPECT_EQ(0, data_tuple.getTuplesNum());
+ EXPECT_EQ(0U, data_tuple.getTuplesNum());
}
// This test verifies that it is possible to append the opaque data tuple
TEST(OptionOpaqueDataTuples, addTuple4) {
OptionOpaqueDataTuples data_tuple(Option::V4, DHO_VIVCO_SUBOPTIONS);
// Initially there should be no tuples (for DHCPv4).
- ASSERT_EQ(0, data_tuple.getTuplesNum());
+ ASSERT_EQ(0U, data_tuple.getTuplesNum());
// Create a new tuple and add it to the option.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
tuple = "xyz";
data_tuple.addTuple(tuple);
// The option should now hold one tuple.
- ASSERT_EQ(1, data_tuple.getTuplesNum());
+ ASSERT_EQ(1U, data_tuple.getTuplesNum());
EXPECT_EQ("xyz", data_tuple.getTuple(0).getText());
// Add another tuple.
tuple = "abc";
data_tuple.addTuple(tuple);
// The option should now hold exactly two tuples in the order in which
// they were added.
- ASSERT_EQ(2, data_tuple.getTuplesNum());
+ ASSERT_EQ(2U, data_tuple.getTuplesNum());
EXPECT_EQ("xyz", data_tuple.getTuple(0).getText());
EXPECT_EQ("abc", data_tuple.getTuple(1).getText());
TEST(OptionOpaqueDataTuples, addTuple6) {
OptionOpaqueDataTuples data_tuple(Option::V6, D6O_BOOTFILE_PARAM);
// Initially there should be no tuples (for DHCPv6).
- ASSERT_EQ(0, data_tuple.getTuplesNum());
+ ASSERT_EQ(0U, data_tuple.getTuplesNum());
// Create a new tuple and add it to the option.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
tuple = "xyz";
data_tuple.addTuple(tuple);
// The option should now hold one tuple.
- ASSERT_EQ(1, data_tuple.getTuplesNum());
+ ASSERT_EQ(1U, data_tuple.getTuplesNum());
EXPECT_EQ("xyz", data_tuple.getTuple(0).getText());
// Add another tuple.
tuple = "abc";
data_tuple.addTuple(tuple);
// The option should now hold exactly two tuples in the order in which
// they were added.
- ASSERT_EQ(2, data_tuple.getTuplesNum());
+ ASSERT_EQ(2U, data_tuple.getTuplesNum());
EXPECT_EQ("xyz", data_tuple.getTuple(0).getText());
EXPECT_EQ("abc", data_tuple.getTuple(1).getText());
TEST(OptionOpaqueDataTuples, setTuple4) {
OptionOpaqueDataTuples data_tuple(Option::V4, DHO_VIVCO_SUBOPTIONS);
// Initially there should be no tuples (for DHCPv4).
- ASSERT_EQ(0, data_tuple.getTuplesNum());
+ ASSERT_EQ(0U, data_tuple.getTuplesNum());
// Add a tuple
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
tuple = "xyz";
// Add another one.
tuple = "abc";
data_tuple.addTuple(tuple);
- ASSERT_EQ(2, data_tuple.getTuplesNum());
+ ASSERT_EQ(2U, data_tuple.getTuplesNum());
ASSERT_EQ("abc", data_tuple.getTuple(1).getText());
// Try to replace them with new tuples.
tuple = "new_xyz";
ASSERT_NO_THROW(data_tuple.setTuple(0, tuple));
- ASSERT_EQ(2, data_tuple.getTuplesNum());
+ ASSERT_EQ(2U, data_tuple.getTuplesNum());
EXPECT_EQ("new_xyz", data_tuple.getTuple(0).getText());
tuple = "new_abc";
ASSERT_NO_THROW(data_tuple.setTuple(1, tuple));
- ASSERT_EQ(2, data_tuple.getTuplesNum());
+ ASSERT_EQ(2U, data_tuple.getTuplesNum());
EXPECT_EQ("new_abc", data_tuple.getTuple(1).getText());
// For out of range position, exception should be thrown.
TEST(OptionOpaqueDataTuples, setTuple6) {
OptionOpaqueDataTuples data_tuple(Option::V6, D6O_BOOTFILE_PARAM);
// Initially there should be no tuples (for DHCPv6).
- ASSERT_EQ(0, data_tuple.getTuplesNum());
+ ASSERT_EQ(0U, data_tuple.getTuplesNum());
// Add a tuple
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
tuple = "xyz";
// Add another one.
tuple = "abc";
data_tuple.addTuple(tuple);
- ASSERT_EQ(2, data_tuple.getTuplesNum());
+ ASSERT_EQ(2U, data_tuple.getTuplesNum());
ASSERT_EQ("abc", data_tuple.getTuple(1).getText());
// Try to replace them with new tuples.
tuple = "new_xyz";
ASSERT_NO_THROW(data_tuple.setTuple(0, tuple));
- ASSERT_EQ(2, data_tuple.getTuplesNum());
+ ASSERT_EQ(2U, data_tuple.getTuplesNum());
EXPECT_EQ("new_xyz", data_tuple.getTuple(0).getText());
tuple = "new_abc";
ASSERT_NO_THROW(data_tuple.setTuple(1, tuple));
- ASSERT_EQ(2, data_tuple.getTuplesNum());
+ ASSERT_EQ(2U, data_tuple.getTuplesNum());
EXPECT_EQ("new_abc", data_tuple.getTuple(1).getText());
// For out of range position, exception should be thrown.
// Check that the returned length of the DHCPv4 option is correct.
TEST(OptionOpaqueDataTuples, len4) {
OptionOpaqueDataTuples data_tuple(Option::V4, DHO_VIVCO_SUBOPTIONS);
- ASSERT_EQ(2, data_tuple.len());
+ ASSERT_EQ(2U, data_tuple.len());
// Add first tuple.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
tuple = "xyz";
ASSERT_NO_THROW(data_tuple.addTuple(tuple));
// The total length grows by 1 byte of the length field and 3 bytes
// consumed by 'xyz'.
- EXPECT_EQ(6, data_tuple.len());
+ EXPECT_EQ(6U, data_tuple.len());
// Add another tuple and check that the total size gets increased.
tuple = "abc";
data_tuple.addTuple(tuple);
- EXPECT_EQ(10, data_tuple.len());
+ EXPECT_EQ(10U, data_tuple.len());
}
// Check that the returned length of the DHCPv4 option is correct when
OptionOpaqueDataTuples data_tuple(Option::V4, DHO_V4_SZTP_REDIRECT, buf.begin(),
buf.end(), OpaqueDataTuple::LENGTH_2_BYTES);
// Expected len = 20 = 2 (v4 headers) + 2 (LFT) + 11 (1st tuple) + 2 (LFT) + 3 (2nd tuple)
- ASSERT_EQ(20, data_tuple.len());
+ ASSERT_EQ(20U, data_tuple.len());
}
// Check that the returned length of the DHCPv6 option is correct.
TEST(OptionOpaqueDataTuples, len6) {
OptionOpaqueDataTuples data_tuple(Option::V6, D6O_BOOTFILE_PARAM);
- ASSERT_EQ(4, data_tuple.len());
+ ASSERT_EQ(4U, data_tuple.len());
// Add first tuple.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
tuple = "xyz";
ASSERT_NO_THROW(data_tuple.addTuple(tuple));
// The total length grows by 2 bytes of the length field and 3 bytes
// consumed by 'xyz'.
- EXPECT_EQ(9, data_tuple.len());
+ EXPECT_EQ(9U, data_tuple.len());
// Add another tuple and check that the total size gets increased.
tuple = "abc";
data_tuple.addTuple(tuple);
- EXPECT_EQ(14, data_tuple.len());
+ EXPECT_EQ(14U, data_tuple.len());
}
// Check that the DHCPv4 option is rendered to the buffer in wire format.
TEST(OptionOpaqueDataTuples, pack4) {
OptionOpaqueDataTuples data_tuple(Option::V4, DHO_VIVCO_SUBOPTIONS);
- ASSERT_EQ(0, data_tuple.getTuplesNum());
+ ASSERT_EQ(0U, data_tuple.getTuplesNum());
// Add tuple.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
tuple = "Hello world";
// Render the data to the buffer.
OutputBuffer buf(10);
ASSERT_NO_THROW(data_tuple.pack(buf));
- ASSERT_EQ(18, buf.getLength());
+ ASSERT_EQ(18U, buf.getLength());
// Prepare reference data.
const uint8_t ref[] = {
TEST(OptionOpaqueDataTuples, pack4_with_ltf) {
OptionOpaqueDataTuples data_tuple(Option::V4, DHO_V4_SZTP_REDIRECT,
OpaqueDataTuple::LENGTH_2_BYTES);
- ASSERT_EQ(0, data_tuple.getTuplesNum());
+ ASSERT_EQ(0U, data_tuple.getTuplesNum());
// Add tuple.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
tuple = "Hello world";
// Render the data to the buffer.
OutputBuffer buf(10);
ASSERT_NO_THROW(data_tuple.pack(buf));
- ASSERT_EQ(20, buf.getLength());
+ ASSERT_EQ(20U, buf.getLength());
// Prepare reference data.
const uint8_t ref[] = {
// Check that the DHCPv6 option is rendered to the buffer in wire format.
TEST(OptionOpaqueDataTuples, pack6) {
OptionOpaqueDataTuples data_tuple(Option::V6, D6O_BOOTFILE_PARAM);
- ASSERT_EQ(0, data_tuple.getTuplesNum());
+ ASSERT_EQ(0U, data_tuple.getTuplesNum());
// Add tuple.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
tuple = "Hello world";
// Render the data to the buffer.
OutputBuffer buf(10);
ASSERT_NO_THROW(data_tuple.pack(buf));
- ASSERT_EQ(22, buf.getLength());
+ ASSERT_EQ(22U, buf.getLength());
// Prepare reference data.
const uint8_t ref[] = {
buf.end()));
);
EXPECT_EQ(DHO_VIVCO_SUBOPTIONS, data_tuple->getType());
- ASSERT_EQ(2, data_tuple->getTuplesNum());
+ ASSERT_EQ(2U, data_tuple->getTuplesNum());
EXPECT_EQ("Hello world", data_tuple->getTuple(0).getText());
EXPECT_EQ("foo", data_tuple->getTuple(1).getText());
}
OpaqueDataTuple::LENGTH_2_BYTES));
);
EXPECT_EQ(DHO_V4_SZTP_REDIRECT, data_tuple->getType());
- ASSERT_EQ(2, data_tuple->getTuplesNum());
+ ASSERT_EQ(2U, data_tuple->getTuplesNum());
EXPECT_EQ("Hello world", data_tuple->getTuple(0).getText());
EXPECT_EQ("foo", data_tuple->getTuple(1).getText());
}
buf.end()));
);
EXPECT_EQ(D6O_BOOTFILE_PARAM, data_tuple->getType());
- ASSERT_EQ(2, data_tuple->getTuplesNum());
+ ASSERT_EQ(2U, data_tuple->getTuplesNum());
EXPECT_EQ("Hello world", data_tuple->getTuple(0).getText());
EXPECT_EQ("foo", data_tuple->getTuple(1).getText());
}
buf.end()));
);
EXPECT_EQ(DHO_VIVCO_SUBOPTIONS, data_tuple->getType());
- ASSERT_EQ(1, data_tuple->getTuplesNum());
+ ASSERT_EQ(1U, data_tuple->getTuplesNum());
EXPECT_TRUE(data_tuple->getTuple(0).getText().empty());
}
OpaqueDataTuple::LENGTH_2_BYTES));
);
EXPECT_EQ(DHO_V4_SZTP_REDIRECT, data_tuple->getType());
- ASSERT_EQ(1, data_tuple->getTuplesNum());
+ ASSERT_EQ(1U, data_tuple->getTuplesNum());
EXPECT_TRUE(data_tuple->getTuple(0).getText().empty());
}
buf.end()));
);
EXPECT_EQ(D6O_BOOTFILE_PARAM, data_tuple->getType());
- ASSERT_EQ(1, data_tuple->getTuplesNum());
+ ASSERT_EQ(1U, data_tuple->getTuplesNum());
EXPECT_TRUE(data_tuple->getTuple(0).getText().empty());
}
buf.end()));
);
EXPECT_EQ(DHO_VIVCO_SUBOPTIONS, data_tuple->getType());
- EXPECT_EQ(0, data_tuple->getTuplesNum());
+ EXPECT_EQ(0U, data_tuple->getTuplesNum());
}
// This test checks that the DHCPv4 option containing no opaque
OpaqueDataTuple::LENGTH_2_BYTES));
);
EXPECT_EQ(DHO_V4_SZTP_REDIRECT, data_tuple->getType());
- EXPECT_EQ(0, data_tuple->getTuplesNum());
+ EXPECT_EQ(0U, data_tuple->getTuplesNum());
}
// This test checks that the DHCPv6 bootfile-param option containing no opaque
buf.end()));
);
EXPECT_EQ(D6O_BOOTFILE_PARAM, data_tuple->getType());
- EXPECT_EQ(0, data_tuple->getTuplesNum());
+ EXPECT_EQ(0U, data_tuple->getTuplesNum());
}
// Verifies correctness of the text representation of the DHCPv4 option.
TEST(OptionOpaqueDataTuples, toText4) {
OptionOpaqueDataTuples data_tuple(Option::V4, DHO_VIVCO_SUBOPTIONS);
- ASSERT_EQ(0, data_tuple.getTuplesNum());
+ ASSERT_EQ(0U, data_tuple.getTuplesNum());
// Lets add a tuple
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
tuple = "Hello world";
// tuple's length field is coded on 2 octets.
TEST(OptionOpaqueDataTuples, toText4_with_ltf) {
OptionOpaqueDataTuples data_tuple(Option::V4, DHO_V4_SZTP_REDIRECT, OpaqueDataTuple::LENGTH_2_BYTES);
- ASSERT_EQ(0, data_tuple.getTuplesNum());
+ ASSERT_EQ(0U, data_tuple.getTuplesNum());
// Lets add a tuple
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
tuple = "Hello world";
// Verifies correctness of the text representation of the DHCPv6 option.
TEST(OptionOpaqueDataTuples, toText6) {
OptionOpaqueDataTuples data_tuple(Option::V6, D6O_BOOTFILE_PARAM);
- ASSERT_EQ(0, data_tuple.getTuplesNum());
+ ASSERT_EQ(0U, data_tuple.getTuplesNum());
// Lets add a tuple
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
tuple = "Hello world";
OptionSpace6 space2("abcd", 2145);
EXPECT_EQ("abcd", space2.getName());
EXPECT_TRUE(space2.isVendorSpace());
- EXPECT_EQ(2145, space2.getEnterpriseNumber());
+ EXPECT_EQ(2145U, space2.getEnterpriseNumber());
// Verify that constructors throw an exception when invalid option
// space name has been specified.
// Mark it vendor option space and set enterprise id.
space.setVendorSpace(1234);
EXPECT_TRUE(space.isVendorSpace());
- EXPECT_EQ(1234, space.getEnterpriseNumber());
+ EXPECT_EQ(1234U, space.getEnterpriseNumber());
// Override the enterprise number to make sure and make sure that
// the new number is returned by the object.
space.setVendorSpace(2345);
EXPECT_TRUE(space.isVendorSpace());
- EXPECT_EQ(2345, space.getEnterpriseNumber());
+ EXPECT_EQ(2345U, space.getEnterpriseNumber());
// Clear the vendor option space flag.
space.clearVendorSpace();
const std::string optv4_value = "some option";
OptionString optv4(Option::V4, 123, optv4_value);
EXPECT_EQ(Option::V4, optv4.getUniverse());
- EXPECT_EQ(123, optv4.getType());
+ EXPECT_EQ(123U, optv4.getType());
EXPECT_EQ(optv4_value, optv4.getValue());
EXPECT_EQ(Option::OPTION4_HDR_LEN + optv4_value.size(), optv4.len());
const std::string optv6_value = "other option";
OptionString optv6(Option::V6, 234, optv6_value);
EXPECT_EQ(Option::V6, optv6.getUniverse());
- EXPECT_EQ(234, optv6.getType());
+ EXPECT_EQ(234U, optv6.getType());
EXPECT_EQ("other option", optv6.getValue());
EXPECT_EQ(Option::OPTION6_HDR_LEN + optv6_value.size(), optv6.len());
// Test the instance of the created option.
const std::string optv4_value = "This is a test string";
EXPECT_EQ(Option::V4, optv4->getUniverse());
- EXPECT_EQ(234, optv4->getType());
+ EXPECT_EQ(234U, optv4->getType());
EXPECT_EQ(Option::OPTION4_HDR_LEN + buf_.size(), optv4->len());
EXPECT_EQ(optv4_value, optv4->getValue());
// Test the instance of the created option.
const std::string optv6_value = "This is a test strin";
EXPECT_EQ(Option::V6, optv6->getUniverse());
- EXPECT_EQ(123, optv6->getType());
+ EXPECT_EQ(123U, optv6->getType());
EXPECT_EQ(Option::OPTION6_HDR_LEN + buf_.size() - 1, optv6->len());
EXPECT_EQ(optv6_value, optv6->getValue());
}
// the latter has API to read data from it.
InputBuffer test_buf(buf.getData(), buf.getLength());
// First byte holds option code.
- EXPECT_EQ(123, test_buf.readUint8());
+ EXPECT_EQ(123U, test_buf.readUint8());
// Second byte holds option length.
EXPECT_EQ(option_value.size(), test_buf.readUint8());
// Read the option data.
// One trailing null should trim off.
ASSERT_NO_THROW(optv4.setValue(std::string{"one\0", 4}));
- EXPECT_EQ(3, optv4.getValue().length());
+ EXPECT_EQ(3U, optv4.getValue().length());
EXPECT_EQ(optv4.getValue(), std::string("one"));
// More than one trailing null should trim off.
ASSERT_NO_THROW(optv4.setValue(std::string{"three\0\0\0", 8}));
- EXPECT_EQ(5, optv4.getValue().length());
+ EXPECT_EQ(5U, optv4.getValue().length());
EXPECT_EQ(optv4.getValue(), std::string("three"));
// Embedded null should be left in place.
ASSERT_NO_THROW(optv4.setValue(std::string{"em\0bed", 6}));
- EXPECT_EQ(6, optv4.getValue().length());
+ EXPECT_EQ(6U, optv4.getValue().length());
EXPECT_EQ(optv4.getValue(), (std::string{"em\0bed", 6}));
// Leading null should be left in place.
ASSERT_NO_THROW(optv4.setValue(std::string{"\0leading", 8}));
- EXPECT_EQ(8, optv4.getValue().length());
+ EXPECT_EQ(8U, optv4.getValue().length());
EXPECT_EQ(optv4.getValue(), (std::string{"\0leading", 8}));
}
// One trailing null should trim off.
buffer = {'o', 'n', 'e', 0 };
ASSERT_NO_THROW(optv4.unpack(buffer.begin(), buffer.end()));
- EXPECT_EQ(3, optv4.getValue().length());
+ EXPECT_EQ(3U, optv4.getValue().length());
EXPECT_EQ(optv4.getValue(), std::string("one"));
// More than one trailing null should trim off.
buffer = { 't', 'h', 'r', 'e', 'e', 0, 0, 0 };
ASSERT_NO_THROW(optv4.unpack(buffer.begin(), buffer.end()));
- EXPECT_EQ(5, optv4.getValue().length());
+ EXPECT_EQ(5U, optv4.getValue().length());
EXPECT_EQ(optv4.getValue(), std::string("three"));
// Embedded null should be left in place.
buffer = { 'e', 'm', 0, 'b', 'e', 'd' };
ASSERT_NO_THROW(optv4.unpack(buffer.begin(), buffer.end()));
- EXPECT_EQ(6, optv4.getValue().length());
+ EXPECT_EQ(6U, optv4.getValue().length());
EXPECT_EQ(optv4.getValue(), (std::string{"em\0bed", 6}));
// Leading null should be left in place.
buffer = { 0, 'l', 'e', 'a', 'd', 'i', 'n', 'g' };
ASSERT_NO_THROW(optv4.unpack(buffer.begin(), buffer.end()));
- EXPECT_EQ(8, optv4.getValue().length());
+ EXPECT_EQ(8U, optv4.getValue().length());
EXPECT_EQ(optv4.getValue(), (std::string{"\0leading", 8}));
}
EXPECT_NO_THROW(opt.reset(new Option(Option::V4, 17)));
EXPECT_EQ(Option::V4, opt->getUniverse());
- EXPECT_EQ(17, opt->getType());
- EXPECT_EQ(0, opt->getData().size());
- EXPECT_EQ(2, opt->len()); // just v4 header
+ EXPECT_EQ(17U, opt->getType());
+ EXPECT_EQ(0U, opt->getData().size());
+ EXPECT_EQ(2U, opt->len()); // just v4 header
EXPECT_NO_THROW(opt.reset());
ASSERT_NO_THROW(opt.reset(new Option(Option::V4, 123, data)));
// Check that content is reported properly
- EXPECT_EQ(123, opt->getType());
+ EXPECT_EQ(123U, opt->getType());
vector<uint8_t> optData = opt->getData();
ASSERT_EQ(optData.size(), data.size());
EXPECT_TRUE(optData == data);
- EXPECT_EQ(2, opt->getHeaderLen());
- EXPECT_EQ(6, opt->len());
+ EXPECT_EQ(2U, opt->getHeaderLen());
+ EXPECT_EQ(6U, opt->len());
// Now store that option into a buffer
OutputBuffer buf(100);
// Check content of that buffer:
// 2 byte header + 4 bytes data
- ASSERT_EQ(6, buf.getLength());
+ ASSERT_EQ(6U, buf.getLength());
// That's how this option is supposed to look like
uint8_t exp[] = { 123, 4, 1, 2, 3, 4 };
);
// Check that content is reported properly
- EXPECT_EQ(123, opt->getType());
+ EXPECT_EQ(123U, opt->getType());
vector<uint8_t> optData = opt->getData();
ASSERT_EQ(optData.size(), expData.size());
EXPECT_TRUE(optData == expData);
- EXPECT_EQ(2, opt->getHeaderLen());
- EXPECT_EQ(6, opt->len());
+ EXPECT_EQ(2U, opt->getHeaderLen());
+ EXPECT_EQ(6U, opt->len());
// Now store that option into a buffer
OutputBuffer buf(100);
// Check content of that buffer
// 2 byte header + 4 bytes data
- ASSERT_EQ(6, buf.getLength());
+ ASSERT_EQ(6U, buf.getLength());
// That's how this option is supposed to look like
uint8_t exp[] = { 123, 4, 1, 2, 3, 4 };
scoped_ptr<Option> opt(new Option(Option::V6, 1));
EXPECT_EQ(Option::V6, opt->getUniverse());
- EXPECT_EQ(1, opt->getType());
- EXPECT_EQ(0, opt->getData().size());
- EXPECT_EQ(4, opt->len()); // Just v6 header
+ EXPECT_EQ(1U, opt->getType());
+ EXPECT_EQ(0U, opt->getData().size());
+ EXPECT_EQ(4U, opt->len()); // Just v6 header
EXPECT_NO_THROW(opt.reset());
}
scoped_ptr<Option> opt(new Option(Option::V6, 333, // Type
buf_.begin() + 3, // Begin offset
buf_.begin() + 10)); // End offset
- EXPECT_EQ(333, opt->getType());
+ EXPECT_EQ(333U, opt->getType());
- ASSERT_EQ(11, opt->len());
- ASSERT_EQ(7, opt->getData().size());
+ ASSERT_EQ(11U, opt->len());
+ ASSERT_EQ(7U, opt->getData().size());
EXPECT_EQ(0, memcmp(&buf_[3], &opt->getData()[0], 7) );
opt->pack(outBuf_);
- EXPECT_EQ(11, outBuf_.getLength());
+ EXPECT_EQ(11U, outBuf_.getLength());
const uint8_t* out = outBuf_.getData();
EXPECT_EQ(out[0], 333 / 256); // Type
opt->pack(outBuf_);
// 4 bytes header + 4 bytes content
- EXPECT_EQ(8, opt->len());
+ EXPECT_EQ(8U, opt->len());
EXPECT_EQ(D6O_CLIENTID, opt->getType());
- EXPECT_EQ(8, outBuf_.getLength());
+ EXPECT_EQ(8U, outBuf_.getLength());
// Check if pack worked properly:
// If option type is correct
// opt3 len = 9 4(header)+5(data)
// opt1 len = 7 + suboptions() = 7 + 4 + 9 = 20
- EXPECT_EQ(4, opt2->len());
- EXPECT_EQ(9, opt3->len());
- EXPECT_EQ(20, opt1->len());
+ EXPECT_EQ(4U, opt2->len());
+ EXPECT_EQ(9U, opt3->len());
+ EXPECT_EQ(20U, opt1->len());
uint8_t expected[] = {
0xff, 0xff, 0, 16, 100, 101, 102,
};
opt1->pack(outBuf_);
- EXPECT_EQ(20, outBuf_.getLength());
+ EXPECT_EQ(20U, outBuf_.getLength());
// Payload
EXPECT_EQ(0, memcmp(outBuf_.getData(), expected, 20) );
};
opt1->pack(outBuf_);
- EXPECT_EQ(20, outBuf_.getLength());
+ EXPECT_EQ(20U, outBuf_.getLength());
// Payload
EXPECT_EQ(0, memcmp(outBuf_.getData(), expected, 20) );
parent->addOption(opt3);
// Let's delete one of them
- EXPECT_EQ(true, parent->delOption(2));
+ EXPECT_TRUE(parent->delOption(2));
// There still should be the other option 2
EXPECT_NE(OptionPtr(), parent->getOption(2));
// Let's delete the other option 2
- EXPECT_EQ(true, parent->delOption(2));
+ EXPECT_TRUE(parent->delOption(2));
// No more options with type=2
EXPECT_EQ(OptionPtr(), parent->getOption(2));
// Let's try to delete - should fail
- EXPECT_TRUE(false == parent->delOption(2));
+ EXPECT_FALSE(parent->delOption(2));
}
TEST_F(OptionTest, v6_toText) {
OptionPtr opt4(new Option(Option::V6, 258, buf_.begin(), buf_.begin() + 4));
OptionPtr opt5(new Option(Option::V6, 258, buf_.begin(), buf_.begin() + 5));
- EXPECT_EQ(5, opt1->getUint8());
+ EXPECT_EQ(5U, opt1->getUint8());
EXPECT_THROW(opt1->getUint16(), OutOfRange);
EXPECT_THROW(opt1->getUint32(), OutOfRange);
- EXPECT_EQ(5, opt2->getUint8());
- EXPECT_EQ(0x0504, opt2->getUint16());
+ EXPECT_EQ(5U, opt2->getUint8());
+ EXPECT_EQ(0x0504U, opt2->getUint16());
EXPECT_THROW(opt2->getUint32(), OutOfRange);
- EXPECT_EQ(5, opt3->getUint8());
- EXPECT_EQ(0x0504, opt3->getUint16());
+ EXPECT_EQ(5U, opt3->getUint8());
+ EXPECT_EQ(0x0504U, opt3->getUint16());
EXPECT_THROW(opt3->getUint32(), OutOfRange);
- EXPECT_EQ(5, opt4->getUint8());
- EXPECT_EQ(0x0504, opt4->getUint16());
- EXPECT_EQ(0x05040302, opt4->getUint32());
+ EXPECT_EQ(5U, opt4->getUint8());
+ EXPECT_EQ(0x0504U, opt4->getUint16());
+ EXPECT_EQ(0x05040302U, opt4->getUint32());
// The same as for 4-byte long, just get first 1,2 or 4 bytes
- EXPECT_EQ(5, opt5->getUint8());
- EXPECT_EQ(0x0504, opt5->getUint16());
- EXPECT_EQ(0x05040302, opt5->getUint32());
+ EXPECT_EQ(5U, opt5->getUint8());
+ EXPECT_EQ(0x0504U, opt5->getUint16());
+ EXPECT_EQ(0x05040302U, opt5->getUint32());
}
// Verify setUint8
opt1->setUint8(255);
- EXPECT_EQ(255, opt1->getUint8());
+ EXPECT_EQ(255U, opt1->getUint8());
opt1->pack(outBuf_);
- EXPECT_EQ(3, opt1->len());
- EXPECT_EQ(3, outBuf_.getLength());
+ EXPECT_EQ(3U, opt1->len());
+ EXPECT_EQ(3U, outBuf_.getLength());
uint8_t exp1[] = {125, 1, 255};
- EXPECT_TRUE(0 == memcmp(exp1, outBuf_.getData(), 3));
+ EXPECT_EQ(0, memcmp(exp1, outBuf_.getData(), 3));
// Verify getUint16
outBuf_.clear();
opt2->setUint16(12345);
opt2->pack(outBuf_);
- EXPECT_EQ(12345, opt2->getUint16());
- EXPECT_EQ(4, opt2->len());
- EXPECT_EQ(4, outBuf_.getLength());
+ EXPECT_EQ(12345U, opt2->getUint16());
+ EXPECT_EQ(4U, opt2->len());
+ EXPECT_EQ(4U, outBuf_.getLength());
uint8_t exp2[] = {125, 2, 12345/256, 12345%256};
- EXPECT_TRUE(0 == memcmp(exp2, outBuf_.getData(), 4));
+ EXPECT_EQ(0, memcmp(exp2, outBuf_.getData(), 4));
// Verify getUint32
outBuf_.clear();
opt4->setUint32(0x12345678);
opt4->pack(outBuf_);
- EXPECT_EQ(0x12345678, opt4->getUint32());
- EXPECT_EQ(6, opt4->len());
- EXPECT_EQ(6, outBuf_.getLength());
+ EXPECT_EQ(0x12345678U, opt4->getUint32());
+ EXPECT_EQ(6U, opt4->len());
+ EXPECT_EQ(6U, outBuf_.getLength());
uint8_t exp4[] = {125, 4, 0x12, 0x34, 0x56, 0x78};
- EXPECT_TRUE(0 == memcmp(exp4, outBuf_.getData(), 6));
+ EXPECT_EQ(0, memcmp(exp4, outBuf_.getData(), 6));
}
TEST_F(OptionTest, setData) {
opt1->pack(outBuf_);
ASSERT_EQ(outBuf_.getLength() - opt1->getHeaderLen(), buf_.size());
const uint8_t* test_data = outBuf_.getData();
- EXPECT_TRUE(0 == memcmp(&buf_[0], test_data + opt1->getHeaderLen(),
- buf_.size()));
+ EXPECT_EQ(0, memcmp(&buf_[0], test_data + opt1->getHeaderLen(), buf_.size()));
// Verify data override with new buffer shorter than initial option buffer
// size.
opt2->pack(outBuf_);
ASSERT_EQ(outBuf_.getLength() - opt1->getHeaderLen(), buf_.size());
test_data = outBuf_.getData();
- EXPECT_TRUE(0 == memcmp(&buf_[0], test_data + opt1->getHeaderLen(),
- buf_.size()));
+ EXPECT_EQ(0, memcmp(&buf_[0], test_data + opt1->getHeaderLen(), buf_.size()));
}
// This test verifies that options can be compared using equals(OptionPtr)
auto option = Option::create(Option::V4, 123);
ASSERT_TRUE(option);
EXPECT_EQ(Option::V4, option->getUniverse());
- EXPECT_EQ(123, option->getType());
+ EXPECT_EQ(123U, option->getType());
}
// This test verifies that option factory function creates a
auto option = Option::create(Option::V4, 123, buf_);
ASSERT_TRUE(option);
EXPECT_EQ(Option::V4, option->getUniverse());
- EXPECT_EQ(123, option->getType());
+ EXPECT_EQ(123U, option->getType());
EXPECT_EQ(buf_, option->getData());
}
// long field which carries a value of 0).
TEST(OptionVendorClass, constructor4) {
OptionVendorClass vendor_class(Option::V4, 1234);
- EXPECT_EQ(1234, vendor_class.getVendorId());
+ EXPECT_EQ(1234U, vendor_class.getVendorId());
// Option length is 1 byte for header + 1 byte for option size +
// 4 bytes of enterprise id + 1 byte for opaque data.
- EXPECT_EQ(7, vendor_class.len());
+ EXPECT_EQ(7U, vendor_class.len());
// There should be one empty tuple.
- ASSERT_EQ(1, vendor_class.getTuplesNum());
- EXPECT_EQ(0, vendor_class.getTuple(0).getLength());
+ ASSERT_EQ(1U, vendor_class.getTuplesNum());
+ EXPECT_EQ(0U, vendor_class.getTuple(0).getLength());
}
// This test checks that the DHCPv6 option constructor sets the default
// properties to the expected values.
TEST(OptionVendorClass, constructor6) {
OptionVendorClass vendor_class(Option::V6, 2345);
- EXPECT_EQ(2345, vendor_class.getVendorId());
+ EXPECT_EQ(2345U, vendor_class.getVendorId());
// Option length is 2 bytes for option code + 2 bytes for option size +
// 4 bytes of enterprise id.
- EXPECT_EQ(8, vendor_class.len());
+ EXPECT_EQ(8U, vendor_class.len());
// There should be no tuples.
- EXPECT_EQ(0, vendor_class.getTuplesNum());
+ EXPECT_EQ(0U, vendor_class.getTuplesNum());
}
// This test verifies that it is possible to append the opaque data tuple
TEST(OptionVendorClass, addTuple) {
OptionVendorClass vendor_class(Option::V6, 2345);
// Initially there should be no tuples (for DHCPv6).
- ASSERT_EQ(0, vendor_class.getTuplesNum());
+ ASSERT_EQ(0U, vendor_class.getTuplesNum());
// Create a new tuple and add it to the option.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
tuple = "xyz";
vendor_class.addTuple(tuple);
// The option should now hold one tuple.
- ASSERT_EQ(1, vendor_class.getTuplesNum());
+ ASSERT_EQ(1U, vendor_class.getTuplesNum());
EXPECT_EQ("xyz", vendor_class.getTuple(0).getText());
// Add another tuple.
tuple = "abc";
vendor_class.addTuple(tuple);
// The option should now hold exactly two tuples in the order in which
// they were added.
- ASSERT_EQ(2, vendor_class.getTuplesNum());
+ ASSERT_EQ(2U, vendor_class.getTuplesNum());
EXPECT_EQ("xyz", vendor_class.getTuple(0).getText());
EXPECT_EQ("abc", vendor_class.getTuple(1).getText());
TEST(OptionVendorClass, setTuple) {
OptionVendorClass vendor_class(Option::V4, 1234);
// The DHCPv4 option should carry one empty tuple.
- ASSERT_EQ(1, vendor_class.getTuplesNum());
+ ASSERT_EQ(1U, vendor_class.getTuplesNum());
ASSERT_TRUE(vendor_class.getTuple(0).getText().empty());
// Replace the empty tuple with non-empty one.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
tuple = "xyz";
ASSERT_NO_THROW(vendor_class.setTuple(0, tuple));
// There should be one tuple with updated data.
- ASSERT_EQ(1, vendor_class.getTuplesNum());
+ ASSERT_EQ(1U, vendor_class.getTuplesNum());
EXPECT_EQ("xyz", vendor_class.getTuple(0).getText());
// Add another one.
tuple = "abc";
vendor_class.addTuple(tuple);
- ASSERT_EQ(2, vendor_class.getTuplesNum());
+ ASSERT_EQ(2U, vendor_class.getTuplesNum());
ASSERT_EQ("abc", vendor_class.getTuple(1).getText());
// Try to replace them with new tuples.
tuple = "new_xyz";
ASSERT_NO_THROW(vendor_class.setTuple(0, tuple));
- ASSERT_EQ(2, vendor_class.getTuplesNum());
+ ASSERT_EQ(2U, vendor_class.getTuplesNum());
EXPECT_EQ("new_xyz", vendor_class.getTuple(0).getText());
tuple = "new_abc";
ASSERT_NO_THROW(vendor_class.setTuple(1, tuple));
- ASSERT_EQ(2, vendor_class.getTuplesNum());
+ ASSERT_EQ(2U, vendor_class.getTuplesNum());
EXPECT_EQ("new_abc", vendor_class.getTuple(1).getText());
// For out of range position, exception should be thrown.
// Check that the returned length of the DHCPv4 option is correct.
TEST(OptionVendorClass, len4) {
OptionVendorClass vendor_class(Option::V4, 1234);
- ASSERT_EQ(7, vendor_class.len());
+ ASSERT_EQ(7U, vendor_class.len());
// Replace the default empty tuple.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
tuple = "xyz";
ASSERT_NO_THROW(vendor_class.setTuple(0, tuple));
// The total length should get increased by the size of 'xyz'.
- EXPECT_EQ(10, vendor_class.len());
+ EXPECT_EQ(10U, vendor_class.len());
// Add another tuple.
tuple = "abc";
vendor_class.addTuple(tuple);
// The total size now grows by the additional enterprise id and the
// 1 byte of the tuple length field and 3 bytes of 'abc'.
- EXPECT_EQ(18, vendor_class.len());
+ EXPECT_EQ(18U, vendor_class.len());
}
// Check that the returned length of the DHCPv6 option is correct.
TEST(OptionVendorClass, len6) {
OptionVendorClass vendor_class(Option::V6, 1234);
- ASSERT_EQ(8, vendor_class.len());
+ ASSERT_EQ(8U, vendor_class.len());
// Add first tuple.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
tuple = "xyz";
ASSERT_NO_THROW(vendor_class.addTuple(tuple));
// The total length grows by 2 bytes of the length field and 3 bytes
// consumed by 'xyz'.
- EXPECT_EQ(13, vendor_class.len());
+ EXPECT_EQ(13U, vendor_class.len());
// Add another tuple and check that the total size gets increased.
tuple = "abc";
vendor_class.addTuple(tuple);
- EXPECT_EQ(18, vendor_class.len());
+ EXPECT_EQ(18U, vendor_class.len());
}
// Check that the option is rendered to the buffer in wire format.
TEST(OptionVendorClass, pack4) {
OptionVendorClass vendor_class(Option::V4, 1234);
- ASSERT_EQ(1, vendor_class.getTuplesNum());
+ ASSERT_EQ(1U, vendor_class.getTuplesNum());
// By default, there is an empty tuple in the option. Let's replace
// it with the tuple with some data.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
// Render the data to the buffer.
OutputBuffer buf(10);
ASSERT_NO_THROW(vendor_class.pack(buf));
- ASSERT_EQ(26, buf.getLength());
+ ASSERT_EQ(26U, buf.getLength());
// Prepare reference data.
const uint8_t ref[] = {
// Check that the DHCPv6 option is rendered to the buffer in wire format.
TEST(OptionVendorClass, pack6) {
OptionVendorClass vendor_class(Option::V6, 1234);
- ASSERT_EQ(0, vendor_class.getTuplesNum());
+ ASSERT_EQ(0U, vendor_class.getTuplesNum());
// Add tuple.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
tuple = "Hello world";
// Render the data to the buffer.
OutputBuffer buf(10);
ASSERT_NO_THROW(vendor_class.pack(buf));
- ASSERT_EQ(26, buf.getLength());
+ ASSERT_EQ(26U, buf.getLength());
// Prepare reference data.
const uint8_t ref[] = {
buf.end()));
);
EXPECT_EQ(DHO_VIVCO_SUBOPTIONS, vendor_class->getType());
- EXPECT_EQ(1234, vendor_class->getVendorId());
- ASSERT_EQ(2, vendor_class->getTuplesNum());
+ EXPECT_EQ(1234U, vendor_class->getVendorId());
+ ASSERT_EQ(2U, vendor_class->getTuplesNum());
EXPECT_EQ("Hello world", vendor_class->getTuple(0).getText());
EXPECT_EQ("foo", vendor_class->getTuple(1).getText());
}
buf.end()));
);
EXPECT_EQ(D6O_VENDOR_CLASS, vendor_class->getType());
- EXPECT_EQ(1234, vendor_class->getVendorId());
- ASSERT_EQ(2, vendor_class->getTuplesNum());
+ EXPECT_EQ(1234U, vendor_class->getVendorId());
+ ASSERT_EQ(2U, vendor_class->getTuplesNum());
EXPECT_EQ("Hello world", vendor_class->getTuple(0).getText());
EXPECT_EQ("foo", vendor_class->getTuple(1).getText());
}
buf.end()));
);
EXPECT_EQ(DHO_VIVCO_SUBOPTIONS, vendor_class->getType());
- EXPECT_EQ(1234, vendor_class->getVendorId());
- ASSERT_EQ(1, vendor_class->getTuplesNum());
+ EXPECT_EQ(1234U, vendor_class->getVendorId());
+ ASSERT_EQ(1U, vendor_class->getTuplesNum());
EXPECT_TRUE(vendor_class->getTuple(0).getText().empty());
}
buf.end()));
);
EXPECT_EQ(D6O_VENDOR_CLASS, vendor_class->getType());
- EXPECT_EQ(1234, vendor_class->getVendorId());
- ASSERT_EQ(1, vendor_class->getTuplesNum());
+ EXPECT_EQ(1234U, vendor_class->getVendorId());
+ ASSERT_EQ(1U, vendor_class->getTuplesNum());
EXPECT_TRUE(vendor_class->getTuple(0).getText().empty());
}
buf.end()));
);
EXPECT_EQ(DHO_VIVCO_SUBOPTIONS, vendor_class->getType());
- EXPECT_EQ(1234, vendor_class->getVendorId());
- EXPECT_EQ(0, vendor_class->getTuplesNum());
+ EXPECT_EQ(1234U, vendor_class->getVendorId());
+ EXPECT_EQ(0U, vendor_class->getTuplesNum());
}
// This test checks that the DHCPv6 option without opaque data is
buf.end()));
);
EXPECT_EQ(D6O_VENDOR_CLASS, vendor_class->getType());
- EXPECT_EQ(1234, vendor_class->getVendorId());
- EXPECT_EQ(0, vendor_class->getTuplesNum());
+ EXPECT_EQ(1234U, vendor_class->getVendorId());
+ EXPECT_EQ(0U, vendor_class->getTuplesNum());
}
// This test checks that exception is thrown when parsing truncated DHCPv4
// Verifies correctness of the text representation of the DHCPv4 option.
TEST(OptionVendorClass, toText4) {
OptionVendorClass vendor_class(Option::V4, 1234);
- ASSERT_EQ(1, vendor_class.getTuplesNum());
+ ASSERT_EQ(1U, vendor_class.getTuplesNum());
// By default, there is an empty tuple in the option. Let's replace
// it with the tuple with some data.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_1_BYTE);
// Verifies correctness of the text representation of the DHCPv6 option.
TEST(OptionVendorClass, toText6) {
OptionVendorClass vendor_class(Option::V6, 1234);
- ASSERT_EQ(0, vendor_class.getTuplesNum());
+ ASSERT_EQ(0U, vendor_class.getTuplesNum());
// By default, there is an empty tuple in the option. Let's replace
// it with the tuple with some data.
OpaqueDataTuple tuple(OpaqueDataTuple::LENGTH_2_BYTES);
new OptionVendorClass(Option::V6, buf.begin(), buf.end())););
EXPECT_EQ(D6O_VENDOR_CLASS, vendor_class->getType());
- EXPECT_EQ(1234, vendor_class->getVendorId());
- ASSERT_EQ(2, vendor_class->getTuplesNum());
+ EXPECT_EQ(1234U, vendor_class->getVendorId());
+ ASSERT_EQ(2U, vendor_class->getTuplesNum());
EXPECT_EQ("Hello world", vendor_class->getTuple(0).getText());
EXPECT_EQ("foo", vendor_class->getTuple(1).getText());
new OptionVendorClass(Option::V6, buf.begin(), buf.end())););
EXPECT_EQ(D6O_VENDOR_CLASS, vendor_class->getType());
- EXPECT_EQ(1234, vendor_class->getVendorId());
- ASSERT_EQ(2, vendor_class->getTuplesNum());
+ EXPECT_EQ(1234U, vendor_class->getVendorId());
+ ASSERT_EQ(2U, vendor_class->getTuplesNum());
// The first value will have one extra byte.
EXPECT_EQ(std::string("Hello world") + '\0',
vendor_class->getTuple(0).getText());
new OptionVendorClass(Option::V6, buf.begin(), buf.end())););
EXPECT_EQ(D6O_VENDOR_CLASS, vendor_class->getType());
- EXPECT_EQ(1234, vendor_class->getVendorId());
- ASSERT_EQ(2, vendor_class->getTuplesNum());
+ EXPECT_EQ(1234U, vendor_class->getVendorId());
+ ASSERT_EQ(2U, vendor_class->getTuplesNum());
EXPECT_EQ("Hello world", vendor_class->getTuple(0).getText());
// The length would have internally been interpreted as {0x00, 0x04} == 4,
// but the parser would have stopped at the end of the option, so the second
new OptionVendorClass(Option::V6, buf.begin(), buf.end())););
EXPECT_EQ(D6O_VENDOR_CLASS, vendor_class->getType());
- EXPECT_EQ(1234, vendor_class->getVendorId());
- ASSERT_EQ(2, vendor_class->getTuplesNum());
+ EXPECT_EQ(1234U, vendor_class->getVendorId());
+ ASSERT_EQ(2U, vendor_class->getTuplesNum());
// The first value will have one extra byte.
EXPECT_EQ(std::string("Hello world") + '\0',
vendor_class->getTuple(0).getText());
}
// We should have three.
- ASSERT_EQ(3, q.getSize());
+ ASSERT_EQ(3U, q.getSize());
// We should have transids 1005,1004,1003 (back to front)
Pkt4Ptr pkt;
ASSERT_NO_THROW(pkt = q.peek(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1003, pkt->getTransid());
+ EXPECT_EQ(1003U, pkt->getTransid());
// Peek back should be transid 1005.
ASSERT_NO_THROW(pkt = q.peek(QueueEnd::BACK));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1005, pkt->getTransid());
+ EXPECT_EQ(1005U, pkt->getTransid());
// Pop front should return transid 1003.
ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1003, pkt->getTransid());
+ EXPECT_EQ(1003U, pkt->getTransid());
// Pop back should return transid 1005.
ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::BACK));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1005, pkt->getTransid());
+ EXPECT_EQ(1005U, pkt->getTransid());
// Peek front should be transid 1004.
ASSERT_NO_THROW(pkt = q.peek(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1004, pkt->getTransid());
+ EXPECT_EQ(1004U, pkt->getTransid());
// Peek back should be transid 1004.
ASSERT_NO_THROW(pkt = q.peek(QueueEnd::BACK));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1004, pkt->getTransid());
+ EXPECT_EQ(1004U, pkt->getTransid());
// Pop front should return transid 1004.
ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1004, pkt->getTransid());
+ EXPECT_EQ(1004U, pkt->getTransid());
// Pop front should return an empty pointer.
ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::BACK));
// We should be able to enqueue a packet with even numbered values.
Pkt4Ptr pkt(new Pkt4(DHCPDISCOVER, 1002));
ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_even));
- ASSERT_EQ(1, q.getSize());
+ ASSERT_EQ(1U, q.getSize());
// We should be able to enqueue a packet with odd numbered values.
pkt.reset(new Pkt4(DHCPDISCOVER, 1003));
ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_odd));
- ASSERT_EQ(2, q.getSize());
+ ASSERT_EQ(2U, q.getSize());
// Enable drop logic.
q.drop_enabled_ = true;
// We should not be able to add one with an even-numbered transid.
pkt.reset(new Pkt4(DHCPDISCOVER, 1004));
ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_odd));
- ASSERT_EQ(2, q.getSize());
+ ASSERT_EQ(2U, q.getSize());
// We should not be able to add one with from even-numbered port.
pkt.reset(new Pkt4(DHCPDISCOVER, 1005));
ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_even));
- EXPECT_EQ(2, q.getSize());
+ EXPECT_EQ(2U, q.getSize());
// We should be able to add one with an odd-numbered values.
pkt.reset(new Pkt4(DHCPDISCOVER, 1007));
ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_odd));
- EXPECT_EQ(3, q.getSize());
+ EXPECT_EQ(3U, q.getSize());
// Dequeue them and make sure they are as expected: 1002,1003, and 1007.
ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
- EXPECT_EQ(1002, pkt->getTransid());
+ EXPECT_EQ(1002U, pkt->getTransid());
ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
- EXPECT_EQ(1003, pkt->getTransid());
+ EXPECT_EQ(1003U, pkt->getTransid());
ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
- EXPECT_EQ(1007, pkt->getTransid());
+ EXPECT_EQ(1007U, pkt->getTransid());
// Queue should be empty.
ASSERT_NO_THROW(pkt = q.dequeuePacket());
q.eat_count_ = 2;
ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
- EXPECT_EQ(1003, pkt->getTransid());
- EXPECT_EQ(2, q.getSize());
+ EXPECT_EQ(1003U, pkt->getTransid());
+ EXPECT_EQ(2U, q.getSize());
}
} // end of anonymous namespace
}
// We should have three.
- ASSERT_EQ(3, q.getSize());
+ ASSERT_EQ(3U, q.getSize());
// We should have transids 1005,1004,1003 (back to front)
Pkt6Ptr pkt;
ASSERT_NO_THROW(pkt = q.peek(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1003, pkt->getTransid());
+ EXPECT_EQ(1003U, pkt->getTransid());
// Peek back should be transid 1005.
ASSERT_NO_THROW(pkt = q.peek(QueueEnd::BACK));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1005, pkt->getTransid());
+ EXPECT_EQ(1005U, pkt->getTransid());
// Pop front should return transid 1003.
ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1003, pkt->getTransid());
+ EXPECT_EQ(1003U, pkt->getTransid());
// Pop back should return transid 1005.
ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::BACK));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1005, pkt->getTransid());
+ EXPECT_EQ(1005U, pkt->getTransid());
// Peek front should be transid 1004.
ASSERT_NO_THROW(pkt = q.peek(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1004, pkt->getTransid());
+ EXPECT_EQ(1004U, pkt->getTransid());
// Peek back should be transid 1004.
ASSERT_NO_THROW(pkt = q.peek(QueueEnd::BACK));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1004, pkt->getTransid());
+ EXPECT_EQ(1004U, pkt->getTransid());
// Pop front should return transid 1004.
ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::FRONT));
ASSERT_TRUE(pkt);
- EXPECT_EQ(1004, pkt->getTransid());
+ EXPECT_EQ(1004U, pkt->getTransid());
// Pop front should return an empty pointer.
ASSERT_NO_THROW(pkt = q.popPacket(QueueEnd::BACK));
// We should be able to enqueue a packet with even numbered values.
Pkt6Ptr pkt(new Pkt6(DHCPV6_SOLICIT, 1002));
ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_even));
- ASSERT_EQ(1, q.getSize());
+ ASSERT_EQ(1U, q.getSize());
// We should be able to enqueue a packet with odd numbered values.
pkt.reset(new Pkt6(DHCPV6_SOLICIT, 1003));
ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_odd));
- ASSERT_EQ(2, q.getSize());
+ ASSERT_EQ(2U, q.getSize());
// Enable drop logic.
q.drop_enabled_ = true;
// We should not be able to add one with an even-numbered transid.
pkt.reset(new Pkt6(DHCPV6_SOLICIT, 1004));
ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_odd));
- ASSERT_EQ(2, q.getSize());
+ ASSERT_EQ(2U, q.getSize());
// We should not be able to add one with from even-numbered port.
pkt.reset(new Pkt6(DHCPV6_SOLICIT, 1005));
ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_even));
- EXPECT_EQ(2, q.getSize());
+ EXPECT_EQ(2U, q.getSize());
// We should be able to add one with an odd-numbered values.
pkt.reset(new Pkt6(DHCPV6_SOLICIT, 1007));
ASSERT_NO_THROW(q.enqueuePacket(pkt, sock_odd));
- EXPECT_EQ(3, q.getSize());
+ EXPECT_EQ(3U, q.getSize());
// Dequeue them and make sure they are as expected: 1002,1003, and 1007.
ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
- EXPECT_EQ(1002, pkt->getTransid());
+ EXPECT_EQ(1002U, pkt->getTransid());
ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
- EXPECT_EQ(1003, pkt->getTransid());
+ EXPECT_EQ(1003U, pkt->getTransid());
ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
- EXPECT_EQ(1007, pkt->getTransid());
+ EXPECT_EQ(1007U, pkt->getTransid());
// Queue should be empty.
ASSERT_NO_THROW(pkt = q.dequeuePacket());
q.eat_count_ = 2;
ASSERT_NO_THROW(pkt = q.dequeuePacket());
ASSERT_TRUE(pkt);
- EXPECT_EQ(1003, pkt->getTransid());
- EXPECT_EQ(2, q.getSize());
+ EXPECT_EQ(1003U, pkt->getTransid());
+ EXPECT_EQ(2U, q.getSize());
}
} // end of anonymous namespace
int64_t value = 0;
ASSERT_NO_THROW(value = elem->intValue());
- EXPECT_EQ(exp_value, value) << "stat: " << name << " is wrong" << std::endl;;
+ int64_t exp_value64 = exp_value;
+ EXPECT_EQ(exp_value64, value)
+ << "stat: " << name << " is wrong" << std::endl;;
}
extern data::ElementPtr makeQueueConfig(const std::string& queue_type, size_t capacity, bool enable_queue=true);
OptionStringPtr option12 = boost::static_pointer_cast<OptionString>(x);
ASSERT_TRUE(option12);
- EXPECT_EQ(12, option12->getType()); // this should be option 12
- ASSERT_EQ(3, option12->getValue().length()); // it should be of length 3
- EXPECT_EQ(5, option12->len()); // total option length 5
+ EXPECT_EQ(12U, option12->getType()); // this should be option 12
+ ASSERT_EQ(3U, option12->getValue().length()); // it should be of length 3
+ EXPECT_EQ(5U, option12->len()); // total option length 5
EXPECT_EQ(0, memcmp(&option12->getValue()[0], opt_data_ptr + 2, 2)); // data len=3
opt_data_ptr += x->len();
// the appropriate conversion.
OptionStringPtr option14 = boost::static_pointer_cast<OptionString>(x);
ASSERT_TRUE(option14);
- EXPECT_EQ(14, option14->getType()); // this should be option 14
- ASSERT_EQ(3, option14->getValue().length()); // it should be of length 3
- EXPECT_EQ(5, option14->len()); // total option length 5
+ EXPECT_EQ(14U, option14->getType()); // this should be option 14
+ ASSERT_EQ(3U, option14->getValue().length()); // it should be of length 3
+ EXPECT_EQ(5U, option14->len()); // total option length 5
EXPECT_EQ(0, memcmp(&option14->getValue()[0], opt_data_ptr + 2, 3)); // data len=3
opt_data_ptr += x->len();
x = pkt->getOption(60);
ASSERT_TRUE(x); // option 60 should exist
- EXPECT_EQ(60, x->getType()); // this should be option 60
- ASSERT_EQ(3, x->getData().size()); // it should be of length 3
- EXPECT_EQ(5, x->len()); // total option length 5
+ EXPECT_EQ(60U, x->getType()); // this should be option 60
+ ASSERT_EQ(3U, x->getData().size()); // it should be of length 3
+ EXPECT_EQ(5U, x->len()); // total option length 5
EXPECT_EQ(0, memcmp(&x->getData()[0], opt_data_ptr + 2, 3)); // data len=3
opt_data_ptr += x->len();
x = pkt->getOption(128);
ASSERT_TRUE(x); // option 3 should exist
- EXPECT_EQ(128, x->getType()); // this should be option 254
- ASSERT_EQ(3, x->getData().size()); // it should be of length 3
- EXPECT_EQ(5, x->len()); // total option length 5
+ EXPECT_EQ(128U, x->getType()); // this should be option 254
+ ASSERT_EQ(3U, x->getData().size()); // it should be of length 3
+ EXPECT_EQ(5U, x->len()); // total option length 5
EXPECT_EQ(0, memcmp(&x->getData()[0], opt_data_ptr + 2, 3)); // data len=3
opt_data_ptr += x->len();
x = pkt->getOption(254);
ASSERT_TRUE(x); // option 3 should exist
- EXPECT_EQ(254, x->getType()); // this should be option 254
- ASSERT_EQ(3, x->getData().size()); // it should be of length 3
- EXPECT_EQ(5, x->len()); // total option length 5
+ EXPECT_EQ(254U, x->getType()); // this should be option 254
+ ASSERT_EQ(3U, x->getData().size()); // it should be of length 3
+ EXPECT_EQ(5U, x->len()); // total option length 5
EXPECT_EQ(0, memcmp(&x->getData()[0], opt_data_ptr + 2, 3)); // data len=3
}
// Option taking extra 3 bytes it is 239
EXPECT_EQ(static_cast<size_t>(Pkt4::DHCPV4_PKT_HDR_LEN) + 3, pkt->len());
EXPECT_EQ(DHCPDISCOVER, pkt->getType());
- EXPECT_EQ(0xffffffff, pkt->getTransid());
+ EXPECT_EQ(0xffffffffU, pkt->getTransid());
EXPECT_NO_THROW(pkt.reset());
// Negative case. Should drop truncated messages.
// Retrieve options with option code 1.
OptionCollection options = pkt->getOptions(1);
- ASSERT_EQ(2, options.size());
+ ASSERT_EQ(2U, options.size());
OptionCollection::const_iterator opt_it;
// Retrieve options with option code 2.
options = pkt->getOptions(2);
- ASSERT_EQ(2, options.size());
+ ASSERT_EQ(2U, options.size());
// opt3 and opt4 should exist.
opt_it = std::find(options.begin(), options.end(),
pkt->setCopyRetrievedOptions(true);
options = pkt->getOptions(1);
- ASSERT_EQ(2, options.size());
+ ASSERT_EQ(2U, options.size());
// Both retrieved options should be copied so an attempt to find them
// using option pointer should fail. Original pointers should have
// Let's check that remaining two options haven't been affected by
// retrieving the options with option code 1.
options = pkt->getOptions(2);
- ASSERT_EQ(2, options.size());
+ ASSERT_EQ(2U, options.size());
opt_it = std::find(options.begin(), options.end(),
std::pair<const unsigned int, OptionPtr>(2, opt3));
Pkt4 pkt(DHCPDISCOVER, 1234);
// By default, the hops and giaddr should be 0.
ASSERT_TRUE(pkt.getGiaddr().isV4Zero());
- ASSERT_EQ(0, pkt.getHops());
+ ASSERT_EQ(0U, pkt.getHops());
// For zero giaddr the packet is non-relayed.
EXPECT_FALSE(pkt.isRelayed());
// Set giaddr but leave hops = 0.
// Add to the first class
pkt.addAdditionalClass(DOCSIS3_CLASS_EROUTER);
- EXPECT_EQ(1, pkt.getAdditionalClasses().size());
+ EXPECT_EQ(1U, pkt.getAdditionalClasses().size());
// Add to a second class
pkt.addAdditionalClass(DOCSIS3_CLASS_MODEM);
- EXPECT_EQ(2, pkt.getAdditionalClasses().size());
+ EXPECT_EQ(2U, pkt.getAdditionalClasses().size());
EXPECT_TRUE(pkt.getAdditionalClasses().contains(DOCSIS3_CLASS_EROUTER));
EXPECT_TRUE(pkt.getAdditionalClasses().contains(DOCSIS3_CLASS_MODEM));
EXPECT_FALSE(pkt.getAdditionalClasses().contains("foo"));
ASSERT_EQ(DHO_VIVSO_SUBOPTIONS, x->getType());
OptionVendorPtr vivso = boost::dynamic_pointer_cast<OptionVendor>(x);
ASSERT_TRUE(vivso);
- EXPECT_EQ(133+2, vivso->len()); // data + opt code + len
+ EXPECT_EQ(133 + 2U, vivso->len()); // data + opt code + len
// Build a bad discover packet
pkt = dhcp::test::PktCaptures::discoverWithTruncatedVIVSO();
// Now let's verify that each text option is as expected.
ASSERT_TRUE(opt = pkt->getOption(DHO_HOST_NAME));
ASSERT_TRUE(opstr = boost::dynamic_pointer_cast<OptionString>(opt));
- EXPECT_EQ(3, opstr->getValue().length());
+ EXPECT_EQ(3U, opstr->getValue().length());
EXPECT_EQ("two", opstr->getValue());
ASSERT_TRUE(opt = pkt->getOption(DHO_MERIT_DUMP));
ASSERT_TRUE(opstr = boost::dynamic_pointer_cast<OptionString>(opt));
- EXPECT_EQ(3, opstr->getValue().length());
+ EXPECT_EQ(3U, opstr->getValue().length());
EXPECT_EQ("one", opstr->getValue());
ASSERT_TRUE(opt = pkt->getOption(DHO_ROOT_PATH));
ASSERT_TRUE(opstr = boost::dynamic_pointer_cast<OptionString>(opt));
- EXPECT_EQ(4, opstr->getValue().length());
+ EXPECT_EQ(4U, opstr->getValue().length());
EXPECT_EQ("none", opstr->getValue());
ASSERT_TRUE(opt = pkt->getOption(DHO_DOMAIN_NAME));
ASSERT_TRUE(opstr = boost::dynamic_pointer_cast<OptionString>(opt));
- EXPECT_EQ(6, opstr->getValue().length());
+ EXPECT_EQ(6U, opstr->getValue().length());
std::string embed{"em\0bed", 6};
EXPECT_EQ(embed, opstr->getValue());
OptionStringPtr opstr;
ASSERT_TRUE(opt = pkt->getOption(14));
ASSERT_TRUE(opstr = boost::dynamic_pointer_cast<OptionString>(opt));
- EXPECT_EQ(3, opstr->getValue().length());
+ EXPECT_EQ(3U, opstr->getValue().length());
EXPECT_EQ("abc", opstr->getValue());
// We should not have option 12.
// We should have option 17 = "def".
ASSERT_TRUE(opt = pkt->getOption(17));
ASSERT_TRUE(opstr = boost::dynamic_pointer_cast<OptionString>(opt));
- EXPECT_EQ(3, opstr->getValue().length());
+ EXPECT_EQ(3U, opstr->getValue().length());
EXPECT_EQ("def", opstr->getValue());
}
uint8_t data[] = { 0, 1, 2, 3, 4, 5 };
scoped_ptr<Pkt6> pkt1(new Pkt6(data, sizeof(data)));
- EXPECT_EQ(6, pkt1->data_.size());
+ EXPECT_EQ(6U, pkt1->data_.size());
EXPECT_EQ(0, memcmp( &pkt1->data_[0], data, sizeof(data)));
}
ASSERT_NO_THROW(sol->unpack());
// Check for length
- EXPECT_EQ(98, sol->len() );
+ EXPECT_EQ(98U, sol->len());
// Check for type
EXPECT_EQ(DHCPV6_SOLICIT, sol->getType() );
ASSERT_NO_THROW(clone->unpack());
// transid, message-type should be the same as before
- EXPECT_EQ(0x020304, clone->getTransid());
+ EXPECT_EQ(0x020304U, clone->getTransid());
EXPECT_EQ(DHCPV6_SOLICIT, clone->getType());
EXPECT_TRUE(clone->getOption(1));
parent->addOption(opt3);
OptionCollection options = parent->getOptions(2);
- EXPECT_EQ(2, options.size()); // there should be 2 instances
+ EXPECT_EQ(2U, options.size()); // there should be 2 instances
// Both options must be of type 2 and there must not be
// any other type returned
for (auto const& x : options) {
- EXPECT_EQ(2, x.second->getType());
+ EXPECT_EQ(2U, x.second->getType());
}
// Try to get a single option. Normally for singular options
// it is better to use getOption(), but getOptions() must work
// as well
options = parent->getOptions(1);
- ASSERT_EQ(1, options.size());
+ ASSERT_EQ(1U, options.size());
- EXPECT_EQ(1, (*options.begin()).second->getType());
+ EXPECT_EQ(1U, (*options.begin()).second->getType());
EXPECT_EQ(opt1, options.begin()->second);
// Let's delete one of them
- EXPECT_EQ(true, parent->delOption(2));
+ EXPECT_TRUE(parent->delOption(2));
// There still should be the other option 2
EXPECT_NE(OptionPtr(), parent->getOption(2));
// Let's delete the other option 2
- EXPECT_EQ(true, parent->delOption(2));
+ EXPECT_TRUE(parent->delOption(2));
// No more options with type=2
EXPECT_EQ(OptionPtr(), parent->getOption(2));
// Let's try to delete - should fail
- EXPECT_TRUE(false == parent->delOption(2));
+ EXPECT_FALSE(parent->delOption(2));
// Finally try to get a non-existent option
options = parent->getOptions(1234);
- EXPECT_EQ(0, options.size());
+ EXPECT_EQ(0U, options.size());
}
// Check that multiple options of the same type may be retrieved by using
// Retrieve options with option code 1.
OptionCollection options = pkt.getOptions(1);
- ASSERT_EQ(2, options.size());
+ ASSERT_EQ(2U, options.size());
OptionCollection::const_iterator opt_it;
pkt.setCopyRetrievedOptions(true);
options = pkt.getOptions(1);
- ASSERT_EQ(2, options.size());
+ ASSERT_EQ(2U, options.size());
// Both retrieved options should be copied so an attempt to find them
// using option pointer should fail. Original pointers should have
// Let's check that remaining two options haven't been affected by
// retrieving the options with option code 1.
options = pkt.getNonCopiedOptions(2);
- ASSERT_EQ(2, options.size());
+ ASSERT_EQ(2U, options.size());
opt_it = std::find(options.begin(), options.end(),
std::pair<const unsigned int, OptionPtr>(2, opt3));
EXPECT_NO_THROW(msg->unpack());
EXPECT_EQ(DHCPV6_SOLICIT, msg->getType());
- EXPECT_EQ(217, msg->len());
+ EXPECT_EQ(217U, msg->len());
- ASSERT_EQ(2, msg->relay_info_.size());
+ ASSERT_EQ(2U, msg->relay_info_.size());
OptionPtr opt;
// Part 1: Check options inserted by the first relay
// There should be 2 options in first relay
- EXPECT_EQ(2, msg->relay_info_[0].options_.size());
+ EXPECT_EQ(2U, msg->relay_info_[0].options_.size());
// There should be interface-id option
- EXPECT_EQ(1, msg->getRelayOptions(D6O_INTERFACE_ID, 0).size());
+ EXPECT_EQ(1U, msg->getRelayOptions(D6O_INTERFACE_ID, 0).size());
ASSERT_TRUE(opt = msg->getRelayOption(D6O_INTERFACE_ID, 0));
OptionBuffer data = opt->getData();
- EXPECT_EQ(32, opt->len()); // 28 bytes of data + 4 bytes header
- EXPECT_EQ(data.size(), 28);
+ EXPECT_EQ(32U, opt->len()); // 28 bytes of data + 4 bytes header
+ EXPECT_EQ(data.size(), 28U);
// That's a strange interface-id, but this is a real life example
EXPECT_TRUE(0 == memcmp("ISAM144|299|ipv6|nt:vp:1:110", &data[0], 28));
// Get the remote-id option
- EXPECT_EQ(1, msg->getRelayOptions(D6O_REMOTE_ID, 0).size());
+ EXPECT_EQ(1U, msg->getRelayOptions(D6O_REMOTE_ID, 0).size());
ASSERT_TRUE(opt = msg->getRelayOption(D6O_REMOTE_ID, 0));
- EXPECT_EQ(22, opt->len()); // 18 bytes of data + 4 bytes header
+ EXPECT_EQ(22U, opt->len()); // 18 bytes of data + 4 bytes header
boost::shared_ptr<OptionCustom> custom = boost::dynamic_pointer_cast<OptionCustom>(opt);
uint32_t vendor_id = custom->readInteger<uint32_t>(0);
- EXPECT_EQ(6527, vendor_id); // 6527 = Panthera Networks
+ EXPECT_EQ(6527U, vendor_id); // 6527 = Panthera Networks
uint8_t expected_remote_id[] = { 0x00, 0x01, 0x00, 0x01, 0x18, 0xb0,
0x33, 0x41, 0x00, 0x00, 0x21, 0x5c,
// Part 2: Check options inserted by the second relay
// Get the interface-id from the second relay
- EXPECT_EQ(1, msg->getRelayOptions(D6O_INTERFACE_ID, 1).size());
+ EXPECT_EQ(1U, msg->getRelayOptions(D6O_INTERFACE_ID, 1).size());
ASSERT_TRUE(opt = msg->getRelayOption(D6O_INTERFACE_ID, 1));
data = opt->getData();
- EXPECT_EQ(25, opt->len()); // 21 bytes + 4 bytes header
- EXPECT_EQ(data.size(), 21);
+ EXPECT_EQ(25U, opt->len()); // 21 bytes + 4 bytes header
+ EXPECT_EQ(data.size(), 21U);
EXPECT_TRUE(0 == memcmp("ISAM144 eth 1/1/05/01", &data[0], 21));
// Get the remote-id option
- EXPECT_EQ(1, msg->getRelayOptions(D6O_REMOTE_ID, 1).size());
+ EXPECT_EQ(1U, msg->getRelayOptions(D6O_REMOTE_ID, 1).size());
ASSERT_TRUE(opt = msg->getRelayOption(D6O_REMOTE_ID, 1));
- EXPECT_EQ(8, opt->len());
+ EXPECT_EQ(8U, opt->len());
custom = boost::dynamic_pointer_cast<OptionCustom>(opt);
vendor_id = custom->readInteger<uint32_t>(0);
- EXPECT_EQ(3561, vendor_id); // 3561 = Broadband Forum
+ EXPECT_EQ(3561U, vendor_id); // 3561 = Broadband Forum
// @todo: See if we can validate empty remote-id field
// Let's check if there is no leak between options stored in
// This is not redundant compared to other direct messages tests,
// as we parsed it differently
EXPECT_EQ(DHCPV6_SOLICIT, msg->getType());
- EXPECT_EQ(0x6b4fe2, msg->getTransid());
+ EXPECT_EQ(0x6b4fe2U, msg->getTransid());
ASSERT_TRUE(opt = msg->getOption(D6O_CLIENTID));
- EXPECT_EQ(18, opt->len()); // 14 bytes of data + 4 bytes of header
+ EXPECT_EQ(18U, opt->len()); // 14 bytes of data + 4 bytes of header
uint8_t expected_client_id[] = { 0x00, 0x01, 0x00, 0x01, 0x18, 0xb0,
0x33, 0x41, 0x00, 0x00, 0x21, 0x5c,
0x18, 0xa9 };
boost::shared_ptr<Option6IA> ia =
boost::dynamic_pointer_cast<Option6IA>(opt);
ASSERT_TRUE(ia);
- EXPECT_EQ(1, ia->getIAID());
- EXPECT_EQ(0xffffffff, ia->getT1());
- EXPECT_EQ(0xffffffff, ia->getT2());
+ EXPECT_EQ(1U, ia->getIAID());
+ EXPECT_EQ(0xffffffffU, ia->getT1());
+ EXPECT_EQ(0xffffffffU, ia->getT2());
ASSERT_TRUE(opt = msg->getOption(D6O_ELAPSED_TIME));
- EXPECT_EQ(6, opt->len()); // 2 bytes of data + 4 bytes of header
+ EXPECT_EQ(6U, opt->len()); // 2 bytes of data + 4 bytes of header
boost::shared_ptr<OptionInt<uint16_t> > elapsed =
boost::dynamic_pointer_cast<OptionInt<uint16_t> > (opt);
ASSERT_TRUE(elapsed);
- EXPECT_EQ(0, elapsed->getValue());
+ EXPECT_EQ(0U, elapsed->getValue());
ASSERT_TRUE(opt = msg->getOption(D6O_ORO));
boost::shared_ptr<OptionIntArray<uint16_t> > oro =
boost::dynamic_pointer_cast<OptionIntArray<uint16_t> > (opt);
const std::vector<uint16_t> oro_list = oro->getValues();
- EXPECT_EQ(3, oro_list.size());
- EXPECT_EQ(23, oro_list[0]);
- EXPECT_EQ(242, oro_list[1]);
- EXPECT_EQ(243, oro_list[2]);
+ EXPECT_EQ(3U, oro_list.size());
+ EXPECT_EQ(23U, oro_list[0]);
+ EXPECT_EQ(242U, oro_list[1]);
+ EXPECT_EQ(243U, oro_list[2]);
}
// This test verified that message with relay information can be
EXPECT_FALSE(clone->getOption(103));
// Now check relay info
- ASSERT_EQ(1, clone->relay_info_.size());
+ ASSERT_EQ(1U, clone->relay_info_.size());
EXPECT_EQ(DHCPV6_RELAY_REPL, clone->relay_info_[0].msg_type_);
- EXPECT_EQ(17, clone->relay_info_[0].hop_count_);
+ EXPECT_EQ(17U, clone->relay_info_[0].hop_count_);
EXPECT_EQ("2001:db8::1", clone->relay_info_[0].linkaddr_.toText());
EXPECT_EQ("fe80::abcd", clone->relay_info_[0].peeraddr_.toText());
// There should be exactly one option
- EXPECT_EQ(1, clone->relay_info_[0].options_.size());
- EXPECT_EQ(1, clone->getRelayOptions(200, 0).size());
+ EXPECT_EQ(1U, clone->relay_info_[0].options_.size());
+ EXPECT_EQ(1U, clone->getRelayOptions(200, 0).size());
OptionPtr opt = clone->getRelayOption(200, 0);
EXPECT_TRUE(opt);
EXPECT_EQ(opt->getType() , optRelay1->getType());
ASSERT_TRUE(msg);
ASSERT_NO_THROW(msg->unpack());
- ASSERT_EQ(2, msg->relay_info_.size());
+ ASSERT_EQ(2U, msg->relay_info_.size());
OptionPtr opt_iface_id = msg->getNonCopiedRelayOption(D6O_INTERFACE_ID, 0);
ASSERT_TRUE(opt_iface_id);
ASSERT_TRUE(msg);
ASSERT_NO_THROW(msg->unpack());
- ASSERT_EQ(2, msg->relay_info_.size());
+ ASSERT_EQ(2U, msg->relay_info_.size());
OptionCollection opts_iface_id =
msg->getNonCopiedRelayOptions(D6O_INTERFACE_ID, 0);
- ASSERT_EQ(1, opts_iface_id.size());
+ ASSERT_EQ(1U, opts_iface_id.size());
OptionPtr opt_iface_id = msg->getNonCopiedRelayOption(D6O_INTERFACE_ID, 0);
ASSERT_TRUE(opt_iface_id);
OptionCollection opts_iface_id_returned =
msg->getRelayOptions(D6O_INTERFACE_ID, 0);
- ASSERT_EQ(1, opts_iface_id_returned.size());
+ ASSERT_EQ(1U, opts_iface_id_returned.size());
OptionPtr opt_iface_id_returned = msg->getRelayOption(D6O_INTERFACE_ID, 0);
ASSERT_TRUE(opt_iface_id_returned);
msg->setCopyRetrievedOptions(true);
opts_iface_id_returned = msg->getRelayOptions(D6O_INTERFACE_ID, 0);
- ASSERT_EQ(1, opts_iface_id_returned.size());
+ ASSERT_EQ(1U, opts_iface_id_returned.size());
opt_iface_id_returned = msg->getRelayOption(D6O_INTERFACE_ID, 0);
EXPECT_FALSE(opt_iface_id == opt_iface_id_returned);
EXPECT_FALSE(opts_iface_id.begin()->second == opt_iface_id_returned);
// Check collections.
OptionCollection opts0 =
msg->getNonCopiedAllRelayOptions(200, Pkt6::RELAY_SEARCH_FROM_CLIENT);
- EXPECT_EQ(3, opts0.size());
+ EXPECT_EQ(3U, opts0.size());
vector<OptionPtr> lopts0;
for (auto const& it : opts0) {
lopts0.push_back(it.second);
}
- ASSERT_EQ(3, lopts0.size());
+ ASSERT_EQ(3U, lopts0.size());
EXPECT_TRUE(lopts0[0] == opt);
EXPECT_TRUE(lopts0[0] == relay3_opt1);
EXPECT_TRUE(lopts0[1] == relay2_opt4);
// Check collections.
opts = msg->getNonCopiedAllRelayOptions(200, Pkt6::RELAY_SEARCH_FROM_SERVER);
- EXPECT_EQ(3, opts.size());
+ EXPECT_EQ(3U, opts.size());
vector<OptionPtr> lopts;
for (auto const& it : opts) {
lopts.push_back(it.second);
}
- ASSERT_EQ(3, lopts.size());
+ ASSERT_EQ(3U, lopts.size());
EXPECT_TRUE(lopts[0] == opt);
EXPECT_TRUE(lopts[0] == relay1_opt1);
EXPECT_TRUE(lopts[1] == relay2_opt4);
EXPECT_TRUE(opt->equals(relay3_opt1));
EXPECT_TRUE(opt == relay3_opt1);
opts = msg->getNonCopiedAllRelayOptions(200, Pkt6::RELAY_GET_FIRST);
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
EXPECT_TRUE(opt == opts.begin()->second);
opts = msg->getAllRelayOptions(200, Pkt6::RELAY_GET_FIRST);
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
EXPECT_TRUE(opts.begin()->second == relay3_opt1);
// We just want option from the last relay (closest to the server)
EXPECT_TRUE(opt->equals(relay1_opt1));
EXPECT_TRUE(opt == relay1_opt1);
opts = msg->getNonCopiedAllRelayOptions(200, Pkt6::RELAY_GET_LAST);
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
EXPECT_TRUE(opt == opts.begin()->second);
opts = msg->getAllRelayOptions(200, Pkt6::RELAY_GET_LAST);
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
EXPECT_TRUE(opts.begin()->second == relay1_opt1);
// Enable copying options when they are retrieved and redo the tests
for (auto const& it : opts) {
lopts0.push_back(it.second);
}
- ASSERT_EQ(3, lopts0.size());
+ ASSERT_EQ(3U, lopts0.size());
EXPECT_TRUE(lopts0[0] == opt);
EXPECT_TRUE(lopts0[0] == relay3_opt1);
EXPECT_TRUE(lopts0[1] == relay2_opt4);
for (auto const& it : opts) {
lopts.push_back(it.second);
}
- ASSERT_EQ(3, lopts.size());
+ ASSERT_EQ(3U, lopts.size());
EXPECT_TRUE(relay3_opt1->equals(lopts[0]));
EXPECT_FALSE(lopts[0] == lopts0[0]);
EXPECT_TRUE(relay2_opt4->equals(lopts[1]));
for (auto const& it : opts) {
lopts0.push_back(it.second);
}
- ASSERT_EQ(3, lopts0.size());
+ ASSERT_EQ(3U, lopts0.size());
EXPECT_TRUE(lopts0[0] == opt);
EXPECT_TRUE(lopts0[0] == relay1_opt1);
EXPECT_TRUE(lopts0[1] == relay2_opt4);
for (auto const& it : opts) {
lopts.push_back(it.second);
}
- ASSERT_EQ(3, lopts.size());
+ ASSERT_EQ(3U, lopts.size());
EXPECT_TRUE(relay1_opt1->equals(lopts[0]));
EXPECT_FALSE(lopts[0] == lopts0[0]);
EXPECT_TRUE(relay2_opt4->equals(lopts[1]));
ASSERT_TRUE(relay3_opt1);
EXPECT_TRUE(opt == relay3_opt1);
opts = msg->getNonCopiedAllRelayOptions(200, Pkt6::RELAY_GET_FIRST);
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
EXPECT_TRUE(opt == opts.begin()->second);
opts = msg->getAllRelayOptions(200, Pkt6::RELAY_GET_FIRST);
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
EXPECT_FALSE(opts.begin()->second == relay3_opt1);
relay3_opt1 = msg->getNonCopiedAnyRelayOption(200, Pkt6::RELAY_GET_FIRST);
EXPECT_TRUE(opts.begin()->second == relay3_opt1);
ASSERT_TRUE(relay1_opt1);
EXPECT_TRUE(opt == relay1_opt1);
opts = msg->getNonCopiedAllRelayOptions(200, Pkt6::RELAY_GET_LAST);
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
EXPECT_TRUE(opt == opts.begin()->second);
opts = msg->getAllRelayOptions(200, Pkt6::RELAY_GET_LAST);
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
EXPECT_FALSE(opts.begin()->second == relay1_opt1);
relay1_opt1 = msg->getNonCopiedAnyRelayOption(200, Pkt6::RELAY_GET_LAST);
EXPECT_TRUE(opts.begin()->second == relay1_opt1);
ASSERT_TRUE(opt);
EXPECT_TRUE(opt->equals(relay2_opt1));
opts = msg->getNonCopiedAllRelayOptions(100, Pkt6::RELAY_SEARCH_FROM_SERVER);
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
EXPECT_TRUE(opts.begin()->second == relay2_opt1);
opts = msg->getAllRelayOptions(100, Pkt6::RELAY_SEARCH_FROM_SERVER);
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
EXPECT_TRUE(relay2_opt1->equals(opts.begin()->second));
opt = msg->getAnyRelayOption(100, Pkt6::RELAY_SEARCH_FROM_CLIENT);
ASSERT_TRUE(opt);
EXPECT_TRUE(opt->equals(relay2_opt1));
opts = msg->getNonCopiedAllRelayOptions(100, Pkt6::RELAY_SEARCH_FROM_CLIENT);
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
EXPECT_TRUE(opts.begin()->second == relay2_opt1);
opts = msg->getAllRelayOptions(100, Pkt6::RELAY_SEARCH_FROM_SERVER);
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
EXPECT_TRUE(relay2_opt1->equals(opts.begin()->second));
opt = msg->getAnyRelayOption(100, Pkt6::RELAY_GET_FIRST);
Pkt6Ptr msg(capture2());
EXPECT_NO_THROW(msg->unpack());
- ASSERT_EQ(2, msg->relay_info_.size());
+ ASSERT_EQ(2U, msg->relay_info_.size());
string expected =
"local_address=[ff05::1:3]:547, remote_address=[fe80::1234]:547,\n"
// Add to the first class
pkt.addAdditionalClass(DOCSIS3_CLASS_EROUTER);
- EXPECT_EQ(1, pkt.getAdditionalClasses().size());
+ EXPECT_EQ(1U, pkt.getAdditionalClasses().size());
// Add to a second class
pkt.addAdditionalClass(DOCSIS3_CLASS_MODEM);
- EXPECT_EQ(2, pkt.getAdditionalClasses().size());
+ EXPECT_EQ(2U, pkt.getAdditionalClasses().size());
EXPECT_TRUE(pkt.getAdditionalClasses().contains(DOCSIS3_CLASS_EROUTER));
EXPECT_TRUE(pkt.getAdditionalClasses().contains(DOCSIS3_CLASS_MODEM));
EXPECT_FALSE(pkt.getAdditionalClasses().contains("foo"));
// ... and pretend it was relayed by a single relay.
Pkt6::RelayInfo info;
pkt.addRelayInfo(info);
- ASSERT_EQ(1, pkt.relay_info_.size());
+ ASSERT_EQ(1U, pkt.relay_info_.size());
// Let's get the first interface
IfacePtr iface = IfaceMgr::instance().getIface(1);
// the client. The method should get that address and build MAC from it.
info.peeraddr_ = linklocal1;
pkt.addRelayInfo(info);
- ASSERT_EQ(3, pkt.relay_info_.size());
+ ASSERT_EQ(3U, pkt.relay_info_.size());
// Let's get the first interface
IfacePtr iface = IfaceMgr::instance().getIface(1);
info.options_.insert(make_pair(relay_opt->getType(), relay_opt));
pkt.addRelayInfo(info);
- ASSERT_EQ(1, pkt.relay_info_.size());
+ ASSERT_EQ(1U, pkt.relay_info_.size());
HWAddrPtr found = pkt.getMAC(HWAddr::HWADDR_SOURCE_CLIENT_ADDR_RELAY_OPTION);
ASSERT_TRUE(found);
// Second relay, closest to the client has not implemented RFC6939
Pkt6::RelayInfo info2;
pkt.addRelayInfo(info2);
- ASSERT_EQ(2, pkt.relay_info_.size());
+ ASSERT_EQ(2U, pkt.relay_info_.size());
EXPECT_FALSE(pkt.getMAC(HWAddr::HWADDR_SOURCE_CLIENT_ADDR_RELAY_OPTION));
OptionBuffer(opt_data, opt_data + sizeof(opt_data))));
info3.options_.insert(make_pair(relay_opt3->getType(), relay_opt3));
pkt.addRelayInfo(info3);
- ASSERT_EQ(3, pkt.relay_info_.size());
+ ASSERT_EQ(3U, pkt.relay_info_.size());
// Now extract the MAC address from the relayed option
HWAddrPtr found = pkt.getMAC(HWAddr::HWADDR_SOURCE_CLIENT_ADDR_RELAY_OPTION);
// First simulate relaying message without adding remote-id option
Pkt6::RelayInfo info;
pkt.addRelayInfo(info);
- ASSERT_EQ(1, pkt.relay_info_.size());
+ ASSERT_EQ(1U, pkt.relay_info_.size());
// This should fail as the remote-id option isn't there
EXPECT_FALSE(pkt.getMAC(HWAddr::HWADDR_SOURCE_REMOTE_ID));
// Now add this option to the relayed message
info.options_.insert(make_pair(relay_opt->getType(), relay_opt));
pkt.addRelayInfo(info);
- ASSERT_EQ(2, pkt.relay_info_.size());
+ ASSERT_EQ(2U, pkt.relay_info_.size());
// This should work now
HWAddrPtr mac = pkt.getMAC(HWAddr::HWADDR_SOURCE_REMOTE_ID);
// First simulate relaying message without adding remote-id option
Pkt6::RelayInfo info;
pkt.addRelayInfo(info);
- ASSERT_EQ(1, pkt.relay_info_.size());
+ ASSERT_EQ(1U, pkt.relay_info_.size());
// This should fail as the remote-id option isn't there
EXPECT_FALSE(pkt.getMAC(HWAddr::HWADDR_SOURCE_REMOTE_ID));
// Now add this option to the relayed message
info.options_.insert(make_pair(relay_opt->getType(), relay_opt));
pkt.addRelayInfo(info);
- ASSERT_EQ(2, pkt.relay_info_.size());
+ ASSERT_EQ(2U, pkt.relay_info_.size());
// This should work now
HWAddrPtr mac = pkt.getMAC(HWAddr::HWADDR_SOURCE_REMOTE_ID);
EXPECT_NO_THROW(msg->unpack());
EXPECT_EQ(DHCPV6_SOLICIT, msg->getType());
- EXPECT_EQ(217, msg->len());
+ EXPECT_EQ(217U, msg->len());
- ASSERT_EQ(2, msg->relay_info_.size());
+ ASSERT_EQ(2U, msg->relay_info_.size());
// There should be an RSOO option in the outermost relay
OptionPtr opt = msg->getRelayOption(D6O_RSOO, 1);
EXPECT_EQ(D6O_RSOO, opt->getType());
const OptionCollection& rsoo = opt->getOptions();
- ASSERT_EQ(2, rsoo.size());
+ ASSERT_EQ(2U, rsoo.size());
OptionPtr rsoo1 = opt->getOption(255);
OptionPtr rsoo2 = opt->getOption(256);
ASSERT_TRUE(rsoo1);
ASSERT_TRUE(rsoo2);
- EXPECT_EQ(8, rsoo1->len()); // 4 bytes of data + header
- EXPECT_EQ(13, rsoo2->len()); // 9 bytes of data + header
-
+ EXPECT_EQ(8U, rsoo1->len()); // 4 bytes of data + header
+ EXPECT_EQ(13U, rsoo2->len()); // 9 bytes of data + header
}
// Verify that the DUID can be extracted from the DHCPv6 packet
ASSERT_EQ(D6O_VENDOR_OPTS, x->getType());
OptionVendorPtr vivso = boost::dynamic_pointer_cast<OptionVendor>(x);
ASSERT_TRUE(vivso);
- EXPECT_EQ(8, vivso->len()); // data + opt code + len
+ EXPECT_EQ(8U, vivso->len()); // data + opt code + len
// Build a bad Solicit packet
pkt = dhcp::test::PktCaptures::captureSolicitWithTruncatedVIVSO();
OptionStringPtr opstr;
ASSERT_TRUE(opt = pkt->getOption(41));
ASSERT_TRUE(opstr = boost::dynamic_pointer_cast<OptionString>(opt));
- EXPECT_EQ(3, opstr->getValue().length());
+ EXPECT_EQ(3U, opstr->getValue().length());
EXPECT_EQ("abc", opstr->getValue());
// We should not have option 59.
// We should have option 42 = "def".
ASSERT_TRUE(opt = pkt->getOption(42));
ASSERT_TRUE(opstr = boost::dynamic_pointer_cast<OptionString>(opt));
- EXPECT_EQ(3, opstr->getValue().length());
+ EXPECT_EQ(3U, opstr->getValue().length());
EXPECT_EQ("def", opstr->getValue());
}
// return the number of bytes sent, which is equal to the size of our
// message.
ASSERT_EQ(sendmsg(send_msg_sock_, &m, 0),
- test_message_->getBuffer().getLength());
+ static_cast<ssize_t>(test_message_->getBuffer().getLength()));
close(send_msg_sock_);
send_msg_sock_ = -1;
// Address Family pseudo header contains the address family of the
// packet (used for local loopback interface instead of the link-layer
// header such as ethernet frame header).
- uint32_t af = 0;
- memcpy(static_cast<void*>(&af),
- static_cast<void*>(rcv_buf + bpfh_len), 4);
+ int32_t af = 0;
+ memcpy(static_cast<void*>(&af), static_cast<void*>(rcv_buf + bpfh_len), 4);
// Check the value in the pseudo header. If this is incorrect, something
// is really broken, so let's exit.
ASSERT_EQ(AF_INET, af);
ASSERT_EQ(sendto(send_msg_sock_, test_message_->getBuffer().getData(),
test_message_->getBuffer().getLength(), 0,
reinterpret_cast<struct sockaddr*>(&dest_addr4),
- sizeof(sockaddr)), test_message_->getBuffer().getLength());
+ sizeof(sockaddr)),
+ static_cast<ssize_t>(test_message_->getBuffer().getLength()));
close(send_msg_sock_);
send_msg_sock_ = -1;
// Get the actual checksum.
uint16_t chksum = ~calcChecksum(hdr, hdr_size);
// The 0xb1e6 value has been calculated by other means.
- EXPECT_EQ(0xb1e6, chksum);
+ EXPECT_EQ(0xb1e6U, chksum);
// Tested function may also take the initial value of the sum.
// Let's set it to 2 and see whether it is included in the
// calculation.
chksum = ~calcChecksum(hdr, hdr_size, 2);
// The checksum value should change.
- EXPECT_EQ(0xb1e4, chksum);
+ EXPECT_EQ(0xb1e4U, chksum);
}
// The purpose of this test is to verify that the Ethernet frame header
ASSERT_EQ(ETHERNET_HEADER_LEN, in_buf.getPosition());
// And the dummy data should be still readable and correct.
uint32_t dummy_data = in_buf.readUint32();
- EXPECT_EQ(0x01020304, dummy_data);
+ EXPECT_EQ(0x01020304U, dummy_data);
}
/// The purpose of this test is to verify that the IP and UDP header
// Verify the source address and port.
EXPECT_EQ("192.0.2.99", pkt->getRemoteAddr().toText());
- EXPECT_EQ(10068, pkt->getRemotePort());
+ EXPECT_EQ(10068U, pkt->getRemotePort());
// Verify the destination address and port.
EXPECT_EQ("192.0.2.12", pkt->getLocalAddr().toText());
- EXPECT_EQ(10067, pkt->getLocalPort());
+ EXPECT_EQ(10067U, pkt->getLocalPort());
// Verify that the dummy data has not been corrupted and that the
// internal read pointer has been moved to the tail of the UDP
// header.
ASSERT_EQ(MIN_IP_HEADER_LEN + UDP_HEADER_LEN, in_buf.getPosition());
- EXPECT_EQ(0x01020304, in_buf.readUint32());
+ EXPECT_EQ(0x01020304U, in_buf.readUint32());
}
/// The purpose of this test is to verify that the ethernet
// The resulting ethernet header consists of destination
// and src HW address (each 6 bytes long) and two bytes
// of encapsulated protocol type.
- ASSERT_EQ(14, buf.getLength());
+ ASSERT_EQ(14U, buf.getLength());
// Verify that first 6 bytes comprise valid destination
// HW address. Instead of using memory comparison functions
// The last two bytes comprise the encapsulated protocol type.
// We expect IPv4 protocol type which is specified by 0x0800.
- EXPECT_EQ(0x08, buf[12]);
- EXPECT_EQ(0x0, buf[13]);
+ EXPECT_EQ(0x08U, buf[12]);
+ EXPECT_EQ(0U, buf[13]);
}
/// The purpose of this test is to verify that the ethernet
// The resulting ethernet header consists of destination
// and src HW address (each 6 bytes long) and two bytes
// of encapsulated protocol type.
- ASSERT_EQ(14, buf.getLength());
+ ASSERT_EQ(14U, buf.getLength());
// Verify that first 6 bytes comprise broadcast destination
// HW address.
for (unsigned i = 0; i < 6; ++i) {
- EXPECT_EQ(255, buf[i]);
+ EXPECT_EQ(255U, buf[i]);
}
// Verify that following 6 bytes comprise the valid source
// The last two bytes comprise the encapsulated protocol type.
// We expect IPv4 protocol type which is specified by 0x0800.
- EXPECT_EQ(0x08, buf[12]);
- EXPECT_EQ(0x0, buf[13]);
+ EXPECT_EQ(0x08U, buf[12]);
+ EXPECT_EQ(0U, buf[13]);
}
/// The purpose of this test is to verify that the ethernet
// The resulting ethernet header consists of destination
// and src HW address (each 6 bytes long) and two bytes
// of encapsulated protocol type.
- ASSERT_EQ(14, buf.getLength());
+ ASSERT_EQ(14U, buf.getLength());
// Verify that first 6 bytes comprise valid destination
// HW address. Instead of using memory comparison functions
// The last two bytes comprise the encapsulated protocol type.
// We expect IPv4 protocol type which is specified by 0x0800.
- EXPECT_EQ(0x08, buf[12]);
- EXPECT_EQ(0x0, buf[13]);
+ EXPECT_EQ(0x08U, buf[12]);
+ EXPECT_EQ(0U, buf[13]);
}
TEST(ProtocolUtilTest, writeIpUdpHeader) {
// The resulting size of the buffer must be 30. The 28 bytes are
// consumed by the IP and UDP headers. The other 2 bytes are dummy
// data at the beginning of the buffer.
- ASSERT_EQ(30, buf.getLength());
+ ASSERT_EQ(30U, buf.getLength());
// Make sure that the existing data in the buffer was not corrupted
// by the function under test.
- EXPECT_EQ(0x01, buf[0]);
- EXPECT_EQ(0x02, buf[1]);
+ EXPECT_EQ(0x01U, buf[0]);
+ EXPECT_EQ(0x02U, buf[1]);
// Copy the contents of the buffer to InputBuffer object. This object
// exposes convenient functions for reading.
// Check dummy data.
uint16_t dummy_data = in_buf.readUint16();
- EXPECT_EQ(0x0102, dummy_data);
+ EXPECT_EQ(0x0102U, dummy_data);
// The IP version and IHL are stored in the same octet (4 bits each).
uint8_t ver_len = in_buf.readUint8();
// The most significant bits define IP version.
uint8_t ip_ver = ver_len >> 4;
- EXPECT_EQ(4, ip_ver);
+ EXPECT_EQ(4U, ip_ver);
// The least significant bits define header length (in 32-bits chunks).
uint8_t ip_len = ver_len & 0x0F;
- EXPECT_EQ(5, ip_len);
+ EXPECT_EQ(5U, ip_len);
// Get Differentiated Services Codepoint and Explicit Congestion
// Notification field.
// Identification field.
uint16_t ident = in_buf.readUint16();
- EXPECT_EQ(0, ident);
+ EXPECT_EQ(0U, ident);
// Fragmentation.
uint16_t fragment = in_buf.readUint16();
// Setting second most significant bit means no fragmentation.
- EXPECT_EQ(0x4000, fragment);
+ EXPECT_EQ(0x4000U, fragment);
// Get TTL
uint8_t ttl = in_buf.readUint8();
// Expect non-zero TTL.
- EXPECT_GE(ttl, 1);
+ EXPECT_GE(ttl, 1U);
// Protocol type is UDP.
uint8_t proto = in_buf.readUint8();
// Check that the checksum is correct. The reference checksum value
// has been calculated manually.
uint16_t ip_checksum = in_buf.readUint16();
- EXPECT_EQ(0x755c, ip_checksum);
+ EXPECT_EQ(0x755cU, ip_checksum);
// Validate source address.
// Initializing it to IPv6 address guarantees that it is not initialized
// Verify UDP checksum. The reference checksum has been calculated manually.
uint16_t udp_checksum = in_buf.readUint16();
- EXPECT_EQ(0x8817, udp_checksum);
+ EXPECT_EQ(0x8817U, udp_checksum);
}
/// Test that checks the RAII implementation of ScopedEnableOptionsCopy works
pkt->addOption(option);
OptionCollection options = pkt->options_;
size_t count = options.size();
- ASSERT_NE(0, count);
+ ASSERT_NE(0U, count);
ASSERT_EQ(option, pkt->getOption(DHO_BOOT_FILE_NAME));
std::string expected = pkt->toText();
pkt->pack();
pkt->addOption(option);
OptionCollection options = pkt->options_;
size_t count = options.size();
- ASSERT_NE(0, count);
+ ASSERT_NE(0U, count);
ASSERT_EQ(option, pkt->getOption(D6O_BOOTFILE_URL));
std::string expected = pkt->toText();
pkt->pack();
initial->addOption(option);
OptionCollection options = initial->getOptions();
size_t count = options.size();
- ASSERT_NE(0, count);
+ ASSERT_NE(0U, count);
ASSERT_EQ(option, initial->getOption(DHO_BOOT_FILE_NAME));
{
ScopedSubOptionsCopy oc(initial);
projects / thirdparty / kea.git / commitdiff
