// We should have received a signed response.
ASSERT_TRUE(response_);
EXPECT_EQ(D2UpdateMessage::RESPONSE, response_->getQRFlag());
- ASSERT_EQ(1, response_->getRRCount(D2UpdateMessage::SECTION_ZONE));
+ ASSERT_EQ(1U, response_->getRRCount(D2UpdateMessage::SECTION_ZONE));
D2ZonePtr zone = response_->getZone();
ASSERT_TRUE(zone);
EXPECT_EQ("example.com.", zone->getName().toText());
// We should have received an unsigned response.
ASSERT_TRUE(response_);
EXPECT_EQ(D2UpdateMessage::RESPONSE, response_->getQRFlag());
- ASSERT_EQ(1, response_->getRRCount(D2UpdateMessage::SECTION_ZONE));
+ ASSERT_EQ(1U, response_->getRRCount(D2UpdateMessage::SECTION_ZONE));
D2ZonePtr zone = response_->getZone();
ASSERT_FALSE(zone);
}
EXPECT_NO_THROW(buf.reset(new GssApiBuffer()));
ASSERT_TRUE(buf);
ASSERT_TRUE(buf->getPtr());
- EXPECT_EQ(0, buf->getLength());
+ EXPECT_EQ(0U, buf->getLength());
EXPECT_FALSE(buf->getValue());
EXPECT_TRUE(buf->empty());
const vector<uint8_t>& empty = buf->getContent();
- EXPECT_EQ(0, empty.size());
+ EXPECT_EQ(0U, empty.size());
const vector<uint8_t>& test = { 1, 2, 3, 0 };
EXPECT_NO_THROW(buf.reset(new GssApiBuffer(test)));
ASSERT_TRUE(buf);
ASSERT_TRUE(buf->getPtr());
- EXPECT_EQ(4, buf->getLength());
+ EXPECT_EQ(4U, buf->getLength());
EXPECT_TRUE(buf->getValue());
EXPECT_FALSE(buf->empty());
const vector<uint8_t>& content = buf->getContent();
- ASSERT_EQ(4, content.size());
+ ASSERT_EQ(4U, content.size());
EXPECT_EQ(0, memcmp(&test[0], &content[0], 4));
const string& strpp = buf->getString();
// Enforce the embedded nul.
expected.resize(4);
EXPECT_EQ(expected, strpp);
- EXPECT_EQ(4, strpp.size());
- EXPECT_EQ(3, strlen(strpp.c_str()));
+ EXPECT_EQ(4U, strpp.size());
+ EXPECT_EQ(3U, strlen(strpp.c_str()));
EXPECT_NO_THROW(buf.reset(new GssApiBuffer(strpp)));
ASSERT_TRUE(buf);
ASSERT_TRUE(buf->getPtr());
- EXPECT_EQ(4, buf->getLength());
+ EXPECT_EQ(4U, buf->getLength());
EXPECT_TRUE(buf->getValue());
EXPECT_FALSE(buf->empty());
EXPECT_EQ(0, memcmp(&test[0], buf->getValue(), 4));
// Trim the embedded nul.
expected.resize(3);
EXPECT_EQ(expected, str);
- EXPECT_EQ(3, str.size());
- EXPECT_EQ(3, strlen(str.c_str()));
+ EXPECT_EQ(3U, str.size());
+ EXPECT_EQ(3U, strlen(str.c_str()));
EXPECT_NO_THROW(buf.reset(new GssApiBuffer(str)));
ASSERT_TRUE(buf);
ASSERT_TRUE(buf->getPtr());
- EXPECT_EQ(3, buf->getLength());
+ EXPECT_EQ(3U, buf->getLength());
EXPECT_TRUE(buf->getValue());
EXPECT_FALSE(buf->empty());
EXPECT_EQ(0, memcmp(&test[0], buf->getValue(), 4));
EXPECT_NO_THROW(buf.reset(new GssApiBuffer(4, &test[0])));
ASSERT_TRUE(buf);
ASSERT_TRUE(buf->getPtr());
- EXPECT_EQ(4, buf->getLength());
+ EXPECT_EQ(4U, buf->getLength());
EXPECT_TRUE(buf->getValue());
EXPECT_FALSE(buf->empty());
EXPECT_EQ(0, memcmp(&test[0], buf->getValue(), 4));
OM_uint32 expected_major = 0x20000;
#endif
EXPECT_THROW_MSG(name->toString(), GssApiError, expected);
- EXPECT_EQ(expected_major, name->getLastError());
+ EXPECT_EQ(static_cast<int>(expected_major), name->getLastError());
string principal = "DNS/server.example.org@EXAMPLE.NET";
EXPECT_NO_THROW(name.reset(new GssApiName(principal)));
EXPECT_NO_THROW(cred->inquire(name, usage, lifetime));
EXPECT_TRUE(name.get());
// lifetime == 0 means expired.
- EXPECT_NE(0, lifetime);
+ EXPECT_NE(0U, lifetime);
const uint64_t now = static_cast<uint64_t>(time(0));
// krbtgt/EXAMPLE.NIL@EXAMPLE.NIL cached credential expires at
// Apr 6 19:04:36 2036.
OM_uint32 lifetime = 0;
EXPECT_NO_THROW(cred.reset(new GssApiCred(name, GSS_C_ACCEPT,
lifetime)));
- EXPECT_NE(0, lifetime);
+ EXPECT_NE(0U, lifetime);
ASSERT_TRUE(cred);
EXPECT_TRUE(cred->get());
EXPECT_EQ(0, cred->getLastError());
EXPECT_TRUE(namep->compare(name));
EXPECT_EQ(GSS_C_ACCEPT, usage);
// lifetime == 0 means expired.
- EXPECT_NE(0, lifetime);
+ EXPECT_NE(0U, lifetime);
const uint64_t now = static_cast<uint64_t>(time(0));
// DNS/blu.example.nil@EXAMPLE.NIL cached credential expires at
// Apr 6 19:04:36 2036.
}
}
}
- EXPECT_EQ(2, loop);
+ EXPECT_EQ(2U, loop);
ASSERT_TRUE(clnt_ret);
ASSERT_TRUE(clnt_ctx.get());
EXPECT_EQ(0, clnt_ctx.getLastError());
// lifetime == 0 means expired.
- EXPECT_NE(0, clnt_lifetime);
+ EXPECT_NE(0U, clnt_lifetime);
uint64_t now = static_cast<uint64_t>(time(0));
// Cached credentials expire at Apr 6 19:04:36 2036.
const uint64_t expire = timeFromText64("20260406190436");
EXPECT_NO_THROW(tgt_txt = target.toString());
EXPECT_EQ("DNS/blu.example.nil@EXAMPLE.NIL", tgt_txt);
// lifetime == 0 means expired.
- EXPECT_NE(0, clnt_lifetime);
+ EXPECT_NE(0U, clnt_lifetime);
now = static_cast<uint64_t>(time(0));
EXPECT_LE(expire, now + clnt_lifetime);
EXPECT_EQ(flags, (got_flags & flags));
EXPECT_NO_THROW(tgt_txt = target2.toString());
EXPECT_EQ("DNS/blu.example.nil@EXAMPLE.NIL", tgt_txt);
// lifetime == 0 means expired.
- EXPECT_NE(0, srv_lifetime);
+ EXPECT_NE(0U, srv_lifetime);
now = static_cast<uint64_t>(time(0));
EXPECT_LE(expire, now + srv_lifetime);
// Server side shall expire after the client (experiments showed 300s).
ASSERT_TRUE(srv);
EXPECT_EQ(id, srv->getID());
EXPECT_EQ(addr, srv->getIpAddress());
- EXPECT_EQ(53, srv->getPort());
+ EXPECT_EQ(53U, srv->getPort());
// ID.
id = "foo";
ASSERT_NO_THROW(info.reset(new DnsServerInfo("", addr)));
ASSERT_TRUE(info);
srv->addServerInfo(info);
- ASSERT_EQ(1, srv->getServerInfos().size());
+ ASSERT_EQ(1U, srv->getServerInfos().size());
DnsServerInfoPtr got;
ASSERT_NO_THROW(got = srv->getServerInfos().at(0));
EXPECT_EQ(info, got);
EXPECT_TRUE(srv->getGssSequenceFlag());
// TKEY lifetime.
- EXPECT_EQ(3600, srv->getKeyLifetime());
+ EXPECT_EQ(3600U, srv->getKeyLifetime());
srv->setKeyLifetime(7200);
- EXPECT_EQ(7200, srv->getKeyLifetime());
+ EXPECT_EQ(7200U, srv->getKeyLifetime());
// Rekey interval.
- EXPECT_EQ(2700, srv->getRekeyInterval());
+ EXPECT_EQ(2700U, srv->getRekeyInterval());
srv->setRekeyInterval(5400);
- EXPECT_EQ(5400, srv->getRekeyInterval());
+ EXPECT_EQ(5400U, srv->getRekeyInterval());
// Retry interval.
- EXPECT_EQ(120, srv->getRetryInterval());
+ EXPECT_EQ(120U, srv->getRetryInterval());
srv->setRetryInterval(240);
- EXPECT_EQ(240, srv->getRetryInterval());
+ EXPECT_EQ(240U, srv->getRetryInterval());
// TKEY protocol.
EXPECT_EQ(IOFetch::TCP, srv->getKeyProto());
DnsServerPtr srv2(new DnsServer(id, { }, addr, 1234));
ASSERT_TRUE(srv2);
EXPECT_EQ(addr, srv2->getIpAddress());
- EXPECT_EQ(1234, srv2->getPort());
+ EXPECT_EQ(1234U, srv2->getPort());
// TKEY exchange timeout.
- EXPECT_EQ(3000, srv->getExchangeTimeout());
+ EXPECT_EQ(3000U, srv->getExchangeTimeout());
srv->setExchangeTimeout(5000);
- EXPECT_EQ(5000, srv->getExchangeTimeout());
+ EXPECT_EQ(5000U, srv->getExchangeTimeout());
// User context.
ConstElementPtr user_ctx = srv->getContext();
"empty D2 config");
ASSERT_NO_THROW(srv->buildServerInfo(ctx));
const DnsServerInfoStorage& infos = srv->getServerInfos();
- ASSERT_EQ(2, infos.size());
+ ASSERT_EQ(2U, infos.size());
DnsServerInfoPtr info1;
ASSERT_NO_THROW(info1 = infos.at(0));
ASSERT_TRUE(info1);
EXPECT_EQ(addr, info1->getIpAddress());
- EXPECT_EQ(53, info1->getPort());
+ EXPECT_EQ(53U, info1->getPort());
DnsServerInfoPtr info2;
ASSERT_NO_THROW(info2 = infos.at(1));
ASSERT_TRUE(info2);
EXPECT_EQ(addr, info2->getIpAddress());
- EXPECT_EQ(53, info2->getPort());
+ EXPECT_EQ(53U, info2->getPort());
EXPECT_NE(info1, info2);
// buildServerInfo can be called only once.
// Check the buildServerInfo method.
ASSERT_NO_THROW(srv->buildServerInfo(ctx));
const DnsServerInfoStorage& infos = srv->getServerInfos();
- ASSERT_EQ(2, infos.size());
+ ASSERT_EQ(2U, infos.size());
DnsServerInfoPtr info1;
ASSERT_NO_THROW(info1 = infos.at(0));
ASSERT_TRUE(info1);
EXPECT_EQ(addr, info1->getIpAddress());
- EXPECT_EQ(53, info1->getPort());
+ EXPECT_EQ(53U, info1->getPort());
DnsServerInfoPtr info2;
ASSERT_NO_THROW(info2 = infos.at(1));
ASSERT_TRUE(info2);
EXPECT_EQ(addr, info2->getIpAddress());
- EXPECT_EQ(53, info2->getPort());
+ EXPECT_EQ(53U, info2->getPort());
EXPECT_NE(info1, info2);
}
// Check the buildServerInfo method.
ASSERT_NO_THROW(srv->buildServerInfo(ctx));
const DnsServerInfoStorage& infos = srv->getServerInfos();
- ASSERT_EQ(1, infos.size());
+ ASSERT_EQ(1U, infos.size());
DnsServerInfoPtr info;
ASSERT_NO_THROW(info = infos.at(0));
ASSERT_TRUE(info);
EXPECT_EQ(addr, info->getIpAddress());
- EXPECT_EQ(53, info->getPort());
+ EXPECT_EQ(53U, info->getPort());
}
/// @build Check buildServerInfo with no server.
EXPECT_EQ("KCM:", cfg.getCredsCache());
// maximum tkey lifetime.
- EXPECT_EQ(0, cfg.getMaxKeyLifetime());
+ EXPECT_EQ(0U, cfg.getMaxKeyLifetime());
cfg.setMaxKeyLifetime(12345);
- EXPECT_EQ(12345, cfg.getMaxKeyLifetime());
+ EXPECT_EQ(12345U, cfg.getMaxKeyLifetime());
}
/// @brief Check the DNS server containers.
// Check the server list.
cfg.addServer(srv);
- EXPECT_EQ(1, cfg.getServerList().size());
+ EXPECT_EQ(1U, cfg.getServerList().size());
EXPECT_EQ(srv, cfg.getServerList().front());
EXPECT_EQ(srv, cfg.getServer(id));
EXPECT_FALSE(cfg.getServer("bar"));
EXPECT_THROW(cfg.buildServerRevMap(D2CfgContextPtr()), D2CfgError);
ASSERT_NO_THROW(cfg.buildServerRevMap(ctx));
const DnsServerRevMap& rev_map = cfg.getServerRevMap();
- ASSERT_EQ(2, rev_map.size());
+ ASSERT_EQ(2U, rev_map.size());
for (auto const& it : rev_map) {
DnsServerInfoPtr info = it.first;
ASSERT_TRUE(info);
EXPECT_EQ(addr, info->getIpAddress());
- EXPECT_EQ(53, info->getPort());
+ EXPECT_EQ(53U, info->getPort());
EXPECT_EQ(srv, it.second);
}
ASSERT_NO_THROW(cfg.configure(json));
EXPECT_EQ("FILE:/etc/krb5.keytab", cfg.getClientKeyTab());
EXPECT_EQ("FILE:/etc/ccache", cfg.getCredsCache());
- EXPECT_EQ(86400, cfg.getMaxKeyLifetime());
+ EXPECT_EQ(86400U, cfg.getMaxKeyLifetime());
EXPECT_TRUE(cfg.getIgnoreBadDirection());
EXPECT_TRUE(GssApiSecCtx::ignore_bad_direction_);
// Put this in the fixture if one is created...
GssApiSecCtx::ignore_bad_direction_ = false;
const DnsServerList& servers = cfg.getServerList();
- ASSERT_EQ(2, servers.size());
+ ASSERT_EQ(2U, servers.size());
DnsServerPtr server;
ASSERT_NO_THROW(server = servers.at(0));
ASSERT_TRUE(server);
EXPECT_EQ("foo", server->getID());
EXPECT_EQ("192.0.2.1", server->getIpAddress().toText());
- EXPECT_EQ(53, server->getPort());
+ EXPECT_EQ(53U, server->getPort());
EXPECT_EQ("DNS/server1.example.org@REALM", server->getServerPrincipal());
EXPECT_EQ("sig-server1.example.org.", server->getKeyNameSuffix());
EXPECT_EQ("DHCP/admin1.example.org@REALM", server->getClientPrincipal());
EXPECT_TRUE(server->getGssReplayFlag());
EXPECT_FALSE(server->getGssSequenceFlag());
- EXPECT_EQ(64800, server->getRekeyInterval());
- EXPECT_EQ(2880, server->getRetryInterval());
- EXPECT_EQ(86400, server->getKeyLifetime());
+ EXPECT_EQ(64800U, server->getRekeyInterval());
+ EXPECT_EQ(2880U, server->getRetryInterval());
+ EXPECT_EQ(86400U, server->getKeyLifetime());
EXPECT_EQ(IOFetch::UDP, server->getKeyProto());
- EXPECT_EQ(4000, server->getExchangeTimeout());
+ EXPECT_EQ(4000U, server->getExchangeTimeout());
ASSERT_NO_THROW(server = servers.at(1));
ASSERT_TRUE(server);
EXPECT_EQ("bar", server->getID());
EXPECT_EQ("192.0.2.2", server->getIpAddress().toText());
- EXPECT_EQ(5300, server->getPort());
+ EXPECT_EQ(5300U, server->getPort());
EXPECT_EQ("DNS/server.example.org@REALM", server->getServerPrincipal());
EXPECT_EQ("sig-server.example.org.", server->getKeyNameSuffix());
EXPECT_EQ("DHCP/admin.example.org@REALM", server->getClientPrincipal());
EXPECT_FALSE(server->getGssReplayFlag());
EXPECT_TRUE(server->getGssSequenceFlag());
- EXPECT_EQ(5400, server->getRekeyInterval());
- EXPECT_EQ(240, server->getRetryInterval());
- EXPECT_EQ(7200, server->getKeyLifetime());
+ EXPECT_EQ(5400U, server->getRekeyInterval());
+ EXPECT_EQ(240U, server->getRetryInterval());
+ EXPECT_EQ(7200U, server->getKeyLifetime());
EXPECT_EQ(IOFetch::UDP, server->getKeyProto());
- EXPECT_EQ(2000, server->getExchangeTimeout());
+ EXPECT_EQ(2000U, server->getExchangeTimeout());
}
/// @brief Check configure requires a map.
ASSERT_TRUE(json);
GssTsigCfg cfg;
ASSERT_NO_THROW(cfg.configure(json));
- EXPECT_EQ(3600, cfg.getMaxKeyLifetime());
+ EXPECT_EQ(3600U, cfg.getMaxKeyLifetime());
const DnsServerList& servers = cfg.getServerList();
- ASSERT_EQ(1, servers.size());
+ ASSERT_EQ(1U, servers.size());
DnsServerPtr server;
ASSERT_NO_THROW(server = servers.at(0));
GssTsigCfg cfg;
ASSERT_NO_THROW(cfg.configure(json));
const DnsServerList& servers = cfg.getServerList();
- ASSERT_EQ(1, servers.size());
+ ASSERT_EQ(1U, servers.size());
DnsServerPtr server;
ASSERT_NO_THROW(server = servers.at(0));
GssTsigCfg cfg;
ASSERT_NO_THROW(cfg.configure(json));
const DnsServerList& servers = cfg.getServerList();
- ASSERT_EQ(1, servers.size());
+ ASSERT_EQ(1U, servers.size());
DnsServerPtr server;
ASSERT_NO_THROW(server = servers.at(0));
EXPECT_EQ(TSIGContext::INIT, ctx->getState());
EXPECT_EQ(TSIGError::NOERROR(), ctx->getError());
// Length is 26 + 26 + 10 + 128 + 0 = 190.
- EXPECT_EQ(190, ctx->getTSIGLength());
+ EXPECT_EQ(190U, ctx->getTSIGLength());
}
/// @brief Check sign direct errors.
ASSERT_TRUE(tsig);
EXPECT_EQ(Name(name), tsig->getName());
EXPECT_EQ(RRClass::ANY(), tsig->getClass());
- EXPECT_EQ(0, tsig->getTTL().getValue());
+ EXPECT_EQ(0U, tsig->getTTL().getValue());
// Length is 26 + 26 + 10 = 62.
- EXPECT_EQ(62, tsig->getLength());
+ EXPECT_EQ(62U, tsig->getLength());
const TSIG& rdata = tsig->getRdata();
EXPECT_EQ(Name("gss-tsig."), rdata.getAlgorithm());
EXPECT_LE(before, rdata.getTimeSigned());
EXPECT_GE(after, rdata.getTimeSigned());
EXPECT_EQ(TSIGContext::DEFAULT_FUDGE, rdata.getFudge());
- EXPECT_EQ(0, rdata.getMACSize());
+ EXPECT_EQ(0U, rdata.getMACSize());
EXPECT_FALSE(rdata.getMAC());
- EXPECT_EQ(0x1234, rdata.getOriginalID());
+ EXPECT_EQ(0x1234U, rdata.getOriginalID());
EXPECT_EQ(TSIGError::BAD_SIG_CODE, rdata.getError());
- EXPECT_EQ(0, rdata.getOtherLen());
+ EXPECT_EQ(0U, rdata.getOtherLen());
EXPECT_FALSE(rdata.getOtherData());
EXPECT_EQ(TSIGContext::SENT_RESPONSE, ctx->getState());
EXPECT_EQ(TSIGError::BAD_SIG(), ctx->getError());
ASSERT_TRUE(tsig);
EXPECT_EQ(Name(name), tsig->getName());
EXPECT_EQ(RRClass::ANY(), tsig->getClass());
- EXPECT_EQ(0, tsig->getTTL().getValue());
+ EXPECT_EQ(0U, tsig->getTTL().getValue());
// Length is 26 + 26 + 10 = 62.
- EXPECT_EQ(62, tsig->getLength());
+ EXPECT_EQ(62U, tsig->getLength());
const TSIG& rdata2 = tsig->getRdata();
EXPECT_EQ(Name("gss-tsig."), rdata2.getAlgorithm());
EXPECT_LE(before, rdata2.getTimeSigned());
EXPECT_GE(after, rdata2.getTimeSigned());
EXPECT_EQ(TSIGContext::DEFAULT_FUDGE, rdata2.getFudge());
- EXPECT_EQ(0, rdata2.getMACSize());
+ EXPECT_EQ(0U, rdata2.getMACSize());
EXPECT_FALSE(rdata2.getMAC());
EXPECT_EQ(0x1234, rdata2.getOriginalID());
EXPECT_EQ(TSIGError::BAD_KEY_CODE, rdata2.getError());
- EXPECT_EQ(0, rdata2.getOtherLen());
+ EXPECT_EQ(0U, rdata2.getOtherLen());
EXPECT_FALSE(rdata2.getOtherData());
EXPECT_EQ(TSIGContext::SENT_RESPONSE, ctx->getState());
EXPECT_EQ(TSIGError::BAD_KEY(), ctx->getError());
const size_t MESSAGE_HEADER_LEN = 12;
size_t len = MESSAGE_HEADER_LEN + tsig->getLength();
// len is 12 + 26 + 26 + 10 = 74.
- EXPECT_EQ(74, len);
+ EXPECT_EQ(74U, len);
EXPECT_THROW_MSG(ctx->verify(tsig.get(), 0, len - 1), InvalidParameter,
"TSIG verify: data length is invalid: 73");
EXPECT_THROW_MSG(ctx->verify(tsig.get(), 0, len), InvalidParameter,
EXPECT_NO_THROW(message_.toWire(renderer));
// len is 12 + 17 + 4 = 33
ASSERT_TRUE(buf.getData());
- EXPECT_EQ(33, buf.getLength());
+ EXPECT_EQ(33U, buf.getLength());
// Sign.
GssTsigContextPtr ctx;
ASSERT_TRUE(tsig);
EXPECT_EQ(Name(name), tsig->getName());
EXPECT_EQ(RRClass::ANY(), tsig->getClass());
- EXPECT_EQ(0, tsig->getTTL().getValue());
- EXPECT_LT(62, tsig->getLength());
+ EXPECT_EQ(0U, tsig->getTTL().getValue());
+ EXPECT_LT(62U, tsig->getLength());
const TSIG& rdata = tsig->getRdata();
EXPECT_EQ(Name("gss-tsig."), rdata.getAlgorithm());
EXPECT_LE(before, rdata.getTimeSigned());
EXPECT_EQ(TSIGContext::DEFAULT_FUDGE, rdata.getFudge());
EXPECT_EQ(tsig->getLength() - 62, rdata.getMACSize());
EXPECT_TRUE(rdata.getMAC());
- EXPECT_EQ(0x4321, rdata.getOriginalID());
- EXPECT_EQ(0, rdata.getError());
- EXPECT_EQ(0, rdata.getOtherLen());
+ EXPECT_EQ(0x4321U, rdata.getOriginalID());
+ EXPECT_EQ(0U, rdata.getError());
+ EXPECT_EQ(0U, rdata.getOtherLen());
EXPECT_FALSE(rdata.getOtherData());
EXPECT_EQ(TSIGContext::SENT_REQUEST, ctx->getState());
EXPECT_EQ(TSIGError::NOERROR(), ctx->getError());
// Depend on setup.
- EXPECT_EQ(28, rdata.getMACSize());
+ EXPECT_EQ(28U, rdata.getMACSize());
}
/// @brief Check that toWire with sign works as expected.
uint64_t after = static_cast<uint64_t>(time(0));
// len is 33 + 62 + 28 = 123.
ASSERT_TRUE(obuf.getData());
- EXPECT_EQ(123, obuf.getLength());
+ EXPECT_EQ(123U, obuf.getLength());
// Check the TSIG RR.
message_.clear(Message::PARSE);
ASSERT_TRUE(tsig);
EXPECT_EQ(Name(name), tsig->getName());
EXPECT_EQ(RRClass::ANY(), tsig->getClass());
- EXPECT_EQ(0, tsig->getTTL().getValue());
- EXPECT_LT(62, tsig->getLength());
+ EXPECT_EQ(0U, tsig->getTTL().getValue());
+ EXPECT_LT(62U, tsig->getLength());
const TSIG& rdata = tsig->getRdata();
EXPECT_EQ(Name("gss-tsig."), rdata.getAlgorithm());
EXPECT_LE(before, rdata.getTimeSigned());
EXPECT_EQ(TSIGContext::DEFAULT_FUDGE, rdata.getFudge());
EXPECT_EQ(tsig->getLength() - 62, rdata.getMACSize());
EXPECT_TRUE(rdata.getMAC());
- EXPECT_EQ(0x1234, rdata.getOriginalID());
- EXPECT_EQ(0, rdata.getError());
- EXPECT_EQ(0, rdata.getOtherLen());
+ EXPECT_EQ(0x1234U, rdata.getOriginalID());
+ EXPECT_EQ(0U, rdata.getError());
+ EXPECT_EQ(0U, rdata.getOtherLen());
EXPECT_FALSE(rdata.getOtherData());
EXPECT_EQ(TSIGContext::SENT_REQUEST, ctx->getState());
EXPECT_EQ(TSIGError::NOERROR(), ctx->getError());
// Depend on setup.
- EXPECT_EQ(28, rdata.getMACSize());
+ EXPECT_EQ(28U, rdata.getMACSize());
}
/// @brief Check that sign and verify work as expected.
EXPECT_NO_THROW(message_.toWire(renderer, ctx.get()));
// len is 33 + 62 + 28 = 123.
ASSERT_TRUE(obuf.getData());
- EXPECT_EQ(123, obuf.getLength());
+ EXPECT_EQ(123U, obuf.getLength());
// Check the TSIG RR.
message_.clear(Message::PARSE);
EXPECT_NO_THROW(message_.toWire(renderer, ctx.get()));
// len is 33 + 62 + 28 = 123.
ASSERT_TRUE(obuf.getData());
- EXPECT_EQ(123, obuf.getLength());
+ EXPECT_EQ(123U, obuf.getLength());
// Check the TSIG RR.
message_.clear(Message::PARSE);
InputBuffer ibuf(obuf.getData(), obuf.getLength());
// Change the signature at 93..121.
- ASSERT_EQ(123, obuf.getLength());
+ ASSERT_EQ(123U, obuf.getLength());
const uint8_t* ptr = obuf.getData();
obuf.writeUint8At(ptr[120] ^ 1, 120);
EXPECT_NO_THROW(message_.fromWire(ibuf));
EXPECT_EQ(TSIGError::BAD_SIG(), error);
EXPECT_EQ(TSIGError::BAD_SIG(), ctx->getError());
EXPECT_EQ(TSIGContext::RECEIVED_REQUEST, ctx->getState());
- EXPECT_EQ(GSS_S_BAD_SIG, srv_key->getSecCtx().getLastError());
+ EXPECT_EQ(static_cast<int>(GSS_S_BAD_SIG),
+ srv_key->getSecCtx().getLastError());
}
/// @brief Check that verify fail on bad direction.
EXPECT_NO_THROW(message_.toWire(renderer, ctx.get()));
// len is 33 + 62 + 28 = 123.
ASSERT_TRUE(obuf.getData());
- EXPECT_EQ(123, obuf.getLength());
+ EXPECT_EQ(123U, obuf.getLength());
// Check the TSIG RR.
message_.clear(Message::PARSE);
EXPECT_EQ(TSIGError::BAD_SIG(), error);
EXPECT_EQ(TSIGError::BAD_SIG(), ctx->getError());
EXPECT_EQ(TSIGContext::RECEIVED_REQUEST, ctx->getState());
- EXPECT_EQ(GSS_S_BAD_SIG, key->getSecCtx().getLastError());
+ EXPECT_EQ(GSS_S_BAD_SIG, static_cast<OM_uint32>(key->getSecCtx().getLastError()));
}
/// @brief Check that verify fail on bad direction instead ignored.
EXPECT_NO_THROW(message_.toWire(renderer, ctx.get()));
// len is 33 + 62 + 28 = 123.
ASSERT_TRUE(obuf.getData());
- EXPECT_EQ(123, obuf.getLength());
+ EXPECT_EQ(123U, obuf.getLength());
// Check the TSIG RR.
message_.clear(Message::PARSE);
EXPECT_FALSE(impl_->findKey(name2));
ASSERT_TRUE(impl_->findKey(name3));
EXPECT_EQ(key3, impl_->findKey(name3));
- EXPECT_EQ(2, impl_->keys_.size());
+ EXPECT_EQ(2U, impl_->keys_.size());
}
}
EXPECT_EQ(key1, impl_->findKey(name1));
EXPECT_FALSE(impl_->findKey(name2));
EXPECT_FALSE(impl_->findKey(name3));
- EXPECT_EQ(1, impl_->keys_.size());
+ EXPECT_EQ(1U, impl_->keys_.size());
}
}
expected_status = CONTROL_RESULT_SUCCESS;
expected_txt = "GSS-TSIG server[" + id + "] rekeyed";
checkAnswer(response, expected_status, expected_txt, expected);
- EXPECT_EQ(impl_->keys_.size(), 1);
+ EXPECT_EQ(impl_->keys_.size(), 1U);
impl_->keys_.clear();
}
}
ASSERT_TRUE(response);
checkAnswer(response, expected_status, expected_txt, expected);
io_service_->poll();
- EXPECT_EQ(impl_->keys_.size(), 0);
+ EXPECT_EQ(impl_->keys_.size(), 0U);
impl_->keys_.clear();
}
ASSERT_TRUE(response);
checkAnswer(response, expected_status, expected_txt, expected);
io_service_->poll();
- EXPECT_EQ(impl_->keys_.size(), 1);
+ EXPECT_EQ(impl_->keys_.size(), 1U);
for (auto const& key : impl_->keys_) {
key->getTKeyExchange().reset();
}
ASSERT_TRUE(response);
checkAnswer(response, expected_status, expected_txt, expected);
io_service_->poll();
- EXPECT_EQ(impl_->keys_.size(), 3);
+ EXPECT_EQ(impl_->keys_.size(), 3U);
for (auto const& temp_key : impl_->keys_) {
temp_key->getTKeyExchange().reset();
}
ASSERT_TRUE(impl_->findKey(name5));
EXPECT_EQ(key5, impl_->findKey(name5));
- EXPECT_EQ(5, impl_->keys_.size());
+ EXPECT_EQ(5U, impl_->keys_.size());
ASSERT_NO_THROW(impl_->purgeKeys());
- EXPECT_EQ(2, impl_->keys_.size());
+ EXPECT_EQ(2U, impl_->keys_.size());
EXPECT_EQ(key1, impl_->findKey(name1));
EXPECT_EQ(key5, impl_->findKey(name5));
}
EXPECT_EQ(Name("gss-tsig."), key->getAlgorithmName());
EXPECT_EQ(TSIGKey::GSSTSIG_NAME(), key->getAlgorithmName());
EXPECT_EQ(UNKNOWN_HASH, key->getAlgorithm());
- EXPECT_EQ(0, key->getDigestbits());
- EXPECT_EQ(0, key->getSecretLength());
+ EXPECT_EQ(0U, key->getDigestbits());
+ EXPECT_EQ(0U, key->getSecretLength());
EXPECT_FALSE(key->getSecret());
string expected = name + "::gss-tsig.";
EXPECT_EQ(expected, key->toText());
system_clock::time_point now = system_clock::now();
uint32_t now32 = static_cast<uint32_t>(system_clock::to_time_t(now));
EXPECT_EQ(epoch, key->getInception());
- EXPECT_EQ(0, key->getInception32());
+ EXPECT_EQ(0U, key->getInception32());
EXPECT_EQ(epoch, key->getExpire());
- EXPECT_EQ(0, key->getExpire32());
+ EXPECT_EQ(0U, key->getExpire32());
EXPECT_NO_THROW(key->setInception(now));
EXPECT_EQ(now, key->getInception());
EXPECT_EQ(now32, key->getInception32());
qid = msg_->getQid();
EXPECT_EQ(Rcode::NOERROR(), msg_->getRcode());
EXPECT_EQ(Opcode(Opcode::QUERY_CODE), msg_->getOpcode());
- ASSERT_EQ(1, msg_->getRRCount(Message::SECTION_QUESTION));
+ ASSERT_EQ(1U, msg_->getRRCount(Message::SECTION_QUESTION));
QuestionPtr question = *msg_->beginQuestion();
ASSERT_TRUE(question);
key_name = question->getName();
EXPECT_EQ(RRClass::ANY(), question->getClass());
EXPECT_EQ(RRType::TKEY(), question->getType());
- EXPECT_EQ(0, msg_->getRRCount(Message::SECTION_ANSWER));
- EXPECT_EQ(0, msg_->getRRCount(Message::SECTION_AUTHORITY));
- ASSERT_EQ(1, msg_->getRRCount(Message::SECTION_ADDITIONAL));
+ EXPECT_EQ(0U, msg_->getRRCount(Message::SECTION_ANSWER));
+ EXPECT_EQ(0U, msg_->getRRCount(Message::SECTION_AUTHORITY));
+ ASSERT_EQ(1U, msg_->getRRCount(Message::SECTION_ADDITIONAL));
RRsetPtr rrset = *msg_->beginSection(Message::SECTION_ADDITIONAL);
ASSERT_TRUE(rrset);
EXPECT_EQ(key_name, rrset->getName());
EXPECT_EQ(RRClass::ANY(), rrset->getClass());
ASSERT_EQ(RRType::TKEY(), rrset->getType());
EXPECT_EQ(RRTTL(0), rrset->getTTL());
- ASSERT_EQ(1, rrset->getRdataCount());
+ ASSERT_EQ(1U, rrset->getRdataCount());
auto rdata_it = rrset->getRdataIterator();
try {
const TKEY& tkey =
EXPECT_EQ(TKEY::GSS_API_MODE, tkey.getMode());
EXPECT_EQ(Rcode::NOERROR().getCode(), tkey.getError());
token.reset(new GssApiBuffer(tkey.getKeyLen(), tkey.getKey()));
- EXPECT_EQ(0, tkey.getOtherLen());
+ EXPECT_EQ(0U, tkey.getOtherLen());
EXPECT_FALSE(tkey.getOtherData());
} catch (const exception& ex) {
FAIL() << ex.what();
msg_.reset();
ASSERT_NO_THROW(output = buildTKey(true, qid, key_name, token));
ASSERT_TRUE(msg_);
- ASSERT_NE(0, output->getLength());
+ ASSERT_NE(0U, output->getLength());
}
/// @brief Check TKEY message decode.
GssApiBuffer token("foobar");
OutputBufferPtr output;
ASSERT_NO_THROW(output = buildTKey(true, qid, key_name, token));
- ASSERT_NE(0, output->getLength());
+ ASSERT_NE(0U, output->getLength());
const vector<uint8_t>& input = output->getVector();
bool query = false;
ASSERT_FALSE(msg->getHeaderFlag(Message::HEADERFLAG_QR));
ASSERT_EQ(msg->getRcode(), Rcode::NOERROR());
ASSERT_EQ(msg->getOpcode(), Opcode::QUERY());
- ASSERT_EQ(msg->getRRCount(Message::SECTION_QUESTION), 1);
+ ASSERT_EQ(msg->getRRCount(Message::SECTION_QUESTION), 1U);
QuestionPtr question = *msg->beginQuestion();
ASSERT_TRUE(question);
ASSERT_EQ(question->getClass(), RRClass::ANY());
key_name = rrset->getName();
ASSERT_EQ(rrset->getClass(), RRClass::ANY());
ASSERT_EQ(rrset->getType(), RRType::TKEY());
- ASSERT_EQ(rrset->getRdataCount(), 1);
+ ASSERT_EQ(rrset->getRdataCount(), 1U);
auto rdata_it = rrset->getRdataIterator();
const TKEY& tkey = dynamic_cast<const TKEY&>(rdata_it->getCurrent());
ASSERT_EQ(tkey.getError(), Rcode::NOERROR_CODE);
if (processed) {
EXPECT_EQ(CalloutHandle::NEXT_STEP_SKIP, handle.getStatus());
EXPECT_FALSE(pkt->getOption(DHO_DHCP_MESSAGE_TYPE));
- EXPECT_LE(300, pkt->getBuffer().getLength());
+ EXPECT_LE(300U, pkt->getBuffer().getLength());
} else {
EXPECT_EQ(CalloutHandle::NEXT_STEP_CONTINUE, handle.getStatus());
EXPECT_TRUE(pkt->getOption(DHO_DHCP_MESSAGE_TYPE));
// This works because we did not add options to the response.
- EXPECT_GT(300, pkt->getBuffer().getLength());
+ EXPECT_GT(300U, pkt->getBuffer().getLength());
}
}
ASSERT_TRUE(cfg_option_def);
auto option_def = cfg_option_def->get(DHCP4_OPTION_SPACE, 224);
ASSERT_TRUE(option_def);
- EXPECT_EQ(224, option_def->getCode());
+ EXPECT_EQ(224U, option_def->getCode());
// Verify that option has been added.
auto cfg_option = def->getCfgOption();
ASSERT_TRUE(cfg_option_def);
auto option_def = cfg_option_def->get(DHCP4_OPTION_SPACE, 224);
ASSERT_TRUE(option_def);
- EXPECT_EQ(224, option_def->getCode());
+ EXPECT_EQ(224U, option_def->getCode());
// Verify that option has been added.
auto cfg_option = def->getCfgOption();
ASSERT_TRUE(args);
ConstElementPtr defs = args->get("client-classes");
ASSERT_TRUE(defs);
- EXPECT_EQ(0, defs->size());
+ EXPECT_EQ(0U, defs->size());
}
// Checks that class-list can handle a situation when one class is
ASSERT_TRUE(args);
ConstElementPtr defs = args->get("client-classes");
ASSERT_TRUE(defs);
- ASSERT_GE(1, defs->size());
- EXPECT_EQ(1, defs->size());
+ ASSERT_GE(1U, defs->size());
+ EXPECT_EQ(1U, defs->size());
ConstElementPtr def = defs->get(0);
ASSERT_TRUE(def);
ASSERT_TRUE(def->get("name"));
ASSERT_TRUE(args);
ConstElementPtr defs = args->get("client-classes");
ASSERT_TRUE(defs);
- ASSERT_GE(2, defs->size());
- EXPECT_EQ(2, defs->size());
+ ASSERT_GE(2U, defs->size());
+ EXPECT_EQ(2U, defs->size());
ConstElementPtr def = defs->get(0);
ASSERT_TRUE(def);
ASSERT_TRUE(def->get("name"));
config->set("hostname-expr", Element::create("'global'"));
ASSERT_NO_THROW_LOG(impl_->configure(config));
// We should have a global expression.
- ASSERT_EQ(impl_->getCacheSize(), 1); // global only
+ ASSERT_EQ(impl_->getCacheSize(), 1U); // global only
ASSERT_TRUE(impl_->getGlobalHostnameExpression());
// Flush the cache. Verify it contains only the global expression.
impl_->flushCache();
- ASSERT_EQ(impl_->getCacheSize(), 1); // global only
+ ASSERT_EQ(impl_->getCacheSize(), 1U); // global only
ASSERT_TRUE(impl_->getGlobalHostnameExpression());
if (make_pre_existing) {
ASSERT_NO_THROW_LOG(impl_->calculateHostname(pkt, subnet));
// Verify we added an entry to the cache. We'll take it on faith that the
// expression content is correct. First exposure tests should cover this.
- ASSERT_EQ(impl_->getCacheSize(), 2);
+ ASSERT_EQ(impl_->getCacheSize(), 2U);
}
// Wind clock back 10 seconds. This ensures we can verify whether
}
// Verify cache size is correct: global + subnet.
- EXPECT_EQ(impl_->getCacheSize(), 2);
+ EXPECT_EQ(impl_->getCacheSize(), 2U);
// Verify the cached expression is what we expect.
ExpressionPtr cached_expr = impl_->getHostnameExpression(subnet->getID());
impl_->setHostnameExpression(999, expression);
// Cache size should be two.
- EXPECT_EQ(2, impl_->getCacheSize());
+ EXPECT_EQ(2U, impl_->getCacheSize());
// Verify both expressions are cached correctly.
ASSERT_EQ(evaluateExpression(0), "global");
// cache has no entries.
ptime last_flush_time = expressions.getLastFlushTime();
EXPECT_GE(last_flush_time, start_time);
- EXPECT_EQ(expressions.size(), 0);
+ EXPECT_EQ(expressions.size(), 0U);
// Verify that looking for an entry in an empty cache
// gracefully finds nothing.
"error parsing expression: [addrtotext(relay6[0].linkaddr)] :"
" <string>:1.19: Nest level invalid for DHCPv4 packets");
- EXPECT_EQ(expressions.size(), 0);
+ EXPECT_EQ(expressions.size(), 0U);
}
/// @brief Verifies that valid DHCPv4 expressions are cached correctly.
};
// Verify that we can cache valid expressions.
- int id = 1;
+ unsigned id = 1;
for (auto const& expression_str : expression_strs) {
ExpressionPtr expression;
ASSERT_NO_THROW_LOG(expression = expressions.parseAndCacheExpression(id, expression_str, AF_INET));
"error parsing expression: [addrtotext(pkt4.yiaddr)] :"
" <string>:1.12-15: pkt4 can only be used in DHCPv4.");
- EXPECT_EQ(expressions.size(), 0);
+ EXPECT_EQ(expressions.size(), 0U);
}
/// @brief Verifies that valid DHCPv6 expressions are cached correctly.
};
// Verify that we can cache valid expressions.
- int id = 1;
+ unsigned id = 1;
for (auto const& expression_str : expression_strs) {
ExpressionPtr expression;
ASSERT_NO_THROW_LOG(expression = expressions.parseAndCacheExpression(id, expression_str, AF_INET6));
void testExpressionCacheNullExpressions() {
// Create a new cache.
TestExpressionCache expressions;
- EXPECT_EQ(expressions.size(), 0);
+ EXPECT_EQ(expressions.size(), 0U);
// Verify that we can cache a null pointer expression.
ExpressionPtr no_exp;
ASSERT_NO_THROW_LOG(expressions.cacheExpression(1, no_exp));
- EXPECT_EQ(expressions.size(), 1);
+ EXPECT_EQ(expressions.size(), 1U);
// Verify we can retrieve the cached null expression pointer.
ExpressionPtr fetched_exp;
void testFlushCache() {
// Create a new cache.
TestExpressionCache expressions;
- EXPECT_EQ(expressions.size(), 0);
+ EXPECT_EQ(expressions.size(), 0U);
ptime last_flush_time = expressions.getLastFlushTime();
// Now let's wind the clock back on last_flush_time.
last_flush_time = expressions.getLastFlushTime();
std::vector<std::string> expression_strs { "'one'", "'two'", "'three'" };
- int id = 1;
+ unsigned id = 1;
for (auto const& expression_str : expression_strs) {
ExpressionPtr expression;
ASSERT_NO_THROW_LOG(expression = expressions.parseAndCacheExpression(id, expression_str, AF_INET));
// and last_flush_time should be updated.
expressions.clear();
EXPECT_GT(expressions.getLastFlushTime(), last_flush_time);
- EXPECT_EQ(expressions.size(), 0);
+ EXPECT_EQ(expressions.size(), 0U);
}
};
iana_count++;
auto iana = boost::dynamic_pointer_cast<Option6IA>(opt.second);
if (context_iana_count == 1) {
- ASSERT_EQ(iana->getIAID(), 0);
+ ASSERT_EQ(iana->getIAID(), 0U);
} else {
ASSERT_EQ(iana->getIAID(), iana_count);
}
iapd_count++;
auto iapd = boost::dynamic_pointer_cast<Option6IA>(opt.second);
if (context_iapd_count == 1) {
- ASSERT_EQ(iapd->getIAID(), 0);
+ ASSERT_EQ(iapd->getIAID(), 0U);
} else {
ASSERT_EQ(iapd->getIAID(), iapd_count);
}
ASSERT_TRUE(opt);
EXPECT_EQ(DHO_HOST_NAME, opt->getType());
const OptionBuffer& buffer = opt->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
}
ASSERT_TRUE(opt);
EXPECT_EQ(D6O_BOOTFILE_URL, opt->getType());
const OptionBuffer& buffer = opt->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
}
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getOptionConfigMap();
- EXPECT_EQ(1, map.count(109));
+ EXPECT_EQ(1U, map.count(109));
auto opt_lst = map[109];
- EXPECT_EQ(1, opt_lst.size());
+ EXPECT_EQ(1U, opt_lst.size());
}
// Verify that the definition is not required when csv-format is false.
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getOptionConfigMap();
- EXPECT_EQ(1, map.count(109));
+ EXPECT_EQ(1U, map.count(109));
auto opt_lst = map[109];
- EXPECT_EQ(1, opt_lst.size());
+ EXPECT_EQ(1U, opt_lst.size());
}
// Verify that the code must be a known option when csv-format is true.
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getOptionConfigMap();
- EXPECT_EQ(1, map.count(DHO_HOST_NAME));
+ EXPECT_EQ(1U, map.count(DHO_HOST_NAME));
auto opt_lst = map[DHO_HOST_NAME];
- EXPECT_EQ(1, opt_lst.size());
+ EXPECT_EQ(1U, opt_lst.size());
}
// Verify that the name can be an user defined option.
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getOptionConfigMap();
- EXPECT_EQ(1, map.count(222));
+ EXPECT_EQ(1U, map.count(222));
auto opt_lst = map[222];
- EXPECT_EQ(1, opt_lst.size());
+ EXPECT_EQ(1U, opt_lst.size());
}
// Verify that the name can be an user defined option in a custom space.
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getOptionConfigMap();
- EXPECT_EQ(1, map.count(222));
+ EXPECT_EQ(1U, map.count(222));
auto opt_lst = map[222];
- EXPECT_EQ(1, opt_lst.size());
+ EXPECT_EQ(1U, opt_lst.size());
}
// Last resort is only option 43...
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getOptionConfigMap();
- EXPECT_EQ(1, map.count(DHO_HOST_NAME));
+ EXPECT_EQ(1U, map.count(DHO_HOST_NAME));
auto opt_lst = map[DHO_HOST_NAME];
- EXPECT_EQ(2, opt_lst.size());
+ EXPECT_EQ(2U, opt_lst.size());
}
// Verify that the add value must be a string.
FlexOptionImpl::OptionConfigList opt_lst;
ASSERT_NO_THROW(opt_lst = map.at(DHO_HOST_NAME));
ASSERT_FALSE(opt_lst.empty());
- EXPECT_EQ(1, opt_lst.size());
+ EXPECT_EQ(1U, opt_lst.size());
FlexOptionImpl::OptionConfigPtr opt_cfg;
ASSERT_NO_THROW(opt_cfg = opt_lst.front());
ExpressionPtr expr = opt_cfg->getExpr();
ASSERT_TRUE(expr);
- ASSERT_EQ(1, expr->size());
+ ASSERT_EQ(1U, expr->size());
Pkt4Ptr pkt4(new Pkt4(DHCPDISCOVER, 12345));
ValueStack values;
EXPECT_NO_THROW(expr->at(0)->evaluate(*pkt4, values));
- ASSERT_EQ(1, values.size());
+ ASSERT_EQ(1U, values.size());
EXPECT_EQ("abc", values.top());
}
FlexOptionImpl::OptionConfigList opt_lst;
ASSERT_NO_THROW(opt_lst = map.at(D6O_BOOTFILE_URL));
ASSERT_FALSE(opt_lst.empty());
- EXPECT_EQ(1, opt_lst.size());
+ EXPECT_EQ(1U, opt_lst.size());
FlexOptionImpl::OptionConfigPtr opt_cfg;
ASSERT_NO_THROW(opt_cfg = opt_lst.front());
ExpressionPtr expr = opt_cfg->getExpr();
ASSERT_TRUE(expr);
- ASSERT_EQ(1, expr->size());
+ ASSERT_EQ(1U, expr->size());
Pkt6Ptr pkt6(new Pkt6(DHCPV6_SOLICIT, 12345));
ValueStack values;
EXPECT_NO_THROW(expr->at(0)->evaluate(*pkt6, values));
- ASSERT_EQ(1, values.size());
+ ASSERT_EQ(1U, values.size());
EXPECT_EQ("abc", values.top());
}
FlexOptionImpl::OptionConfigList opt_lst;
ASSERT_NO_THROW(opt_lst = map.at(DHO_HOST_NAME));
ASSERT_FALSE(opt_lst.empty());
- EXPECT_EQ(1, opt_lst.size());
+ EXPECT_EQ(1U, opt_lst.size());
FlexOptionImpl::OptionConfigPtr opt_cfg;
ASSERT_NO_THROW(opt_cfg = opt_lst.front());
ExpressionPtr expr = opt_cfg->getExpr();
ASSERT_TRUE(expr);
- ASSERT_EQ(1, expr->size());
+ ASSERT_EQ(1U, expr->size());
Pkt4Ptr pkt4(new Pkt4(DHCPDISCOVER, 12345));
ValueStack values;
EXPECT_NO_THROW(expr->at(0)->evaluate(*pkt4, values));
- ASSERT_EQ(1, values.size());
+ ASSERT_EQ(1U, values.size());
EXPECT_EQ("abc", values.top());
}
FlexOptionImpl::OptionConfigList opt_lst;
ASSERT_NO_THROW(opt_lst = map.at(D6O_BOOTFILE_URL));
ASSERT_FALSE(opt_lst.empty());
- EXPECT_EQ(1, opt_lst.size());
+ EXPECT_EQ(1U, opt_lst.size());
FlexOptionImpl::OptionConfigPtr opt_cfg;
ASSERT_NO_THROW(opt_cfg = opt_lst.front());
ExpressionPtr expr = opt_cfg->getExpr();
ASSERT_TRUE(expr);
- ASSERT_EQ(1, expr->size());
+ ASSERT_EQ(1U, expr->size());
Pkt6Ptr pkt6(new Pkt6(DHCPV6_SOLICIT, 12345));
ValueStack values;
EXPECT_NO_THROW(expr->at(0)->evaluate(*pkt6, values));
- ASSERT_EQ(1, values.size());
+ ASSERT_EQ(1U, values.size());
EXPECT_EQ("abc", values.top());
}
FlexOptionImpl::OptionConfigList opt_lst;
ASSERT_NO_THROW(opt_lst = map.at(DHO_HOST_NAME));
ASSERT_FALSE(opt_lst.empty());
- EXPECT_EQ(1, opt_lst.size());
+ EXPECT_EQ(1U, opt_lst.size());
FlexOptionImpl::OptionConfigPtr opt_cfg;
ASSERT_NO_THROW(opt_cfg = opt_lst.front());
ExpressionPtr expr = opt_cfg->getExpr();
ASSERT_TRUE(expr);
- ASSERT_EQ(3, expr->size());
+ ASSERT_EQ(3U, expr->size());
Pkt4Ptr pkt4(new Pkt4(DHCPDISCOVER, 12345));
ValueStack values;
EXPECT_NO_THROW(expr->at(0)->evaluate(*pkt4, values));
- ASSERT_EQ(1, values.size());
+ ASSERT_EQ(1U, values.size());
EXPECT_EQ("abc", values.top());
EXPECT_NO_THROW(expr->at(1)->evaluate(*pkt4, values));
- ASSERT_EQ(2, values.size());
+ ASSERT_EQ(2U, values.size());
EXPECT_NO_THROW(expr->at(2)->evaluate(*pkt4, values));
- ASSERT_EQ(1, values.size());
+ ASSERT_EQ(1U, values.size());
EXPECT_EQ("true", values.top());
}
FlexOptionImpl::OptionConfigList opt_lst;
ASSERT_NO_THROW(opt_lst = map.at(D6O_BOOTFILE_URL));
ASSERT_FALSE(opt_lst.empty());
- EXPECT_EQ(1, opt_lst.size());
+ EXPECT_EQ(1U, opt_lst.size());
FlexOptionImpl::OptionConfigPtr opt_cfg;
ASSERT_NO_THROW(opt_cfg = opt_lst.front());
ExpressionPtr expr = opt_cfg->getExpr();
ASSERT_TRUE(expr);
- ASSERT_EQ(3, expr->size());
+ ASSERT_EQ(3U, expr->size());
Pkt6Ptr pkt6(new Pkt6(DHCPV6_SOLICIT, 12345));
ValueStack values;
EXPECT_NO_THROW(expr->at(0)->evaluate(*pkt6, values));
- ASSERT_EQ(1, values.size());
+ ASSERT_EQ(1U, values.size());
EXPECT_EQ("abc", values.top());
EXPECT_NO_THROW(expr->at(1)->evaluate(*pkt6, values));
- ASSERT_EQ(2, values.size());
+ ASSERT_EQ(2U, values.size());
EXPECT_NO_THROW(expr->at(2)->evaluate(*pkt6, values));
- ASSERT_EQ(1, values.size());
+ ASSERT_EQ(1U, values.size());
EXPECT_EQ("true", values.top());
}
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getOptionConfigMap();
- EXPECT_EQ(2, map.size());
+ EXPECT_EQ(2U, map.size());
FlexOptionImpl::OptionConfigList opt1_lst;
ASSERT_NO_THROW(opt1_lst = map.at(DHO_HOST_NAME));
ASSERT_FALSE(opt1_lst.empty());
- EXPECT_EQ(1, opt1_lst.size());
+ EXPECT_EQ(1U, opt1_lst.size());
FlexOptionImpl::OptionConfigPtr opt1_cfg;
ASSERT_NO_THROW(opt1_cfg = opt1_lst.front());
FlexOptionImpl::OptionConfigList opt2_lst;
ASSERT_NO_THROW(opt2_lst = map.at(DHO_ROOT_PATH));
ASSERT_FALSE(opt2_lst.empty());
- EXPECT_EQ(1, opt2_lst.size());
+ EXPECT_EQ(1U, opt2_lst.size());
FlexOptionImpl::OptionConfigPtr opt2_cfg;
ASSERT_NO_THROW(opt2_cfg = opt2_lst.front());
ASSERT_TRUE(opt);
EXPECT_EQ(DHO_HOST_NAME, opt->getType());
const OptionBuffer& buffer = opt->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
opt = response->getOption(DHO_DOMAIN_SEARCH);
ASSERT_TRUE(opt);
EXPECT_EQ(DHO_DOMAIN_SEARCH, opt->getType());
const OptionBuffer& buffer_fqdn = opt->getData();
- ASSERT_EQ(13, buffer_fqdn.size());
- EXPECT_EQ(7, buffer_fqdn[0]);
+ ASSERT_EQ(13U, buffer_fqdn.size());
+ EXPECT_EQ(7U, buffer_fqdn[0]);
EXPECT_EQ(0, memcmp(&buffer_fqdn[1], "example", 7));
- EXPECT_EQ(3, buffer_fqdn[8]);
+ EXPECT_EQ(3U, buffer_fqdn[8]);
EXPECT_EQ(0, memcmp(&buffer_fqdn[9], "com", 3));
- EXPECT_EQ(0, buffer_fqdn[12]);
+ EXPECT_EQ(0U, buffer_fqdn[12]);
}
// Verify that ADD action adds the specified option in raw format.
ASSERT_TRUE(opt);
EXPECT_EQ(DHO_HOST_NAME, opt->getType());
const OptionBuffer& buffer = opt->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
opt = response->getOption(DHO_DOMAIN_SEARCH);
ASSERT_TRUE(opt);
EXPECT_EQ(DHO_DOMAIN_SEARCH, opt->getType());
const OptionBuffer& buffer_fqdn = opt->getData();
- ASSERT_EQ(13, buffer_fqdn.size());
- EXPECT_EQ(7, buffer_fqdn[0]);
+ ASSERT_EQ(13U, buffer_fqdn.size());
+ EXPECT_EQ(7U, buffer_fqdn[0]);
EXPECT_EQ(0, memcmp(&buffer_fqdn[1], "example", 7));
- EXPECT_EQ(3, buffer_fqdn[8]);
+ EXPECT_EQ(3U, buffer_fqdn[8]);
EXPECT_EQ(0, memcmp(&buffer_fqdn[9], "com", 3));
- EXPECT_EQ(0, buffer_fqdn[12]);
+ EXPECT_EQ(0U, buffer_fqdn[12]);
}
// Verify that ADD action does not add an already existing option.
ASSERT_TRUE(opt);
EXPECT_EQ(DHO_HOST_NAME, opt->getType());
const OptionBuffer& buffer = opt->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
opt = response->getOption(DHO_DOMAIN_SEARCH);
ASSERT_TRUE(opt);
EXPECT_EQ(DHO_DOMAIN_SEARCH, opt->getType());
const OptionBuffer& buffer_fqdn = opt->getData();
- ASSERT_EQ(13, buffer_fqdn.size());
- EXPECT_EQ(7, buffer_fqdn[0]);
+ ASSERT_EQ(13U, buffer_fqdn.size());
+ EXPECT_EQ(7U, buffer_fqdn[0]);
EXPECT_EQ(0, memcmp(&buffer_fqdn[1], "example", 7));
- EXPECT_EQ(3, buffer_fqdn[8]);
+ EXPECT_EQ(3U, buffer_fqdn[8]);
EXPECT_EQ(0, memcmp(&buffer_fqdn[9], "com", 3));
- EXPECT_EQ(0, buffer_fqdn[12]);
+ EXPECT_EQ(0U, buffer_fqdn[12]);
}
// Verify that SUPERSEDE action supersedes the specified option in raw format.
ASSERT_TRUE(opt);
EXPECT_EQ(DHO_HOST_NAME, opt->getType());
const OptionBuffer& buffer = opt->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
opt = response->getOption(DHO_DOMAIN_SEARCH);
ASSERT_TRUE(opt);
EXPECT_EQ(DHO_DOMAIN_SEARCH, opt->getType());
const OptionBuffer& buffer_fqdn = opt->getData();
- ASSERT_EQ(13, buffer_fqdn.size());
- EXPECT_EQ(7, buffer_fqdn[0]);
+ ASSERT_EQ(13U, buffer_fqdn.size());
+ EXPECT_EQ(7U, buffer_fqdn[0]);
EXPECT_EQ(0, memcmp(&buffer_fqdn[1], "example", 7));
- EXPECT_EQ(3, buffer_fqdn[8]);
+ EXPECT_EQ(3U, buffer_fqdn[8]);
EXPECT_EQ(0, memcmp(&buffer_fqdn[9], "com", 3));
- EXPECT_EQ(0, buffer_fqdn[12]);
+ EXPECT_EQ(0U, buffer_fqdn[12]);
}
// Verify that SUPERSEDE action supersedes an already existing option.
ASSERT_TRUE(opt);
EXPECT_EQ(D6O_BOOTFILE_URL, opt->getType());
const OptionBuffer& buffer = opt->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
uint8_t expected[] = { 0xab, 0xcd, 0xef };
EXPECT_EQ(0, memcmp(&buffer[0], expected, 3));
ASSERT_TRUE(opt);
EXPECT_EQ(D6O_DOMAIN_SEARCH, opt->getType());
const OptionBuffer& buffer_fqdn = opt->getData();
- ASSERT_EQ(13, buffer_fqdn.size());
- EXPECT_EQ(7, buffer_fqdn[0]);
+ ASSERT_EQ(13U, buffer_fqdn.size());
+ EXPECT_EQ(7U, buffer_fqdn[0]);
EXPECT_EQ(0, memcmp(&buffer_fqdn[1], "example", 7));
- EXPECT_EQ(3, buffer_fqdn[8]);
+ EXPECT_EQ(3U, buffer_fqdn[8]);
EXPECT_EQ(0, memcmp(&buffer_fqdn[9], "com", 3));
- EXPECT_EQ(0, buffer_fqdn[12]);
+ EXPECT_EQ(0U, buffer_fqdn[12]);
}
// Verify that SUPERSEDE action does not supersede an empty value.
ASSERT_TRUE(opt);
EXPECT_EQ(DHO_HOST_NAME, opt->getType());
const OptionBuffer& buffer = opt->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
}
ASSERT_TRUE(opt);
EXPECT_EQ(D6O_BOOTFILE_URL, opt->getType());
const OptionBuffer& buffer = opt->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "add", 3));
}
ASSERT_TRUE(opt);
EXPECT_EQ(DHO_HOST_NAME, opt->getType());
const OptionBuffer& buffer = opt->getData();
- ASSERT_EQ(9, buffer.size());
+ ASSERT_EQ(9U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "supersede", 9));
}
ASSERT_TRUE(opt);
EXPECT_EQ(DHO_BOOT_FILE_NAME, opt->getType());
const OptionBuffer& buffer = opt->getData();
- ASSERT_EQ(8, buffer.size());
+ ASSERT_EQ(8U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "foo.boot", 8));
}
ASSERT_TRUE(opt);
EXPECT_EQ(D6O_NEW_POSIX_TIMEZONE, opt->getType());
const OptionBuffer& buffer = opt->getData();
- EXPECT_EQ(35, buffer.size());
+ EXPECT_EQ(35U, buffer.size());
std::string data("EST5EDT4,M3.2.0/02:00,M11.1.0/02:00");
EXPECT_EQ(0, memcmp(&buffer[0], &data[0], buffer.size()));
}
ASSERT_TRUE(opt);
EXPECT_EQ(D6O_NEW_POSIX_TIMEZONE, opt->getType());
const OptionBuffer& buffer = opt->getData();
- EXPECT_EQ(35, buffer.size());
+ EXPECT_EQ(35U, buffer.size());
std::string data("EST5EDT4,M3.2.0/02:00,M11.1.0/02:00");
EXPECT_EQ(0, memcmp(&buffer[0], &data[0], buffer.size()));
}
FlexOptionImpl::OptionConfigList opt_lst;
ASSERT_NO_THROW(opt_lst = map.at(DHO_HOST_NAME));
ASSERT_FALSE(opt_lst.empty());
- EXPECT_EQ(1, opt_lst.size());
+ EXPECT_EQ(1U, opt_lst.size());
FlexOptionImpl::OptionConfigPtr opt_cfg;
ASSERT_NO_THROW(opt_cfg = opt_lst.front());
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getSubOptionConfigMap();
- EXPECT_EQ(1, map.count(109));
+ EXPECT_EQ(1U, map.count(109));
auto smap = map[109];
- EXPECT_EQ(1, smap.count(222));
+ EXPECT_EQ(1U, smap.count(222));
}
// Verify that the definition is not required when csv-format is false.
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getSubOptionConfigMap();
- EXPECT_EQ(1, map.count(109));
+ EXPECT_EQ(1U, map.count(109));
auto smap = map[109];
- EXPECT_EQ(1, smap.count(222));
+ EXPECT_EQ(1U, smap.count(222));
}
// Verify that the code must be a known sub-option when csv-format is true.
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getSubOptionConfigMap();
- EXPECT_EQ(1, map.count(109));
+ EXPECT_EQ(1U, map.count(109));
auto smap = map[109];
- EXPECT_EQ(1, smap.count(222));
+ EXPECT_EQ(1U, smap.count(222));
}
// Verify that the name can be a last resort space defined sub-option.
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getSubOptionConfigMap();
- EXPECT_EQ(1, map.count(DHO_VENDOR_ENCAPSULATED_OPTIONS));
+ EXPECT_EQ(1U, map.count(DHO_VENDOR_ENCAPSULATED_OPTIONS));
auto smap = map[DHO_VENDOR_ENCAPSULATED_OPTIONS];
- EXPECT_EQ(1, smap.count(222));
+ EXPECT_EQ(1U, smap.count(222));
}
// Verify that the sub-option definition can be fetched from the last
EXPECT_NO_THROW(impl_->testConfigure(options));
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getSubOptionConfigMap();
- EXPECT_EQ(1, map.count(DHO_VENDOR_ENCAPSULATED_OPTIONS));
+ EXPECT_EQ(1U, map.count(DHO_VENDOR_ENCAPSULATED_OPTIONS));
auto smap = map[DHO_VENDOR_ENCAPSULATED_OPTIONS];
- EXPECT_EQ(1, smap.count(222));
+ EXPECT_EQ(1U, smap.count(222));
}
// Verify that the name can be a vendor defined sub-option.
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getSubOptionConfigMap();
- EXPECT_EQ(1, map.count(D6O_VENDOR_OPTS));
+ EXPECT_EQ(1U, map.count(D6O_VENDOR_OPTS));
auto smap = map[D6O_VENDOR_OPTS];
- EXPECT_EQ(1, smap.count(222));
+ EXPECT_EQ(1U, smap.count(222));
}
// Verify that the sub-option definition can be fetched from a custom
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getSubOptionConfigMap();
- EXPECT_EQ(1, map.count(D6O_VENDOR_OPTS));
+ EXPECT_EQ(1U, map.count(D6O_VENDOR_OPTS));
auto smap = map[D6O_VENDOR_OPTS];
- EXPECT_EQ(1, smap.count(222));
+ EXPECT_EQ(1U, smap.count(222));
}
// Verify that the name can be a vendor standard sub-option.
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getSubOptionConfigMap();
- EXPECT_EQ(1, map.count(DHO_VIVSO_SUBOPTIONS));
+ EXPECT_EQ(1U, map.count(DHO_VIVSO_SUBOPTIONS));
auto smap = map[DHO_VIVSO_SUBOPTIONS];
// DOCSIS3_V4_TFTP_SERVERS is 2
- EXPECT_EQ(1, smap.count(2));
+ EXPECT_EQ(1U, smap.count(2));
}
// Verify that the sub-option definition can be fetched from a standard
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getSubOptionConfigMap();
- EXPECT_EQ(1, map.count(DHO_VIVSO_SUBOPTIONS));
+ EXPECT_EQ(1U, map.count(DHO_VIVSO_SUBOPTIONS));
auto smap = map[DHO_VIVSO_SUBOPTIONS];
// DOCSIS3_V4_TFTP_SERVERS is 2
- EXPECT_EQ(1, smap.count(2));
+ EXPECT_EQ(1U, smap.count(2));
}
// Verify that the name must match the code.
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getSubOptionConfigMap();
- EXPECT_EQ(1, map.count(109));
+ EXPECT_EQ(1U, map.count(109));
auto smap = map[109];
FlexOptionImpl::SubOptionConfigPtr sub_cfg;
ASSERT_NO_THROW(sub_cfg = smap.at(1));
ASSERT_TRUE(sub_cfg);
- EXPECT_EQ(1, sub_cfg->getCode());
+ EXPECT_EQ(1U, sub_cfg->getCode());
EXPECT_EQ(FlexOptionImpl::ADD, sub_cfg->getAction());
EXPECT_EQ(FlexOptionImpl::ADD, sub_cfg->getContainerAction());
EXPECT_EQ("'abc'", sub_cfg->getText());
- EXPECT_EQ(109, sub_cfg->getContainerCode());
+ EXPECT_EQ(109U, sub_cfg->getContainerCode());
ASSERT_NO_THROW(sub_cfg = smap.at(2));
ASSERT_TRUE(sub_cfg);
- EXPECT_EQ(2, sub_cfg->getCode());
+ EXPECT_EQ(2U, sub_cfg->getCode());
EXPECT_EQ(FlexOptionImpl::SUPERSEDE, sub_cfg->getAction());
EXPECT_EQ(FlexOptionImpl::NONE, sub_cfg->getContainerAction());
EXPECT_EQ("'def'", sub_cfg->getText());
- EXPECT_EQ(109, sub_cfg->getContainerCode());
+ EXPECT_EQ(109U, sub_cfg->getContainerCode());
ASSERT_NO_THROW(sub_cfg = smap.at(3));
ASSERT_TRUE(sub_cfg);
- EXPECT_EQ(3, sub_cfg->getCode());
+ EXPECT_EQ(3U, sub_cfg->getCode());
EXPECT_EQ(FlexOptionImpl::REMOVE, sub_cfg->getAction());
EXPECT_EQ(FlexOptionImpl::REMOVE, sub_cfg->getContainerAction());
EXPECT_EQ("'a' == 'b'", sub_cfg->getText());
- EXPECT_EQ(109, sub_cfg->getContainerCode());
+ EXPECT_EQ(109U, sub_cfg->getContainerCode());
ASSERT_NO_THROW(sub_cfg = smap.at(4));
ASSERT_TRUE(sub_cfg);
- EXPECT_EQ(4, sub_cfg->getCode());
+ EXPECT_EQ(4U, sub_cfg->getCode());
EXPECT_EQ(FlexOptionImpl::REMOVE, sub_cfg->getAction());
EXPECT_EQ(FlexOptionImpl::NONE, sub_cfg->getContainerAction());
EXPECT_EQ("'b' == 'a'", sub_cfg->getText());
- EXPECT_EQ(109, sub_cfg->getContainerCode());
+ EXPECT_EQ(109U, sub_cfg->getContainerCode());
}
// Empty sub-option config list doing nothing is the same as empty option list.
OptionPtr opt = response->getOption(222);
ASSERT_TRUE(opt);
- EXPECT_EQ(222, opt->getType());
+ EXPECT_EQ(222U, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
// The fqdn array is the most complex encoding of one element...
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(13, buffer.size());
- EXPECT_EQ(7, buffer[0]);
+ ASSERT_EQ(13U, buffer.size());
+ EXPECT_EQ(7U, buffer[0]);
EXPECT_EQ(0, memcmp(&buffer[1], "example", 7));
- EXPECT_EQ(3, buffer[8]);
+ EXPECT_EQ(3U, buffer[8]);
EXPECT_EQ(0, memcmp(&buffer[9], "com", 3));
- EXPECT_EQ(0, buffer[12]);
+ EXPECT_EQ(0U, buffer[12]);
}
// Verify that ADD action does nothing when the container does not exist and
OptionPtr opt = response->getOption(222);
ASSERT_TRUE(opt);
- EXPECT_EQ(222, opt->getType());
+ EXPECT_EQ(222U, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(13, buffer.size());
- EXPECT_EQ(7, buffer[0]);
+ ASSERT_EQ(13U, buffer.size());
+ EXPECT_EQ(7U, buffer[0]);
EXPECT_EQ(0, memcmp(&buffer[1], "example", 7));
- EXPECT_EQ(3, buffer[8]);
+ EXPECT_EQ(3U, buffer[8]);
EXPECT_EQ(0, memcmp(&buffer[9], "com", 3));
- EXPECT_EQ(0, buffer[12]);
+ EXPECT_EQ(0U, buffer[12]);
}
// Verify that ADD action adds the specified sub-option in an already
EXPECT_NO_THROW(impl_->process<Pkt4Ptr>(Option::V4, query, response));
// Only one option with code 222.
- EXPECT_EQ(1, response->options_.count(222));
+ EXPECT_EQ(1U, response->options_.count(222));
OptionPtr opt = response->getOption(222);
ASSERT_TRUE(opt);
- EXPECT_EQ(222, opt->getType());
+ EXPECT_EQ(222U, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
// Only one sub-option.
auto const& opts = opt->getOptions();
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
}
// Verify that ADD action does not add an already existing sub-option.
EXPECT_EQ(response_txt, response->toText());
OptionPtr opt = response->getOption(222);
ASSERT_TRUE(opt);
- EXPECT_EQ(222, opt->getType());
+ EXPECT_EQ(222U, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(4, buffer.size());
+ ASSERT_EQ(4U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "xyzt", 4));
// Only one sub-option.
auto const& opts = opt->getOptions();
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
}
// Verify that ADD action does not add an empty value.
EXPECT_EQ(DHO_VENDOR_ENCAPSULATED_OPTIONS, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(6, buffer.size());
+ ASSERT_EQ(6U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "foobar", 6));
}
Option4AddrLstPtr addr = boost::dynamic_pointer_cast<Option4AddrLst>(sub);
ASSERT_TRUE(addr);
auto const& addrs = addr->getAddresses();
- ASSERT_EQ(1, addrs.size());
+ ASSERT_EQ(1U, addrs.size());
EXPECT_EQ("10.1.2.3", addrs[0].toText());
}
OptionPtr sub = vendor->getOption(DOCSIS3_V6_VENDOR_NAME);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(6, buffer.size());
+ ASSERT_EQ(6U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "foobar", 6));
}
ASSERT_TRUE(opt);
OptionVendorPtr vendor = boost::dynamic_pointer_cast<OptionVendor>(opt);
ASSERT_TRUE(vendor);
- EXPECT_EQ(123456, vendor->getVendorId());
+ EXPECT_EQ(123456U, vendor->getVendorId());
OptionPtr sub = vendor->getOption(1);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(6, buffer.size());
+ ASSERT_EQ(6U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "foobar", 6));
}
ASSERT_TRUE(opt);
vendor = boost::dynamic_pointer_cast<OptionVendor>(opt);
ASSERT_TRUE(vendor);
- EXPECT_EQ(67890, vendor->getVendorId());
+ EXPECT_EQ(67890U, vendor->getVendorId());
OptionPtr sub = vendor->getOption(1);
EXPECT_FALSE(sub);
sub = vendor->getOption(2);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(4, buffer.size());
+ ASSERT_EQ(4U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "xyzt", 4));
}
ASSERT_TRUE(opt);
OptionVendorPtr vendor = boost::dynamic_pointer_cast<OptionVendor>(opt);
ASSERT_TRUE(vendor);
- EXPECT_EQ(123456, vendor->getVendorId());
+ EXPECT_EQ(123456U, vendor->getVendorId());
OptionPtr sub = vendor->getOption(1);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(6, buffer.size());
+ ASSERT_EQ(6U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "foobar", 6));
}
ASSERT_TRUE(opt);
vendor = boost::dynamic_pointer_cast<OptionVendor>(opt);
ASSERT_TRUE(vendor);
- EXPECT_EQ(67890, vendor->getVendorId());
+ EXPECT_EQ(67890U, vendor->getVendorId());
OptionPtr sub = vendor->getOption(1);
EXPECT_FALSE(sub);
sub = vendor->getOption(2);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(4, buffer.size());
+ ASSERT_EQ(4U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "xyzt", 4));
}
OptionPtr opt = response->getOption(222);
ASSERT_TRUE(opt);
- EXPECT_EQ(222, opt->getType());
+ EXPECT_EQ(222U, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
// The fqdn array is the most complex encoding of one element...
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(13, buffer.size());
- EXPECT_EQ(7, buffer[0]);
+ ASSERT_EQ(13U, buffer.size());
+ EXPECT_EQ(7U, buffer[0]);
EXPECT_EQ(0, memcmp(&buffer[1], "example", 7));
- EXPECT_EQ(3, buffer[8]);
+ EXPECT_EQ(3U, buffer[8]);
EXPECT_EQ(0, memcmp(&buffer[9], "com", 3));
- EXPECT_EQ(0, buffer[12]);
+ EXPECT_EQ(0U, buffer[12]);
}
// Verify that SUPERSEDE action does nothing when the container does not exist
OptionPtr opt = response->getOption(222);
ASSERT_TRUE(opt);
- EXPECT_EQ(222, opt->getType());
+ EXPECT_EQ(222U, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(13, buffer.size());
- EXPECT_EQ(7, buffer[0]);
+ ASSERT_EQ(13U, buffer.size());
+ EXPECT_EQ(7U, buffer[0]);
EXPECT_EQ(0, memcmp(&buffer[1], "example", 7));
- EXPECT_EQ(3, buffer[8]);
+ EXPECT_EQ(3U, buffer[8]);
EXPECT_EQ(0, memcmp(&buffer[9], "com", 3));
- EXPECT_EQ(0, buffer[12]);
+ EXPECT_EQ(0U, buffer[12]);
}
// Verify that SUPERSEDE action adds the specified sub-option in an already
EXPECT_NO_THROW(impl_->process<Pkt4Ptr>(Option::V4, query, response));
// Only one option with code 222.
- EXPECT_EQ(1, response->options_.count(222));
+ EXPECT_EQ(1U, response->options_.count(222));
OptionPtr opt = response->getOption(222);
ASSERT_TRUE(opt);
- EXPECT_EQ(222, opt->getType());
+ EXPECT_EQ(222U, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
// Only one sub-option.
auto const& opts = opt->getOptions();
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
}
// Verify that SUPERSEDE action replaces an already existing sub-option.
EXPECT_NO_THROW(impl_->process<Pkt4Ptr>(Option::V4, query, response));
// Only one option with code 222.
- EXPECT_EQ(1, response->options_.count(222));
+ EXPECT_EQ(1U, response->options_.count(222));
OptionPtr opt = response->getOption(222);
ASSERT_TRUE(opt);
- EXPECT_EQ(222, opt->getType());
+ EXPECT_EQ(222U, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
// Only one sub-option.
auto const& opts = opt->getOptions();
- EXPECT_EQ(1, opts.size());
+ EXPECT_EQ(1U, opts.size());
}
// Verify that SUPERSEDE action does not add an empty value.
EXPECT_EQ(DHO_VENDOR_ENCAPSULATED_OPTIONS, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(6, buffer.size());
+ ASSERT_EQ(6U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "foobar", 6));
}
OptionPtr sub = vendor->getOption(DOCSIS3_V4_TFTP_SERVERS);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(4, buffer.size());
+ ASSERT_EQ(4U, buffer.size());
uint8_t expected[] = { 10, 1, 2, 3 };
EXPECT_EQ(0, memcmp(&buffer[0], expected, 4));
}
OptionPtr sub = vendor->getOption(DOCSIS3_V6_VENDOR_NAME);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(6, buffer.size());
+ ASSERT_EQ(6U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "foobar", 6));
}
ASSERT_TRUE(opt);
OptionVendorPtr vendor = boost::dynamic_pointer_cast<OptionVendor>(opt);
ASSERT_TRUE(vendor);
- EXPECT_EQ(123456, vendor->getVendorId());
+ EXPECT_EQ(123456U, vendor->getVendorId());
OptionPtr sub = vendor->getOption(1);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(6, buffer.size());
+ ASSERT_EQ(6U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "foobar", 6));
}
ASSERT_TRUE(opt);
vendor = boost::dynamic_pointer_cast<OptionVendor>(opt);
ASSERT_TRUE(vendor);
- EXPECT_EQ(67890, vendor->getVendorId());
+ EXPECT_EQ(67890U, vendor->getVendorId());
OptionPtr sub = vendor->getOption(1);
EXPECT_FALSE(sub);
sub = vendor->getOption(2);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(4, buffer.size());
+ ASSERT_EQ(4U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "xyzt", 4));
}
ASSERT_TRUE(opt);
OptionVendorPtr vendor = boost::dynamic_pointer_cast<OptionVendor>(opt);
ASSERT_TRUE(vendor);
- EXPECT_EQ(123456, vendor->getVendorId());
+ EXPECT_EQ(123456U, vendor->getVendorId());
OptionPtr sub = vendor->getOption(1);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(6, buffer.size());
+ ASSERT_EQ(6U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "foobar", 6));
}
ASSERT_TRUE(opt);
vendor = boost::dynamic_pointer_cast<OptionVendor>(opt);
ASSERT_TRUE(vendor);
- EXPECT_EQ(67890, vendor->getVendorId());
+ EXPECT_EQ(67890U, vendor->getVendorId());
OptionPtr sub = vendor->getOption(1);
EXPECT_FALSE(sub);
sub = vendor->getOption(2);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(4, buffer.size());
+ ASSERT_EQ(4U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "xyzt", 4));
}
OptionPtr opt = response->getOption(222);
ASSERT_TRUE(opt);
EXPECT_FALSE(opt->getOption(2));
- EXPECT_EQ(1, opt->getOptions().size());
+ EXPECT_EQ(1U, opt->getOptions().size());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
}
EXPECT_EQ(response_txt, response->toText());
OptionPtr opt = response->getOption(222);
ASSERT_TRUE(opt);
- EXPECT_EQ(222, opt->getType());
+ EXPECT_EQ(222U, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
}
ASSERT_TRUE(opt);
vendor = boost::dynamic_pointer_cast<OptionVendor>(opt);
ASSERT_TRUE(vendor);
- EXPECT_EQ(67890, vendor->getVendorId());
+ EXPECT_EQ(67890U, vendor->getVendorId());
OptionPtr sub = vendor->getOption(1);
EXPECT_FALSE(sub);
sub = vendor->getOption(2);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(4, buffer.size());
+ ASSERT_EQ(4U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "xyzt", 4));
}
ASSERT_TRUE(opt);
vendor = boost::dynamic_pointer_cast<OptionVendor>(opt);
ASSERT_TRUE(vendor);
- EXPECT_EQ(67890, vendor->getVendorId());
+ EXPECT_EQ(67890U, vendor->getVendorId());
OptionPtr sub = vendor->getOption(1);
EXPECT_FALSE(sub);
sub = vendor->getOption(2);
ASSERT_TRUE(sub);
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(4, buffer.size());
+ ASSERT_EQ(4U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "xyzt", 4));
}
EXPECT_TRUE(impl_->getErrMsg().empty()) << impl_->getErrMsg();
auto map = impl_->getSubOptionConfigMap();
- EXPECT_EQ(1, map.count(109));
+ EXPECT_EQ(1U, map.count(109));
auto smap = map[109];
FlexOptionImpl::SubOptionConfigPtr sub_cfg;
ASSERT_NO_THROW(sub_cfg = smap.at(222));
ASSERT_TRUE(sub_cfg);
- EXPECT_EQ(222, sub_cfg->getCode());
- EXPECT_EQ(109, sub_cfg->getContainerCode());
+ EXPECT_EQ(222U, sub_cfg->getCode());
+ EXPECT_EQ(109U, sub_cfg->getContainerCode());
EXPECT_EQ("foobar", sub_cfg->getClass());
}
OptionPtr opt = response->getOption(222);
ASSERT_TRUE(opt);
- EXPECT_EQ(222, opt->getType());
+ EXPECT_EQ(222U, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
}
OptionPtr opt = response->getOption(222);
ASSERT_TRUE(opt);
- EXPECT_EQ(222, opt->getType());
+ EXPECT_EQ(222U, opt->getType());
OptionPtr sub = opt->getOption(1);
ASSERT_TRUE(sub);
- EXPECT_EQ(1, sub->getType());
+ EXPECT_EQ(1U, sub->getType());
const OptionBuffer& buffer = sub->getData();
- ASSERT_EQ(3, buffer.size());
+ ASSERT_EQ(3U, buffer.size());
EXPECT_EQ(0, memcmp(&buffer[0], "abc", 3));
}
// Verifies the LegalLogDbLogger class works as expected
TEST_F(LegalLogMgrTest, legalLogDbLogger) {
- EXPECT_EQ(1, db_logger_stack.size());
+ EXPECT_EQ(1U, db_logger_stack.size());
// Open a block
{
- EXPECT_EQ(1, db_logger_stack.size());
+ EXPECT_EQ(1U, db_logger_stack.size());
// Push local logger
LegalLogDbLogger pushed(legal_log_db_logger);
// Check now we have a second logger
- EXPECT_EQ(2, db_logger_stack.size());
+ EXPECT_EQ(2U, db_logger_stack.size());
}
// Logger was popped when existing the block
- EXPECT_EQ(1, db_logger_stack.size());
+ EXPECT_EQ(1U, db_logger_stack.size());
// Open a try block to check it works with it
try {
- EXPECT_EQ(1, db_logger_stack.size());
+ EXPECT_EQ(1U, db_logger_stack.size());
LegalLogDbLogger pushed(legal_log_db_logger);
- EXPECT_EQ(2, db_logger_stack.size());
+ EXPECT_EQ(2U, db_logger_stack.size());
} catch (const std::exception&) {
ADD_FAILURE() << "no exception was raised";
}
- EXPECT_EQ(1, db_logger_stack.size());
+ EXPECT_EQ(1U, db_logger_stack.size());
// Another check with an exception now
try {
- EXPECT_EQ(1, db_logger_stack.size());
+ EXPECT_EQ(1U, db_logger_stack.size());
LegalLogDbLogger pushed(legal_log_db_logger);
- EXPECT_EQ(2, db_logger_stack.size());
+ EXPECT_EQ(2U, db_logger_stack.size());
isc_throw(Unexpected, "for testing");
ADD_FAILURE() << "an exception was raised";
} catch (const std::exception&) {
// The handler is outside the block
- EXPECT_EQ(1, db_logger_stack.size());
+ EXPECT_EQ(1U, db_logger_stack.size());
}
- ASSERT_EQ(1, db_logger_stack.size());
+ ASSERT_EQ(1U, db_logger_stack.size());
}
// Verifies that vectorDump handles empty content (for static analyzers)
<< " invalid path specified: '/tmp', supported path is '"
<< LegalLogMgr::getLogPath() << "'";
- EXPECT_EQ(1, countFile(os.str()));
+ EXPECT_EQ(1U, countFile(os.str()));
}
// Verify that parsing extra parameters for rotate file works
ConstElementPtr service = command->get("service");
ASSERT_TRUE(service);
ASSERT_EQ(Element::list, service->getType());
- ASSERT_EQ(1, service->size());
+ ASSERT_EQ(1U, service->size());
ASSERT_EQ(Element::string, service->get(0)->getType());
EXPECT_EQ(expected_service, service->get(0)->stringValue());
ConstElementPtr service = command->get("service");
ASSERT_TRUE(service);
ASSERT_EQ(Element::list, service->getType());
- ASSERT_EQ(1, service->size());
+ ASSERT_EQ(1U, service->size());
ASSERT_EQ(Element::string, service->get(0)->getType());
EXPECT_EQ(expected_service, service->get(0)->stringValue());
ConstElementPtr arguments;
ASSERT_NO_FATAL_FAILURE(testCommandBasics(command, "dhcp-disable", "dhcp4",
arguments));
- ASSERT_EQ(3, arguments->size());
+ ASSERT_EQ(3U, arguments->size());
ConstElementPtr max_period = arguments->get("max-period");
ASSERT_TRUE(max_period);
ASSERT_EQ(Element::integer, max_period->getType());
HAServerType::DHCPv4);
ASSERT_NO_FATAL_FAILURE(testCommandBasics(command, "dhcp-disable", "dhcp4",
arguments));
- ASSERT_EQ(2, arguments->size());
+ ASSERT_EQ(2U, arguments->size());
origin_id = arguments->get("origin-id");
ASSERT_TRUE(origin_id);
ASSERT_EQ(NetworkState::HA_REMOTE_COMMAND+1, origin_id->intValue());
HAServerType::DHCPv4);
ASSERT_NO_FATAL_FAILURE(testCommandBasics(command, "dhcp-enable", "dhcp4",
arguments));
- ASSERT_EQ(2, arguments->size());
+ ASSERT_EQ(2U, arguments->size());
ConstElementPtr origin_id = arguments->get("origin-id");
ASSERT_TRUE(origin_id);
ASSERT_EQ(NetworkState::HA_REMOTE_COMMAND+1, origin_id->intValue());
ConstElementPtr arguments;
ASSERT_NO_FATAL_FAILURE(testCommandBasics(command, "dhcp-disable", "dhcp6",
arguments));
- ASSERT_EQ(3, arguments->size());
+ ASSERT_EQ(3U, arguments->size());
ConstElementPtr max_period = arguments->get("max-period");
ASSERT_TRUE(max_period);
ASSERT_EQ(Element::integer, max_period->getType());
command = CommandCreator::createDHCPDisable(NetworkState::HA_REMOTE_COMMAND+2, 0, HAServerType::DHCPv6);
ASSERT_NO_FATAL_FAILURE(testCommandBasics(command, "dhcp-disable", "dhcp6",
arguments));
- ASSERT_EQ(2, arguments->size());
+ ASSERT_EQ(2U, arguments->size());
origin_id = arguments->get("origin-id");
ASSERT_TRUE(origin_id);
ASSERT_EQ(NetworkState::HA_REMOTE_COMMAND+2, origin_id->intValue());
ConstElementPtr command = CommandCreator::createDHCPEnable(NetworkState::HA_REMOTE_COMMAND+2, HAServerType::DHCPv6);
ASSERT_NO_FATAL_FAILURE(testCommandBasics(command, "dhcp-enable", "dhcp6",
arguments));
- ASSERT_EQ(2, arguments->size());
+ ASSERT_EQ(2U, arguments->size());
ConstElementPtr origin_id = arguments->get("origin-id");
ASSERT_TRUE(origin_id);
ASSERT_EQ(NetworkState::HA_REMOTE_COMMAND+2, origin_id->intValue());
auto deleted_leases_json = arguments->get("deleted-leases");
ASSERT_TRUE(deleted_leases_json);
ASSERT_EQ(Element::list, deleted_leases_json->getType());
- ASSERT_EQ(1, deleted_leases_json->size());
+ ASSERT_EQ(1U, deleted_leases_json->size());
auto lease_as_json = deleted_leases_json->get(0);
EXPECT_EQ(leaseAsJson(deleted_lease)->str(), lease_as_json->str());
auto leases_json = arguments->get("leases");
ASSERT_TRUE(leases_json);
ASSERT_EQ(Element::list, leases_json->getType());
- ASSERT_EQ(1, leases_json->size());
+ ASSERT_EQ(1U, leases_json->size());
lease_as_json = leases_json->get(0);
EXPECT_EQ(leaseAsJson(lease)->str(), lease_as_json->str());
}
auto deleted_leases_json = arguments->get("deleted-leases");
ASSERT_TRUE(deleted_leases_json);
ASSERT_EQ(Element::list, deleted_leases_json->getType());
- EXPECT_EQ(0, deleted_leases_json->size());
+ EXPECT_EQ(0U, deleted_leases_json->size());
// The lease in the released state should be in the updated leases list.
auto leases_json = arguments->get("leases");
ASSERT_TRUE(leases_json);
ASSERT_EQ(Element::list, leases_json->getType());
- ASSERT_EQ(1, leases_json->size());
+ ASSERT_EQ(1U, leases_json->size());
auto lease_as_json = leases_json->get(0);
EXPECT_EQ(leaseAsJson(released_lease)->str(), lease_as_json->str());
}
auto deleted_leases_json = arguments->get("deleted-leases");
ASSERT_TRUE(deleted_leases_json);
ASSERT_EQ(Element::list, deleted_leases_json->getType());
- ASSERT_EQ(1, deleted_leases_json->size());
+ ASSERT_EQ(1U, deleted_leases_json->size());
auto lease_as_json = deleted_leases_json->get(0);
EXPECT_EQ(leaseAsJson(createLease6())->str(), lease_as_json->str());
auto leases_json = arguments->get("leases");
ASSERT_TRUE(leases_json);
ASSERT_EQ(Element::list, leases_json->getType());
- ASSERT_EQ(1, leases_json->size());
+ ASSERT_EQ(1U, leases_json->size());
lease_as_json = leases_json->get(0);
EXPECT_EQ(leaseAsJson(createLease6())->str(), lease_as_json->str());
// Make sure the backlog is now empty.
- EXPECT_EQ(0, backlog.size());
+ EXPECT_EQ(0U, backlog.size());
}
// This test verifies that the lease6-get-all command is correct.
// Get them back.
auto returned = state_.getPartnerScopes();
- EXPECT_EQ(2, returned.size());
- EXPECT_EQ(1, returned.count("server1"));
- EXPECT_EQ(1, returned.count("server2"));
+ EXPECT_EQ(2U, returned.size());
+ EXPECT_EQ(1U, returned.count("server1"));
+ EXPECT_EQ(1U, returned.count("server2"));
// Override the scopes.
ASSERT_NO_THROW(
state_.setPartnerScopes(Element::fromJSON("[ \"server1\" ]"))
);
returned = state_.getPartnerScopes();
- EXPECT_EQ(1, returned.size());
- EXPECT_EQ(1, returned.count("server1"));
+ EXPECT_EQ(1U, returned.size());
+ EXPECT_EQ(1U, returned.count("server1"));
// Clear the scopes.
ASSERT_NO_THROW(
CommunicationStateTest::detectFailureV4Test() {
// Initially, there should be no unacked clients recorded.
ASSERT_FALSE(state_.failureDetected());
- EXPECT_EQ(0, state_.getUnackedClientsCount());
- EXPECT_EQ(0, state_.getConnectingClientsCount());
- EXPECT_EQ(0, state_.getAnalyzedMessagesCount());
+ EXPECT_EQ(0U, state_.getUnackedClientsCount());
+ EXPECT_EQ(0U, state_.getConnectingClientsCount());
+ EXPECT_EQ(0U, state_.getAnalyzedMessagesCount());
// The maximum number of unacked clients is 10. Let's provide 10
// DHCPDISCOVER messages with the "secs" value of 15 which exceeds
<< "failure detected for the request number "
<< static_cast<int>(i);
}
- EXPECT_EQ(10, state_.getUnackedClientsCount());
- EXPECT_EQ(10, state_.getConnectingClientsCount());
- EXPECT_EQ(10, state_.getAnalyzedMessagesCount());
+ EXPECT_EQ(10U, state_.getUnackedClientsCount());
+ EXPECT_EQ(10U, state_.getConnectingClientsCount());
+ EXPECT_EQ(10U, state_.getAnalyzedMessagesCount());
// Let's provide similar set of requests but this time the "secs" field is
// below the threshold. They should not be counted as failures. Also,
<< "failure detected for the request number "
<< static_cast<int>(i);
}
- EXPECT_EQ(10, state_.getUnackedClientsCount());
- EXPECT_EQ(15, state_.getConnectingClientsCount());
- EXPECT_EQ(20, state_.getAnalyzedMessagesCount());
+ EXPECT_EQ(10U, state_.getUnackedClientsCount());
+ EXPECT_EQ(15U, state_.getConnectingClientsCount());
+ EXPECT_EQ(20U, state_.getAnalyzedMessagesCount());
// Let's create a message from a new (not recorded yet) client with the
// "secs" field value below the threshold. It should not be counted as failure.
// Still no failure.
ASSERT_FALSE(state_.failureDetected());
- EXPECT_EQ(10, state_.getUnackedClientsCount());
- EXPECT_EQ(16, state_.getConnectingClientsCount());
- EXPECT_EQ(21, state_.getAnalyzedMessagesCount());
+ EXPECT_EQ(10U, state_.getUnackedClientsCount());
+ EXPECT_EQ(16U, state_.getConnectingClientsCount());
+ EXPECT_EQ(21U, state_.getAnalyzedMessagesCount());
// Let's repeat one of the requests which already have been recorded as
// unacked but with a greater value of "secs" field. This should not
// be counted because only new clients count.
ASSERT_NO_THROW(state_.analyzeMessage(createMessage4(DHCPDISCOVER, 3, 3, 20)));
ASSERT_FALSE(state_.failureDetected());
- EXPECT_EQ(10, state_.getUnackedClientsCount());
- EXPECT_EQ(16, state_.getConnectingClientsCount());
- EXPECT_EQ(22, state_.getAnalyzedMessagesCount());
+ EXPECT_EQ(10U, state_.getUnackedClientsCount());
+ EXPECT_EQ(16U, state_.getConnectingClientsCount());
+ EXPECT_EQ(22U, state_.getAnalyzedMessagesCount());
// This time let's simulate a client with a MAC address already recorded but
// with a client identifier. This should be counted as a new unacked request.
ASSERT_NO_THROW(state_.analyzeMessage(createMessage4(DHCPDISCOVER, 7, 7, 15)));
ASSERT_TRUE(state_.failureDetected());
- EXPECT_EQ(11, state_.getUnackedClientsCount());
- EXPECT_EQ(16, state_.getConnectingClientsCount());
- EXPECT_EQ(23, state_.getAnalyzedMessagesCount());
+ EXPECT_EQ(11U, state_.getUnackedClientsCount());
+ EXPECT_EQ(16U, state_.getConnectingClientsCount());
+ EXPECT_EQ(23U, state_.getAnalyzedMessagesCount());
// Poking should cause all counters to reset as it is an indication that the
// control connection has been re-established.
// We're back to no failure state.
EXPECT_FALSE(state_.failureDetected());
- EXPECT_EQ(0, state_.getUnackedClientsCount());
- EXPECT_EQ(0, state_.getConnectingClientsCount());
- EXPECT_EQ(0, state_.getAnalyzedMessagesCount());
+ EXPECT_EQ(0U, state_.getUnackedClientsCount());
+ EXPECT_EQ(0U, state_.getConnectingClientsCount());
+ EXPECT_EQ(0U, state_.getAnalyzedMessagesCount());
// Send 11 DHCPDISCOVER messages with the "secs" field bytes swapped. Swapping
// bytes was reported for some misbehaving Windows clients. The server should
<< static_cast<int>(i)
<< " when testing swapped secs field bytes";
}
- EXPECT_EQ(0, state_.getUnackedClientsCount());
- EXPECT_EQ(11, state_.getConnectingClientsCount());
- EXPECT_EQ(11, state_.getAnalyzedMessagesCount());
+ EXPECT_EQ(0U, state_.getUnackedClientsCount());
+ EXPECT_EQ(11U, state_.getConnectingClientsCount());
+ EXPECT_EQ(11U, state_.getAnalyzedMessagesCount());
// Repeat the same test, but this time either the first byte exceeds the
// secs threshold or the second byte is non-zero. All should be counted
ASSERT_NO_THROW(state_.analyzeMessage(createMessage4(DHCPDISCOVER, 11, 11,
0x30)));
EXPECT_TRUE(state_.failureDetected());
- EXPECT_EQ(11, state_.getUnackedClientsCount());
- EXPECT_EQ(12, state_.getConnectingClientsCount());
- EXPECT_EQ(22, state_.getAnalyzedMessagesCount());
+ EXPECT_EQ(11U, state_.getUnackedClientsCount());
+ EXPECT_EQ(12U, state_.getConnectingClientsCount());
+ EXPECT_EQ(22U, state_.getAnalyzedMessagesCount());
}
// This test verifies that it is possible to disable analysis of the DHCPv4
CommunicationStateTest::detectFailureV6Test() {
// Initially, there should be no unacked clients recorded.
ASSERT_FALSE(state6_.failureDetected());
- EXPECT_EQ(0, state6_.getUnackedClientsCount());
- EXPECT_EQ(0, state6_.getConnectingClientsCount());
- EXPECT_EQ(0, state6_.getAnalyzedMessagesCount());
+ EXPECT_EQ(0U, state6_.getUnackedClientsCount());
+ EXPECT_EQ(0U, state6_.getConnectingClientsCount());
+ EXPECT_EQ(0U, state6_.getAnalyzedMessagesCount());
// The maximum number of unacked clients is 10. Let's provide 10
// Solicit messages with the "elapsed time" value of 1500 which exceeds
<< "failure detected for the request number "
<< static_cast<int>(i);
}
- EXPECT_EQ(10, state6_.getUnackedClientsCount());
- EXPECT_EQ(10, state6_.getConnectingClientsCount());
- EXPECT_EQ(10, state6_.getAnalyzedMessagesCount());
+ EXPECT_EQ(10U, state6_.getUnackedClientsCount());
+ EXPECT_EQ(10U, state6_.getConnectingClientsCount());
+ EXPECT_EQ(10U, state6_.getAnalyzedMessagesCount());
// Let's provide similar set of requests but this time the "elapsed time" is
// below the threshold. This should not reduce the number of unacked or new
<< "failure detected for the request number "
<< static_cast<int>(i);
}
- EXPECT_EQ(10, state6_.getUnackedClientsCount());
- EXPECT_EQ(10, state6_.getConnectingClientsCount());
- EXPECT_EQ(20, state6_.getAnalyzedMessagesCount());
+ EXPECT_EQ(10U, state6_.getUnackedClientsCount());
+ EXPECT_EQ(10U, state6_.getConnectingClientsCount());
+ EXPECT_EQ(20U, state6_.getAnalyzedMessagesCount());
// Let's create a message from a new (not recorded yet) client with the
// "elapsed time" value below the threshold. It should not count as failure.
// Still no failure.
ASSERT_FALSE(state6_.failureDetected());
- EXPECT_EQ(10, state6_.getUnackedClientsCount());
- EXPECT_EQ(11, state6_.getConnectingClientsCount());
- EXPECT_EQ(21, state6_.getAnalyzedMessagesCount());
+ EXPECT_EQ(10U, state6_.getUnackedClientsCount());
+ EXPECT_EQ(11U, state6_.getConnectingClientsCount());
+ EXPECT_EQ(21U, state6_.getAnalyzedMessagesCount());
// Let's repeat one of the requests which already have been recorded as
// unacked but with a greater value of "elapsed time". This should not
// be counted because only new clients count.
ASSERT_NO_THROW(state6_.analyzeMessage(createMessage6(DHCPV6_SOLICIT, 3, 2000)));
ASSERT_FALSE(state6_.failureDetected());
- EXPECT_EQ(10, state6_.getUnackedClientsCount());
- EXPECT_EQ(11, state6_.getConnectingClientsCount());
- EXPECT_EQ(22, state6_.getAnalyzedMessagesCount());
+ EXPECT_EQ(10U, state6_.getUnackedClientsCount());
+ EXPECT_EQ(11U, state6_.getConnectingClientsCount());
+ EXPECT_EQ(22U, state6_.getAnalyzedMessagesCount());
// New unacked client should cause failure to be detected.
ASSERT_NO_THROW(state6_.analyzeMessage(createMessage6(DHCPV6_SOLICIT, 11, 1500)));
ASSERT_TRUE(state6_.failureDetected());
- EXPECT_EQ(11, state6_.getUnackedClientsCount());
- EXPECT_EQ(12, state6_.getConnectingClientsCount());
- EXPECT_EQ(23, state6_.getAnalyzedMessagesCount());
+ EXPECT_EQ(11U, state6_.getUnackedClientsCount());
+ EXPECT_EQ(12U, state6_.getConnectingClientsCount());
+ EXPECT_EQ(23U, state6_.getAnalyzedMessagesCount());
// Poking should cause all counters to reset as it is an indication that the
// control connection has been re-established.
// We're back to no failure state.
EXPECT_FALSE(state6_.failureDetected());
- EXPECT_EQ(0, state6_.getUnackedClientsCount());
- EXPECT_EQ(0, state6_.getConnectingClientsCount());
- EXPECT_EQ(0, state6_.getAnalyzedMessagesCount());
+ EXPECT_EQ(0U, state6_.getUnackedClientsCount());
+ EXPECT_EQ(0U, state6_.getConnectingClientsCount());
+ EXPECT_EQ(0U, state6_.getAnalyzedMessagesCount());
}
// This test verifies that it is possible to disable analysis of the DHCPv6
void
CommunicationStateTest::getUnsentUpdateCountTest() {
// Initially the count should be 0.
- EXPECT_EQ(0, state_.getUnsentUpdateCount());
+ EXPECT_EQ(0U, state_.getUnsentUpdateCount());
// Increasing the value by 1 several times.
EXPECT_NO_THROW(state_.increaseUnsentUpdateCount());
- EXPECT_EQ(1, state_.getUnsentUpdateCount());
+ EXPECT_EQ(1U, state_.getUnsentUpdateCount());
EXPECT_NO_THROW(state_.increaseUnsentUpdateCount());
- EXPECT_EQ(2, state_.getUnsentUpdateCount());
+ EXPECT_EQ(2U, state_.getUnsentUpdateCount());
EXPECT_NO_THROW(state_.increaseUnsentUpdateCount());
- EXPECT_EQ(3, state_.getUnsentUpdateCount());
+ EXPECT_EQ(3U, state_.getUnsentUpdateCount());
// Test that the method under test protects against an overflow
// resetting the value to 0.
state_.unsent_update_count_ = std::numeric_limits<uint64_t>::max();
EXPECT_NO_THROW(state_.increaseUnsentUpdateCount());
- EXPECT_EQ(1, state_.getUnsentUpdateCount());
+ EXPECT_EQ(1U, state_.getUnsentUpdateCount());
}
void
void
CommunicationStateTest::reportRejectedLeasesV4Test() {
// Initially, there should be no rejected leases.
- EXPECT_EQ(0, state_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(0U, state_.getRejectedLeaseUpdatesCount());
// Reject lease update.
auto msg = createMessage4(DHCPREQUEST, 1, 0, 0);
state_.reportRejectedLeaseUpdate(msg);
- EXPECT_EQ(1, state_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(1U, state_.getRejectedLeaseUpdatesCount());
// Reject another lease update.
msg = createMessage4(DHCPREQUEST, 2, 0, 0);
state_.reportRejectedLeaseUpdate(msg);
- EXPECT_EQ(2, state_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(2U, state_.getRejectedLeaseUpdatesCount());
// Reject a lease with a short (zero) lease lifetime.
// This lease should be discarded when we call the
// getRejectedLeaseUpdatesCount().
msg = createMessage4(DHCPREQUEST, 3, 0, 0);
state_.reportRejectedLeaseUpdate(msg, 0);
- EXPECT_EQ(2, state_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(2U, state_.getRejectedLeaseUpdatesCount());
// Reject lease update for a client using the same MAC
// address but different client identifier. It should
// be treated as a different lease.
msg = createMessage4(DHCPREQUEST, 2, 1, 0);
state_.reportRejectedLeaseUpdate(msg);
- EXPECT_EQ(3, state_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(3U, state_.getRejectedLeaseUpdatesCount());
// Clear rejected leases and make sure the counter
// is now 0.
state_.clearRejectedLeaseUpdates();
- EXPECT_EQ(0, state_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(0U, state_.getRejectedLeaseUpdatesCount());
}
void
CommunicationStateTest::reportSuccessfulLeasesV4Test() {
// Initially, there should be no rejected leases.
- EXPECT_EQ(0, state_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(0U, state_.getRejectedLeaseUpdatesCount());
auto msg0 = createMessage4(DHCPREQUEST, 1, 0, 0);
// Reject lease update.
state_.reportRejectedLeaseUpdate(msg0);
- EXPECT_EQ(1, state_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(1U, state_.getRejectedLeaseUpdatesCount());
// Reject another lease update.
auto msg1 = createMessage4(DHCPREQUEST, 2, 0, 0);
state_.reportRejectedLeaseUpdate(msg1);
- EXPECT_EQ(2, state_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(2U, state_.getRejectedLeaseUpdatesCount());
// Report successful lease for the first message.
// It should reduce the number of rejected lease
// updates.
EXPECT_TRUE(state_.reportSuccessfulLeaseUpdate(msg0));
- EXPECT_EQ(1, state_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(1U, state_.getRejectedLeaseUpdatesCount());
// Report successful lease update for another message.
auto msg2 = createMessage4(DHCPREQUEST, 1, 1, 0);
EXPECT_FALSE(state_.reportSuccessfulLeaseUpdate(msg2));
- EXPECT_EQ(1, state_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(1U, state_.getRejectedLeaseUpdatesCount());
// There should be no rejected lease updates.
EXPECT_TRUE(state_.reportSuccessfulLeaseUpdate(msg1));
- EXPECT_EQ(0, state_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(0U, state_.getRejectedLeaseUpdatesCount());
}
void
void
CommunicationStateTest::reportRejectedLeasesV6Test() {
// Initially, there should be no rejected leases.
- EXPECT_EQ(0, state6_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(0U, state6_.getRejectedLeaseUpdatesCount());
// Reject lease update.
auto msg = createMessage6(DHCPV6_REQUEST, 1, 0);
state6_.reportRejectedLeaseUpdate(msg);
- EXPECT_EQ(1, state6_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(1U, state6_.getRejectedLeaseUpdatesCount());
// Reject another lease update.
msg = createMessage6(DHCPV6_REQUEST, 2, 0);
state6_.reportRejectedLeaseUpdate(msg);
- EXPECT_EQ(2, state6_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(2U, state6_.getRejectedLeaseUpdatesCount());
// Reject a lease with a short (zero) lease lifetime.
// This lease should be discarded when we call the
// getRejectedLeaseUpdatesCount().
msg = createMessage6(DHCPV6_REQUEST, 3, 0);
state6_.reportRejectedLeaseUpdate(msg, 0);
- EXPECT_EQ(2, state6_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(2U, state6_.getRejectedLeaseUpdatesCount());
// Reject it again. It should not affect the counter.
msg = createMessage6(DHCPV6_REQUEST, 2, 0);
state6_.reportRejectedLeaseUpdate(msg);
- EXPECT_EQ(2, state6_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(2U, state6_.getRejectedLeaseUpdatesCount());
// Clear rejected lease updates and make sure they
// are now 0.
state6_.clearRejectedLeaseUpdates();
- EXPECT_EQ(0, state6_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(0U, state6_.getRejectedLeaseUpdatesCount());
}
void
CommunicationStateTest::reportSuccessfulLeasesV6Test() {
// Initially, there should be no rejected leases.
- EXPECT_EQ(0, state6_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(0U, state6_.getRejectedLeaseUpdatesCount());
// Reject lease update.
auto msg0 = createMessage6(DHCPV6_SOLICIT, 1, 0);
EXPECT_TRUE(state6_.reportRejectedLeaseUpdate(msg0));
- EXPECT_EQ(1, state6_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(1U, state6_.getRejectedLeaseUpdatesCount());
// Reject another lease update.
auto msg1 = createMessage6(DHCPV6_SOLICIT, 2, 0);
EXPECT_TRUE(state6_.reportRejectedLeaseUpdate(msg1));
- EXPECT_EQ(2, state6_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(2U, state6_.getRejectedLeaseUpdatesCount());
// Report successful lease for the first message.
// It should reduce the number of rejected lease
// updates.
EXPECT_TRUE(state6_.reportSuccessfulLeaseUpdate(msg0));
- EXPECT_EQ(1, state6_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(1U, state6_.getRejectedLeaseUpdatesCount());
// Report successful lease update for a lease that wasn't
// rejected. It should not affect the counter.
auto msg2 = createMessage6(DHCPV6_SOLICIT, 3, 0);
EXPECT_FALSE(state6_.reportSuccessfulLeaseUpdate(msg2));
- EXPECT_EQ(1, state6_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(1U, state6_.getRejectedLeaseUpdatesCount());
// Report successful lease update for the last lease.
// The counter should now be 0.
EXPECT_TRUE(state6_.reportSuccessfulLeaseUpdate(msg1));
- EXPECT_EQ(0, state6_.getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(0U, state6_.getRejectedLeaseUpdatesCount());
}
void
// Get the count of valid entries. It should remove the expiring
// entries.
auto valid_entries_count = state_.getRejectedLeaseUpdatesCountFromContainer(entries);
- EXPECT_EQ(500, valid_entries_count);
- EXPECT_EQ(500, entries.size());
+ EXPECT_EQ(500U, valid_entries_count);
+ EXPECT_EQ(500U, entries.size());
// Validate that we removed expired entries, not the valid ones.
for (auto const& entry : entries) {
EXPECT_EQ(HAConfig::LOAD_BALANCING, impl->getConfig()->getHAMode());
EXPECT_FALSE(impl->getConfig()->amSendingLeaseUpdates());
EXPECT_FALSE(impl->getConfig()->amSyncingLeases());
- EXPECT_EQ(20000, impl->getConfig()->getSyncTimeout());
- EXPECT_EQ(3, impl->getConfig()->getSyncPageLimit());
- EXPECT_EQ(111, impl->getConfig()->getDelayedUpdatesLimit());
+ EXPECT_EQ(20000U, impl->getConfig()->getSyncTimeout());
+ EXPECT_EQ(3U, impl->getConfig()->getSyncPageLimit());
+ EXPECT_EQ(111U, impl->getConfig()->getDelayedUpdatesLimit());
EXPECT_TRUE(impl->getConfig()->amAllowingCommRecovery());
- EXPECT_EQ(8, impl->getConfig()->getHeartbeatDelay());
- EXPECT_EQ(11, impl->getConfig()->getMaxResponseDelay());
- EXPECT_EQ(5, impl->getConfig()->getMaxAckDelay());
- EXPECT_EQ(20, impl->getConfig()->getMaxUnackedClients());
- EXPECT_EQ(9, impl->getConfig()->getMaxRejectedLeaseUpdates());
+ EXPECT_EQ(8U, impl->getConfig()->getHeartbeatDelay());
+ EXPECT_EQ(11U, impl->getConfig()->getMaxResponseDelay());
+ EXPECT_EQ(5U, impl->getConfig()->getMaxAckDelay());
+ EXPECT_EQ(20U, impl->getConfig()->getMaxUnackedClients());
+ EXPECT_EQ(9U, impl->getConfig()->getMaxRejectedLeaseUpdates());
EXPECT_FALSE(impl->getConfig()->amWaitingBackupAck());
HAConfig::PeerConfigPtr cfg = impl->getConfig()->getThisServerConfig();
EXPECT_EQ(HAConfig::HOT_STANDBY, impl->getConfig()->getHAMode());
EXPECT_TRUE(impl->getConfig()->amSendingLeaseUpdates());
EXPECT_TRUE(impl->getConfig()->amSyncingLeases());
- EXPECT_EQ(60000, impl->getConfig()->getSyncTimeout());
- EXPECT_EQ(10000, impl->getConfig()->getSyncPageLimit());
- EXPECT_EQ(0, impl->getConfig()->getDelayedUpdatesLimit());
+ EXPECT_EQ(60000U, impl->getConfig()->getSyncTimeout());
+ EXPECT_EQ(10000U, impl->getConfig()->getSyncPageLimit());
+ EXPECT_EQ(0U, impl->getConfig()->getDelayedUpdatesLimit());
EXPECT_FALSE(impl->getConfig()->amAllowingCommRecovery());
- EXPECT_EQ(10000, impl->getConfig()->getHeartbeatDelay());
- EXPECT_EQ(10000, impl->getConfig()->getMaxAckDelay());
- EXPECT_EQ(10, impl->getConfig()->getMaxUnackedClients());
- EXPECT_EQ(10, impl->getConfig()->getMaxRejectedLeaseUpdates());
+ EXPECT_EQ(10000U, impl->getConfig()->getHeartbeatDelay());
+ EXPECT_EQ(10000U, impl->getConfig()->getMaxAckDelay());
+ EXPECT_EQ(10U, impl->getConfig()->getMaxUnackedClients());
+ EXPECT_EQ(10U, impl->getConfig()->getMaxRejectedLeaseUpdates());
EXPECT_FALSE(impl->getConfig()->amWaitingBackupAck());
HAConfig::PeerConfigPtr cfg = impl->getConfig()->getThisServerConfig();
EXPECT_TRUE(query4->getClasses().empty());
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt4-receive-drop"));
// Turn this into the DHCP message by appending a magic cookie and the
// options.
// The client class should be assigned to the message to indicate that the
// server1 should process this message.
- ASSERT_EQ(1, query4->getClasses().size());
+ ASSERT_EQ(1U, query4->getClasses().size());
EXPECT_TRUE(query4->inClass("HA_server1"));
// Check that the message has been parsed. The DHCP message type should
EXPECT_TRUE(query4->getOption(DHO_DOMAIN_NAME));
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt4-parse-failed"));
- EXPECT_EQ(1, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt4-parse-failed"));
+ EXPECT_EQ(1U, getStatistic("pkt4-receive-drop"));
}
// Tests subnet4_select callout implementation when the server name
// The client class should be assigned to the query indicating the relationship
// to which the query belongs.
- ASSERT_EQ(1, query4->getClasses().size());
+ ASSERT_EQ(1U, query4->getClasses().size());
EXPECT_TRUE(query4->inClass("HA_server3"));
// Drop statistics should not increase.
- EXPECT_EQ(0, getStatistic("pkt4-not-for-use"));
- EXPECT_EQ(0, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(0U, getStatistic("pkt4-not-for-use"));
+ EXPECT_EQ(0U, getStatistic("pkt4-receive-drop"));
}
// Tests subnet4_select callout implementation when the server name
// The client class should be assigned to the query indicating the relationship
// to which the query belongs.
- ASSERT_EQ(1, query4->getClasses().size());
+ ASSERT_EQ(1U, query4->getClasses().size());
EXPECT_TRUE(query4->inClass("HA_server3"));
// Drop statistics should not increase.
- EXPECT_EQ(0, getStatistic("pkt4-not-for-us"));
- EXPECT_EQ(0, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(0U, getStatistic("pkt4-not-for-us"));
+ EXPECT_EQ(0U, getStatistic("pkt4-receive-drop"));
}
// Tests that subnet4_select callout returns when there is a single relationship.
EXPECT_TRUE(query4->getClasses().empty());
// Drop statistics should not increase.
- EXPECT_EQ(0, getStatistic("pkt4-not-for-us"));
- EXPECT_EQ(0, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(0U, getStatistic("pkt4-not-for-us"));
+ EXPECT_EQ(0U, getStatistic("pkt4-receive-drop"));
}
// Tests that the subnet4_select drops the packet when server name is not
EXPECT_TRUE(query4->getClasses().empty());
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt4-not-for-us"));
- EXPECT_EQ(1, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt4-not-for-us"));
+ EXPECT_EQ(1U, getStatistic("pkt4-receive-drop"));
}
// Tests that the subnet4_select drops the packet when server name has
EXPECT_TRUE(query4->getClasses().empty());
// Drop statistics should have been increased.
- EXPECT_EQ(0, getStatistic("pkt4-not-for-us"));
- EXPECT_EQ(1, getStatistic("pkt4-processing-failed"));
- EXPECT_EQ(1, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(0U, getStatistic("pkt4-not-for-us"));
+ EXPECT_EQ(1U, getStatistic("pkt4-processing-failed"));
+ EXPECT_EQ(1U, getStatistic("pkt4-receive-drop"));
}
// Tests that the subnet4_select drops the packet when server name is valid
EXPECT_EQ(CalloutHandle::NEXT_STEP_DROP, callout_handle->getStatus());
// However, the class should be assigned after calling HAService::inScope.
- ASSERT_EQ(1, query4->getClasses().size());
+ ASSERT_EQ(1U, query4->getClasses().size());
EXPECT_TRUE(query4->inClass("HA_server3"));
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt4-not-for-us"));
- EXPECT_EQ(1, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt4-not-for-us"));
+ EXPECT_EQ(1U, getStatistic("pkt4-receive-drop"));
}
// Tests that the subnet4_select drops a packet when no subnet has been selected.
EXPECT_TRUE(query4->getClasses().empty());
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt4-not-for-us"));
- EXPECT_EQ(1, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt4-not-for-us"));
+ EXPECT_EQ(1U, getStatistic("pkt4-receive-drop"));
}
// Tests for buffer6_receive callout implementation.
EXPECT_TRUE(query6->getClasses().empty());
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt6-receive-drop"));
// Append transaction id (3 bytes, each set to 1).
msg.insert(msg.end(), 3, 1);
// The client class should be assigned to the message to indicate that the
// server1 should process this message.
- ASSERT_EQ(1, query6->getClasses().size());
+ ASSERT_EQ(1U, query6->getClasses().size());
EXPECT_TRUE(query6->inClass("HA_server1"));
// Check that the message has been parsed. The DHCP message type should
EXPECT_FALSE(query6->getOption(D6O_NIS_DOMAIN_NAME));
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt6-parse-failed"));
- EXPECT_EQ(1, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt6-parse-failed"));
+ EXPECT_EQ(1U, getStatistic("pkt6-receive-drop"));
}
// Tests subnet6_select callout implementation when the server name
// The client class should be assigned to the query indicating the relationship
// to which the query belongs.
- ASSERT_EQ(1, query6->getClasses().size());
+ ASSERT_EQ(1U, query6->getClasses().size());
EXPECT_TRUE(query6->inClass("HA_server3"));
// Drop statistics should not increase.
- EXPECT_EQ(0, getStatistic("pkt6-not-for-use"));
- EXPECT_EQ(0, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(0U, getStatistic("pkt6-not-for-use"));
+ EXPECT_EQ(0U, getStatistic("pkt6-receive-drop"));
}
// Tests subnet6_select callout implementation when the server name
// The client class should be assigned to the query indicating the relationship
// to which the query belongs.
- ASSERT_EQ(1, query6->getClasses().size());
+ ASSERT_EQ(1U, query6->getClasses().size());
EXPECT_TRUE(query6->inClass("HA_server3"));
// Drop statistics should not increase.
- EXPECT_EQ(0, getStatistic("pkt6-not-for-us"));
- EXPECT_EQ(0, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(0U, getStatistic("pkt6-not-for-us"));
+ EXPECT_EQ(0U, getStatistic("pkt6-receive-drop"));
}
// Tests that subnet6_select callout returns when there is a single relationship.
EXPECT_TRUE(query6->getClasses().empty());
// Drop statistics should not increase.
- EXPECT_EQ(0, getStatistic("pkt6-not-for-us"));
- EXPECT_EQ(0, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(0U, getStatistic("pkt6-not-for-us"));
+ EXPECT_EQ(0U, getStatistic("pkt6-receive-drop"));
}
// Tests that the subnet6_select drops the packet when server name is not
EXPECT_TRUE(query6->getClasses().empty());
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt6-not-for-us"));
- EXPECT_EQ(1, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt6-not-for-us"));
+ EXPECT_EQ(1U, getStatistic("pkt6-receive-drop"));
}
// Tests that the subnet6_select drops the packet when server name has
EXPECT_TRUE(query6->getClasses().empty());
// Drop statistics should have been increased.
- EXPECT_EQ(0, getStatistic("pkt6-not-for-us"));
- EXPECT_EQ(1, getStatistic("pkt6-processing-failed"));
- EXPECT_EQ(1, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(0U, getStatistic("pkt6-not-for-us"));
+ EXPECT_EQ(1U, getStatistic("pkt6-processing-failed"));
+ EXPECT_EQ(1U, getStatistic("pkt6-receive-drop"));
}
// Tests that the subnet6_select drops the packet when server name is valid
EXPECT_EQ(CalloutHandle::NEXT_STEP_DROP, callout_handle->getStatus());
// However, the class should be assigned after calling HAService::inScope.
- ASSERT_EQ(1, query6->getClasses().size());
+ ASSERT_EQ(1U, query6->getClasses().size());
EXPECT_TRUE(query6->inClass("HA_server3"));
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt6-not-for-us"));
- EXPECT_EQ(1, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt6-not-for-us"));
+ EXPECT_EQ(1U, getStatistic("pkt6-receive-drop"));
}
// Tests that the subnet6_select drops a packet when no subnet has been selected.
EXPECT_TRUE(query6->getClasses().empty());
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt6-not-for-us"));
- EXPECT_EQ(1, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt6-not-for-us"));
+ EXPECT_EQ(1U, getStatistic("pkt6-receive-drop"));
}
// Tests leases4_committed callout implementation.
EXPECT_TRUE(callout_handle->getParkingLotHandlePtr()->drop(query4));
// Drop statistics should not increase.
- EXPECT_EQ(0, getStatistic("pkt4-not-for-us"));
- EXPECT_EQ(0, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(0U, getStatistic("pkt4-not-for-us"));
+ EXPECT_EQ(0U, getStatistic("pkt4-receive-drop"));
}
// Tests leases4_committed callout implementation for multiple relationships.
EXPECT_TRUE(callout_handle->getParkingLotHandlePtr()->drop(query4));
// Drop statistics should not increase.
- EXPECT_EQ(0, getStatistic("pkt4-not-for-us"));
- EXPECT_EQ(0, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(0U, getStatistic("pkt4-not-for-us"));
+ EXPECT_EQ(0U, getStatistic("pkt4-receive-drop"));
}
// Tests leases4_committed callout implementation for multiple relationships when
EXPECT_TRUE(callout_handle->getParkingLotHandlePtr()->drop(query4));
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt4-not-for-us"));
- EXPECT_EQ(1, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt4-not-for-us"));
+ EXPECT_EQ(1U, getStatistic("pkt4-receive-drop"));
}
// Tests leases4_committed callout implementation for multiple relationships when
EXPECT_TRUE(callout_handle->getParkingLotHandlePtr()->drop(query4));
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt4-not-for-us"));
- EXPECT_EQ(1, getStatistic("pkt4-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt4-not-for-us"));
+ EXPECT_EQ(1U, getStatistic("pkt4-receive-drop"));
}
// Tests leases6_committed callout implementation.
EXPECT_TRUE(callout_handle->getParkingLotHandlePtr()->drop(query6));
// Drop statistics should not increase.
- EXPECT_EQ(0, getStatistic("pkt6-not-for-us"));
- EXPECT_EQ(0, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(0U, getStatistic("pkt6-not-for-us"));
+ EXPECT_EQ(0U, getStatistic("pkt6-receive-drop"));
}
// Tests leases6_committed callout implementation for multiple relationships.
EXPECT_TRUE(callout_handle->getParkingLotHandlePtr()->drop(query6));
// Drop statistics should not increase.
- EXPECT_EQ(0, getStatistic("pkt6-not-for-us"));
- EXPECT_EQ(0, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(0U, getStatistic("pkt6-not-for-us"));
+ EXPECT_EQ(0U, getStatistic("pkt6-receive-drop"));
}
// Tests leases6_committed callout implementation for multiple relationships when
EXPECT_TRUE(callout_handle->getParkingLotHandlePtr()->drop(query6));
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt6-not-for-us"));
- EXPECT_EQ(1, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt6-not-for-us"));
+ EXPECT_EQ(1U, getStatistic("pkt6-receive-drop"));
}
// Tests leases6_committed callout implementation for multiple relationships when
EXPECT_TRUE(callout_handle->getParkingLotHandlePtr()->drop(query6));
// Drop statistics should have been increased.
- EXPECT_EQ(1, getStatistic("pkt6-not-for-us"));
- EXPECT_EQ(1, getStatistic("pkt6-receive-drop"));
+ EXPECT_EQ(1U, getStatistic("pkt6-not-for-us"));
+ EXPECT_EQ(1U, getStatistic("pkt6-receive-drop"));
}
// Tests lease4_expire callout implementation when the server is a hub
size_t peers_to_update;
ASSERT_NO_THROW_LOG(callout_handle->getArgument("peers_to_update", peers_to_update));
- EXPECT_EQ(peers_to_update, 0);
+ EXPECT_EQ(peers_to_update, 0U);
// Enable updates and retry.
test_ha_impl_->config_->get()->setSendLeaseUpdates(true);
EXPECT_EQ(CalloutHandle::NEXT_STEP_CONTINUE, callout_handle->getStatus());
ASSERT_NO_THROW_LOG(callout_handle->getArgument("peers_to_update", peers_to_update));
- EXPECT_EQ(peers_to_update, 1);
+ EXPECT_EQ(peers_to_update, 1U);
}
}
EXPECT_NO_THROW(mapper.map("server4", rel2));
auto const& all = mapper.getAll();
- EXPECT_EQ(2, all.size());
+ EXPECT_EQ(2U, all.size());
EXPECT_EQ(rel1, all[0]);
EXPECT_EQ(rel2, all[1]);
}
// contacted servers because we send one lease update and one
// lease deletion to each contacted server from which we expect
// an acknowledgment.
- EXPECT_EQ(2 * num_updates, service_->getPendingRequest(query));
+ EXPECT_EQ(static_cast<int>(2 * num_updates),
+ service_->getPendingRequest(query));
// Let's park the packet and associate it with the callback function which
// simply records the fact that it has been called. We expect that it wasn't
// The number of requests we send is equal to the number of servers
// from which we expect an acknowledgement. We send both lease updates
// and the deletions in a single bulk update command.
- EXPECT_EQ(num_updates, service_->getPendingRequest(query));
+ EXPECT_EQ(static_cast<int>(num_updates), service_->getPendingRequest(query));
EXPECT_FALSE(boost::dynamic_pointer_cast<NakedCommunicationState6>
(service_->communication_state_)->isPoked());
EXPECT_TRUE(unpark_called);
// Updates have been sent so this counter should remain 0.
- EXPECT_EQ(0, service_->communication_state_->getUnsentUpdateCount());
+ EXPECT_EQ(0U, service_->communication_state_->getUnsentUpdateCount());
// The server 2 should have received two commands.
- EXPECT_EQ(2, factory2_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(2U, factory2_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 2 has received lease4-update command.
auto update_request2 =
EXPECT_TRUE(delete_request2);
// Lease updates should be successfully sent to server3.
- EXPECT_EQ(2, factory3_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(2U, factory3_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 3 has received lease4-update command.
auto update_request3 =
EXPECT_TRUE(unpark_called);
// Updates have been sent so this counter should remain 0.
- EXPECT_EQ(0, service_->communication_state_->getUnsentUpdateCount());
+ EXPECT_EQ(0U, service_->communication_state_->getUnsentUpdateCount());
// The server 2 should have received two commands.
- EXPECT_EQ(2, factory2_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(2U, factory2_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 2 has received lease4-update command.
auto update_request2 =
EXPECT_TRUE(soft_delete_request2);
// Lease updates should be successfully sent to server3.
- EXPECT_EQ(2, factory3_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(2U, factory3_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 3 has received lease4-update command.
auto update_request3 =
EXPECT_FALSE(unpark_called);
// Let's make sure they have been queued.
- EXPECT_EQ(2, service_->lease_update_backlog_.size());
+ EXPECT_EQ(2U, service_->lease_update_backlog_.size());
// Make partner available.
service_->communication_state_->poke();
"192.2.3.4"));
// Backlog should be empty.
- EXPECT_EQ(0, service_->lease_update_backlog_.size());
+ EXPECT_EQ(0U, service_->lease_update_backlog_.size());
}
/// @brief Tests sending outstanding lease updates in the communication-recovery
EXPECT_FALSE(unpark_called);
// Let's make sure they have been queued.
- EXPECT_EQ(2, service_->lease_update_backlog_.size());
+ EXPECT_EQ(2U, service_->lease_update_backlog_.size());
// Make partner available.
service_->communication_state_->poke();
"192.2.3.4"));
// Backlog should be empty.
- EXPECT_EQ(0, service_->lease_update_backlog_.size());
+ EXPECT_EQ(0U, service_->lease_update_backlog_.size());
}
/// @brief Test the cases when the trying to recover from the communication
EXPECT_FALSE(unpark_called);
// Let's make sure they have been queued.
- EXPECT_EQ(2, service_->lease_update_backlog_.size());
+ EXPECT_EQ(2U, service_->lease_update_backlog_.size());
// When testing the case when the backlog should be overflown, we need
// to add several more leases to the backlog to exceed the limit.
}
// The backlog should be empty.
- EXPECT_EQ(0, service_->lease_update_backlog_.size());
+ EXPECT_EQ(0U, service_->lease_update_backlog_.size());
}
/// @brief Tests scenarios when lease updates are not sent to the failover peer.
// This is later returned in the heartbeat so the partner can
// determine whether it should synchronize its lease database or
// not.
- EXPECT_EQ(1, service_->communication_state_->getUnsentUpdateCount());
+ EXPECT_EQ(1U, service_->communication_state_->getUnsentUpdateCount());
// Server 2 should not receive lease4-update.
auto update_request2 =
// The updates should be sent to server 2 and this server should
// return error code.
- EXPECT_EQ(2, factory2_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(2U, factory2_->getResponseCreator()->getReceivedRequests().size());
// Server 2 should receive lease4-update.
auto update_request2 =
EXPECT_TRUE(delete_request2);
// Lease updates should be successfully sent to server3.
- EXPECT_EQ(2, factory3_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(2U, factory3_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 3 has received lease4-update command.
auto update_request3 =
EXPECT_TRUE(factory2_->getResponseCreator()->getReceivedRequests().empty());
// Lease updates should be successfully sent to server3.
- EXPECT_EQ(2, factory3_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(2U, factory3_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 3 has received lease4-update command.
auto update_request3 =
EXPECT_TRUE(unpark_called);
// The server 2 should have received two commands.
- EXPECT_EQ(2, factory2_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(2U, factory2_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 2 has received lease4-update command.
auto update_request2 =
// Ensure that the server has recorded a lease update conflict. The conflict
// reported by the backup server should not count.
- EXPECT_EQ(1, service_->communication_state_->getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(1U, service_->communication_state_->getRejectedLeaseUpdatesCount());
// Change the partner's response to success.
factory2_->getResponseCreator()->setControlResult(CONTROL_RESULT_SUCCESS);
unpark_called = true;
}, false, 1, MyState(HA_LOAD_BALANCING_ST), true, false);
EXPECT_TRUE(unpark_called);
- EXPECT_EQ(0, service_->communication_state_->getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(0U, service_->communication_state_->getRejectedLeaseUpdatesCount());
}
/// @brief Tests scenarios when all lease updates are sent successfully.
EXPECT_TRUE(unpark_called);
// Updates have been sent so this counter should remain 0.
- EXPECT_EQ(0, service_->communication_state_->getUnsentUpdateCount());
+ EXPECT_EQ(0U, service_->communication_state_->getUnsentUpdateCount());
// The server 2 should have received one command.
- EXPECT_EQ(1, factory2_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(1U, factory2_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 2 has received lease6-bulk-apply command.
auto update_request2 =
EXPECT_TRUE(update_request2);
// Lease updates should be successfully sent to server3.
- EXPECT_EQ(1, factory3_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(1U, factory3_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 3 has received lease6-bulk-apply command.
auto update_request3 =
EXPECT_TRUE(unpark_called);
// Updates have been sent so this counter should remain 0.
- EXPECT_EQ(0, service_->communication_state_->getUnsentUpdateCount());
+ EXPECT_EQ(0U, service_->communication_state_->getUnsentUpdateCount());
// The server 2 should have received one command.
- EXPECT_EQ(1, factory2_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(1U, factory2_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 2 has received lease6-bulk-apply command.
auto update_request2 =
auto leases = arguments->get("leases");
ASSERT_TRUE(leases);
EXPECT_EQ(Element::list, leases->getType());
- EXPECT_EQ(2, leases->size());
+ EXPECT_EQ(2U, leases->size());
// Lease updates should be successfully sent to server3.
- EXPECT_EQ(1, factory3_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(1U, factory3_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 3 has received lease6-bulk-apply command.
auto update_request3 =
EXPECT_EQ(Element::map, arguments->getType());
leases = arguments->get("leases");
EXPECT_EQ(Element::list, leases->getType());
- EXPECT_EQ(2, leases->size());
+ EXPECT_EQ(2U, leases->size());
}
/// @brief Tests that DHCPv6 lease updates are queued when the server is in the
EXPECT_FALSE(unpark_called);
// Let's make sure they have been queued.
- EXPECT_EQ(2, service_->lease_update_backlog_.size());
+ EXPECT_EQ(2U, service_->lease_update_backlog_.size());
// Make partner available.
service_->communication_state_->poke();
auto leases = arguments->get("leases");
ASSERT_TRUE(leases);
EXPECT_EQ(Element::list, leases->getType());
- EXPECT_EQ(1, leases->size());
+ EXPECT_EQ(1U, leases->size());
auto deleted_leases = arguments->get("deleted-leases");
ASSERT_TRUE(deleted_leases);
EXPECT_EQ(Element::list, deleted_leases->getType());
- EXPECT_EQ(1, deleted_leases->size());
+ EXPECT_EQ(1U, deleted_leases->size());
// Backlog should be empty.
- EXPECT_EQ(0, service_->lease_update_backlog_.size());
+ EXPECT_EQ(0U, service_->lease_update_backlog_.size());
}
/// @brief Tests sending outstanding lease updates in the communication-recovery
EXPECT_FALSE(unpark_called);
// Let's make sure they have been queued.
- EXPECT_EQ(2, service_->lease_update_backlog_.size());
+ EXPECT_EQ(2U, service_->lease_update_backlog_.size());
// Make partner available.
service_->communication_state_->poke();
EXPECT_EQ(Element::map, arguments->getType());
auto leases = arguments->get("leases");
EXPECT_EQ(Element::list, leases->getType());
- EXPECT_EQ(2, leases->size());
+ EXPECT_EQ(2U, leases->size());
// Backlog should be empty.
- EXPECT_EQ(0, service_->lease_update_backlog_.size());
+ EXPECT_EQ(0U, service_->lease_update_backlog_.size());
}
/// @brief Test the cases when the trying to recover from the communication
EXPECT_FALSE(unpark_called);
// Let's make sure they have been queued.
- EXPECT_EQ(2, service_->lease_update_backlog_.size());
+ EXPECT_EQ(2U, service_->lease_update_backlog_.size());
// When testing the case when the backlog should be overflown, we need
// to add several more leases to the backlog to exceed the limit.
}
// Backlog should be empty.
- EXPECT_EQ(0, service_->lease_update_backlog_.size());
+ EXPECT_EQ(0U, service_->lease_update_backlog_.size());
}
/// @brief Tests scenarios when lease updates are not sent to the failover peer.
// This is later returned in the heartbeat so the partner can
// determine whether it should synchronize its lease database or
// not.
- EXPECT_EQ(1, service_->communication_state_->getUnsentUpdateCount());
+ EXPECT_EQ(1U, service_->communication_state_->getUnsentUpdateCount());
// Server 2 should not receive lease6-bulk-apply.
auto update_request2 =
EXPECT_TRUE(unpark_called);
// The server 2 should have received one command.
- EXPECT_EQ(1, factory2_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(1U, factory2_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 2 has received lease6-bulk-apply command.
auto update_request2 =
}, true, 1);
// The updates should be sent to server 2 and this server should return error code.
- EXPECT_EQ(1, factory2_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(1U, factory2_->getResponseCreator()->getReceivedRequests().size());
// Server 2 should receive lease6-bulk-apply.
auto update_request2 =
EXPECT_TRUE(unpark_called);
// The server 2 should have received one command.
- EXPECT_EQ(1, factory2_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(1U, factory2_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 2 has received lease6-bulk-apply command.
auto update_request2 =
// Ensure that the server has recorded the lease update conflict. The conflict
// reported by the backup server should not count.
- EXPECT_EQ(1, service_->communication_state_->getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(1U, service_->communication_state_->getRejectedLeaseUpdatesCount());
// Change the active server's response to success. The initially rejected
// lease update should no longer be tracked.
unpark_called = true;
}, false, 1, MyState(HA_LOAD_BALANCING_ST), true, false);
EXPECT_TRUE(unpark_called);
- EXPECT_EQ(0, service_->communication_state_->getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(0U, service_->communication_state_->getRejectedLeaseUpdatesCount());
}
/// @brief Test the scenario when the server receiving a lease update returns
// The conflict should not be recorded because the error status code
// takes precedence.
- EXPECT_EQ(0, service_->communication_state_->getRejectedLeaseUpdatesCount());
+ EXPECT_EQ(0U, service_->communication_state_->getRejectedLeaseUpdatesCount());
}
/// @brief Runs HAService::processSynchronize for the DHCPv4 server and
service_->asyncSendSingleLeaseUpdate(query, lease4, parking_lot_handle));
// Verify we have the right number of updates pending.
- EXPECT_EQ(num_updates, service_->getPendingRequest(query));
+ EXPECT_EQ(static_cast<int>(num_updates), service_->getPendingRequest(query));
if (parking_lot) {
// Let's park the packet and associate it with the callback function which
}
// Updates have been sent so this counter should remain 0.
- EXPECT_EQ(0, service_->communication_state_->getUnsentUpdateCount());
+ EXPECT_EQ(0U, service_->communication_state_->getUnsentUpdateCount());
// The server 2 should have received two commands.
- EXPECT_EQ(1, factory2_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(1U, factory2_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 2 has received lease4-update command.
auto update_request2 =
EXPECT_TRUE(update_request2);
// Lease update should be successfully sent to server3.
- EXPECT_EQ(1, factory3_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(1U, factory3_->getResponseCreator()->getReceivedRequests().size());
// Check that the server 3 has received lease4-update command.
auto update_request3 =
auto scopes_list = args->get("scopes");
ASSERT_TRUE(scopes_list);
EXPECT_EQ(Element::list, scopes_list->getType());
- ASSERT_EQ(1, scopes_list->size());
+ ASSERT_EQ(1U, scopes_list->size());
auto scope = scopes_list->get(0);
ASSERT_TRUE(scope);
EXPECT_EQ(Element::string, scope->getType());
ConstElementPtr unsent_update_count = args->get("unsent-update-count");
ASSERT_TRUE(unsent_update_count);
EXPECT_EQ(Element::integer, unsent_update_count->getType());
- EXPECT_EQ(unsent_updates, static_cast<uint64_t>(unsent_update_count->intValue()));
+ EXPECT_EQ(unsent_updates, unsent_update_count->intValue());
}
// This test verifies that the correct value of the heartbeat-delay is used.
ASSERT_NO_THROW(service.runModel(HAService::NOP_EVT));
ASSERT_TRUE(state->timer_);
- EXPECT_EQ(6000, state->timer_->getInterval());
+ EXPECT_EQ(6000U, state->timer_->getInterval());
}
// This test verifies that the heartbeat is periodically sent to the
ASSERT_NO_FATAL_FAILURE(testRecurringHeartbeat(CONTROL_RESULT_SUCCESS, true));
// Server 2 should have received the heartbeat
- EXPECT_GE(factory2_->getResponseCreator()->getReceivedRequests().size(), 0);
+ EXPECT_GE(factory2_->getResponseCreator()->getReceivedRequests().size(), 0U);
}
// This test verifies that the heartbeat is periodically sent to the
ASSERT_NO_FATAL_FAILURE(testRecurringHeartbeat(CONTROL_RESULT_SUCCESS, true));
// Server 2 should have received the heartbeat
- EXPECT_GE(factory2_->getResponseCreator()->getReceivedRequests().size(), 0);
+ EXPECT_GE(factory2_->getResponseCreator()->getReceivedRequests().size(), 0U);
}
// This test verifies that the heartbeat is considered being unsuccessful if the
ASSERT_NO_FATAL_FAILURE(testRecurringHeartbeat(CONTROL_RESULT_ERROR, false));
// Server 2 should have received the heartbeat.
- EXPECT_EQ(1, factory2_->getResponseCreator()->getReceivedRequests().size());
+ EXPECT_EQ(1U, factory2_->getResponseCreator()->getReceivedRequests().size());
}
// This test verifies that the heartbeat is considered being unsuccessful if
// was unsupported.
auto requests = factory2_->getResponseCreator()->getReceivedRequests();
- ASSERT_GE(requests.size(), 3);
+ ASSERT_GE(requests.size(), 3U);
// The dhcp-disable should be the first request.
auto request = factory2_->getResponseCreator()->findRequest("dhcp-disable","20");
auto requests = factory2_->getResponseCreator()->getReceivedRequests();
- ASSERT_GE(requests.size(), 3);
+ ASSERT_GE(requests.size(), 3U);
// The dhcp-disable should be the first request.
auto request = factory2_->getResponseCreator()->findRequest("dhcp-disable","20");
// In the backup state the DHCP service is disabled by default.
// It can only be enabled manually.
ASSERT_FALSE(service_->network_state_->isServiceEnabled());
- ASSERT_EQ(0, service_->query_filter_.getServedScopes().size());
+ ASSERT_EQ(0U, service_->query_filter_.getServedScopes().size());
}
}
}
// Make sure all lease updates have been added.
- EXPECT_EQ(3, backlog.size());
+ EXPECT_EQ(3U, backlog.size());
// Remove lease updates.
ASSERT_NO_THROW(backlog.clear());
// There should be no lease updates.
- EXPECT_EQ(0, backlog.size());
+ EXPECT_EQ(0U, backlog.size());
}
} // end of anonymous namespace
for (auto const& host : hosts) {
ASSERT_NO_THROW(hdsptr_->add(host));
}
- EXPECT_EQ(0, testptr()->hcptr_->hits_);
- EXPECT_EQ(0, testptr()->hcptr_->inserts_);
+ EXPECT_EQ(0U, testptr()->hcptr_->hits_);
+ EXPECT_EQ(0U, testptr()->hcptr_->inserts_);
// First pass filling the cache.
for (auto const& host : hosts) {
ASSERT_TRUE(entry);
HostDataSourceUtils::compareHosts(entry, host);
}
- EXPECT_EQ(0, testptr()->hcptr_->hits_);
- EXPECT_EQ(1000, testptr()->hcptr_->inserts_);
+ EXPECT_EQ(0U, testptr()->hcptr_->hits_);
+ EXPECT_EQ(1000U, testptr()->hcptr_->inserts_);
// Second pass checking the cache.
for (auto const& host : hosts) {
ASSERT_TRUE(entry);
HostDataSourceUtils::compareHosts(entry, host);
}
- EXPECT_EQ(1000, testptr()->hcptr_->size());
- EXPECT_EQ(1000, testptr()->hcptr_->hits_);
- EXPECT_EQ(1000, testptr()->hcptr_->inserts_);
+ EXPECT_EQ(1000U, testptr()->hcptr_->size());
+ EXPECT_EQ(1000U, testptr()->hcptr_->hits_);
+ EXPECT_EQ(1000U, testptr()->hcptr_->inserts_);
// Try a 100 entry cache.
testptr()->hcptr_->flush(testptr()->hcptr_->size() - 100);
- ASSERT_EQ(100, testptr()->hcptr_->size());
+ ASSERT_EQ(100U, testptr()->hcptr_->size());
testptr()->hcptr_->setMaximum(100);
size_t hits100 = testptr()->hcptr_->hits_;
size_t inserts100 = testptr()->hcptr_->inserts_;
size_t hits_delta = testptr()->hcptr_->hits_ - hits100;
size_t inserts_delta = testptr()->hcptr_->inserts_ - inserts100;
// 100 from and to cache.
- EXPECT_EQ(100, hits_delta + inserts_delta);
+ EXPECT_EQ(100U, hits_delta + inserts_delta);
cerr << "100 rounds with cache 100: " << hits_delta << endl;
// Prob(hits_delta < 2) ~= 3.10^-4
if (soft) {
status = false;
}
} else {
- EXPECT_LT(2, hits_delta);
+ EXPECT_LT(2U, hits_delta);
}
// Prob(hits_delta >= 22) ~= 3.10^-4
if (soft) {
status = false;
}
} else {
- EXPECT_GE(22, hits_delta);
+ EXPECT_GE(22U, hits_delta);
}
// Try a 10 entry cache.
testptr()->hcptr_->flush(testptr()->hcptr_->size() - 10);
testptr()->hcptr_->setMaximum(10);
- ASSERT_EQ(10, testptr()->hcptr_->size());
+ ASSERT_EQ(10U, testptr()->hcptr_->size());
size_t hits10 = testptr()->hcptr_->hits_;
size_t inserts10 = testptr()->hcptr_->inserts_;
// Go for 1000 rounds.
}
hits_delta = testptr()->hcptr_->hits_ - hits10;
inserts_delta = testptr()->hcptr_->inserts_ - inserts10;
- EXPECT_EQ(1000, hits_delta + inserts_delta);
+ EXPECT_EQ(1000U, hits_delta + inserts_delta);
cerr << "1000 rounds with cache 10: " << hits_delta << endl;
// Prob(hits_delta < 2) ~= 5.10-4
if (soft) {
status = false;
}
} else {
- EXPECT_LT(2, hits_delta);
+ EXPECT_LT(2U, hits_delta);
}
// Prob(hits_delta > 22) ~= 3.10-4
if (soft) {
status = false;
}
} else {
- EXPECT_GT(22, hits_delta);
+ EXPECT_GT(22U, hits_delta);
}
// Try a 5 entry cache.
testptr()->hcptr_->flush(testptr()->hcptr_->size() - 5);
testptr()->hcptr_->setMaximum(5);
- ASSERT_EQ(5, testptr()->hcptr_->size());
+ ASSERT_EQ(5U, testptr()->hcptr_->size());
size_t hits5 = testptr()->hcptr_->hits_;
size_t inserts5 = testptr()->hcptr_->inserts_;
// Go for 1000 rounds.
}
hits_delta = testptr()->hcptr_->hits_ - hits5;
inserts_delta = testptr()->hcptr_->inserts_ - inserts5;
- EXPECT_EQ(1000, hits_delta + inserts_delta);
+ EXPECT_EQ(1000U, hits_delta + inserts_delta);
cerr << "1000 rounds with cache 5: " << hits_delta << endl;
// Prob(hits_delta >= 15) ~= 2.10-4
if (soft) {
status = false;
}
} else {
- EXPECT_GE(15, hits_delta);
+ EXPECT_GE(15U, hits_delta);
}
// Try a 2 entry cache.
testptr()->hcptr_->flush(testptr()->hcptr_->size() - 2);
testptr()->hcptr_->setMaximum(2);
- ASSERT_EQ(2, testptr()->hcptr_->size());
+ ASSERT_EQ(2U, testptr()->hcptr_->size());
size_t hits2 = testptr()->hcptr_->hits_;
size_t inserts2 = testptr()->hcptr_->inserts_;
// Go for 1000 rounds.
}
hits_delta = testptr()->hcptr_->hits_ - hits2;
inserts_delta = testptr()->hcptr_->inserts_ - inserts2;
- EXPECT_EQ(1000, hits_delta + inserts_delta);
+ EXPECT_EQ(1000U, hits_delta + inserts_delta);
cerr << "1000 rounds with cache 2: " << hits_delta << endl;
// Prob(hits_delta >= 9) ~= 2.10^-4
if (soft) {
status = false;
}
} else {
- EXPECT_GE(9, hits_delta);
+ EXPECT_GE(9U, hits_delta);
}
// And finish with an 1 entry cache.
testptr()->hcptr_->flush(0);
- ASSERT_EQ(0, testptr()->hcptr_->size());
+ ASSERT_EQ(0U, testptr()->hcptr_->size());
testptr()->hcptr_->setMaximum(1);
size_t hits1 = testptr()->hcptr_->hits_;
size_t inserts1 = testptr()->hcptr_->inserts_;
}
hits_delta = testptr()->hcptr_->hits_ - hits1;
inserts_delta = testptr()->hcptr_->inserts_ - inserts1;
- EXPECT_EQ(8000, hits_delta + inserts_delta);
+ EXPECT_EQ(8000U, hits_delta + inserts_delta);
cerr << "8000 rounds with cache 1: " << hits_delta << endl;
// Prob(hits_delta == 0) ~= 5.10-4
if (soft) {
status = false;
}
} else {
- EXPECT_NE(0, hits_delta);
+ EXPECT_NE(0U, hits_delta);
}
}
void fill() {
ASSERT_EQ(4294967295U, SUBNET_ID_UNUSED);
HostPtr host = createHost4();
- EXPECT_EQ(0, hcptr_->insert(host, false));
+ EXPECT_EQ(0U, hcptr_->insert(host, false));
host = createHost4bis();
- EXPECT_EQ(0, hcptr_->insert(host, false));
+ EXPECT_EQ(0U, hcptr_->insert(host, false));
host = createHost6();
- EXPECT_EQ(0, hcptr_->insert(host, false));
+ EXPECT_EQ(0U, hcptr_->insert(host, false));
host = createHost6bis();
- EXPECT_EQ(0, hcptr_->insert(host, false));
- EXPECT_EQ(4, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->insert(host, false));
+ EXPECT_EQ(4U, hcptr_->size());
}
/// @brief Check host ID handling.
EXPECT_NO_THROW(hcptr_->configure(config));
// Check defaults.
- EXPECT_EQ(0, hcptr_->getMaximum());
+ EXPECT_EQ(0U, hcptr_->getMaximum());
// Config must be a map.
config = Element::createList();
// Fill config.
config = Element::fromJSON("{ \"maximum\": 19 }");
EXPECT_NO_THROW(hcptr_->configure(config));
- EXPECT_EQ(19, hcptr_->getMaximum());
+ EXPECT_EQ(19U, hcptr_->getMaximum());
// Check maximum.
config = Element::fromJSON("{ \"maximum\": 0 }");
EXPECT_NO_THROW(hcptr_->configure(config));
- EXPECT_EQ(0, hcptr_->getMaximum());
+ EXPECT_EQ(0U, hcptr_->getMaximum());
config = Element::fromJSON("{ \"maximum\": -1 }");
EXPECT_THROW(hcptr_->configure(config), ConfigError);
// Flush an entry
checkCommand(flush_handler, flush1_cmd, 0, 0,
"Cache flushed (1 entries removed).");
- EXPECT_EQ(3, hcptr_->size());
+ EXPECT_EQ(3U, hcptr_->size());
// Flush another
checkCommand(flush_handler, flush1_cmd, 0, 0,
"Cache flushed (1 entries removed).");
- EXPECT_EQ(2, hcptr_->size());
+ EXPECT_EQ(2U, hcptr_->size());
// Flush all aka clear
checkCommand(clear_handler, clear_cmd, 0, 0, "Cache cleared.");
- EXPECT_EQ(0, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->size());
// No issue to flush an empty cache
checkCommand(flush_handler, flush1_cmd, 0, 0,
checkCommand(get_handler, get_cmd, 0, 3, entries);
// Dump cache with host4
- EXPECT_EQ(0, hcptr_->insert(createHost4(), false));
+ EXPECT_EQ(0U, hcptr_->insert(createHost4(), false));
entries->add(Element::fromJSON(host4_txt));
checkCommand(get_handler, get_cmd, 0, 0, entries);
// Dump cache with host4 and host6
- EXPECT_EQ(0, hcptr_->insert(createHost6(), false));
+ EXPECT_EQ(0U, hcptr_->insert(createHost6(), false));
entries->add(Element::fromJSON(host6_txt));
checkCommand(get_handler, get_cmd, 0, 0, entries);
}
checkCommand(get_by_id_handler, get_by_id_cmd, 0, 3, entries);
// From cache with host4
- EXPECT_EQ(0, hcptr_->insert(createHost4(), false));
+ EXPECT_EQ(0U, hcptr_->insert(createHost4(), false));
entries->add(Element::fromJSON(host4_txt));
checkCommand(get_by_id_handler, get_by_id_cmd, 0, 0, entries);
// From cache with host4 and host6
- EXPECT_EQ(0, hcptr_->insert(createHost6(), false));
+ EXPECT_EQ(0U, hcptr_->insert(createHost6(), false));
entries->add(Element::fromJSON(host6_txt));
checkCommand(get_by_id_handler, get_by_id_cmd, 0, 0, entries);
}
"\"server-hostname\": \"server-hostname.example.org\",\n"
"\"boot-file-name\": \"bootfile.efi\",\n"
"\"host-id\": 0 }\n";
- EXPECT_EQ(0, hcptr_->insert(h, false));
+ EXPECT_EQ(0U, hcptr_->insert(h, false));
entries->add(Element::fromJSON(txt));
checkCommand(get_by_id_handler, get_by_id_cmd, 0, 0, entries);
}
"\"server-hostname\": \"server-hostname.example.org\",\n"
"\"boot-file-name\": \"bootfile.efi\",\n"
"\"host-id\": 0 }\n";
- EXPECT_EQ(0, hcptr_->insert(h, false));
+ EXPECT_EQ(0U, hcptr_->insert(h, false));
entries->add(Element::fromJSON(txt));
checkCommand(get_by_id_handler, get_by_id_cmd, 0, 0, entries);
}
add->set("arguments", args);
checkCommand(add_handler, add, 0, 0,
"0 entries inserted (0 overwritten by more recent entries).");
- EXPECT_EQ(0, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->size());
// Insert one entry
args = Element::fromJSON(host4_txt);
add->set("arguments", args);
checkCommand(add_handler, add, 0, 0,
"1 entries inserted (0 overwritten by more recent entries).");
- EXPECT_EQ(1, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->size());
// Insert a list
args = Element::createList();
add->set("arguments", args);
checkCommand(add_handler, add, 0, 0,
"1 entries inserted (0 overwritten by more recent entries).");
- EXPECT_EQ(2, hcptr_->size());
+ EXPECT_EQ(2U, hcptr_->size());
// Overwrite an entry
args = Element::createList();
add->set("arguments", args);
checkCommand(add_handler, add, 0, 0,
"1 entries inserted (1 overwritten by more recent entries).");
- EXPECT_EQ(2, hcptr_->size());
+ EXPECT_EQ(2U, hcptr_->size());
// Check the order
ElementPtr entries = Element::createList();
"{ \"command\": \"cache-write\", \"arguments\": \"" + file_txt + "\" }";
// Insert two entries
- EXPECT_EQ(0, hcptr_->insert(createHost4(), false));
- EXPECT_EQ(0, hcptr_->insert(createHost6(), false));
- EXPECT_EQ(2, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->insert(createHost4(), false));
+ EXPECT_EQ(0U, hcptr_->insert(createHost6(), false));
+ EXPECT_EQ(2U, hcptr_->size());
// Write file
checkCommand(write_handler, write_cmd, 0, 0,
"{ \"command\": \"cache-write\", \"arguments\": \"" + badpath + "\" }";
// Insert an entry.
- EXPECT_EQ(0, hcptr_->insert(createHost4(), false));
- EXPECT_EQ(1, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->insert(createHost4(), false));
+ EXPECT_EQ(1U, hcptr_->size());
// Write file
checkCommand(write_handler, write_cmd, 0, 0,
oss << "HOST_CACHE_PATH_SECURITY_WARNING Cache file path specified"
<< " is NOT SECURE: invalid path specified: '/tmp', supported path is '"
<< CfgMgr::instance().getDataDir() << "'";
- EXPECT_EQ(1, countFile(oss.str()));
+ EXPECT_EQ(1U, countFile(oss.str()));
}
// Verifies that cache-load can load a dump file.
checkCommand(load_handler, load_cmd, 0, 0,
"3 entries loaded from '" + file_txt + "' (1 overwritten "
"by more recent entries).");
- EXPECT_EQ(2, hcptr_->size());
+ EXPECT_EQ(2U, hcptr_->size());
// Check errors
string noarg_cmd = "{ \"command\": \"cache-load\" }";
ElementPtr del = Element::createMap();
del->set("command", Element::create(string("cache-remove")));
fill();
- ASSERT_EQ(4, hcptr_->size());
+ ASSERT_EQ(4U, hcptr_->size());
// Common remove by address.
ElementPtr args = Element::createMap();
args->set("ip-address", Element::create(string("192.0.2.200")));
del->set("arguments", args);
checkCommand(del_handler, del, 0, 0, "Host removed.");
- EXPECT_EQ(3, hcptr_->size());
+ EXPECT_EQ(3U, hcptr_->size());
// Remove it a second time won't find it.
checkCommand(del_handler, del, 0, 3, "Host not removed (not found).");
- EXPECT_EQ(3, hcptr_->size());
+ EXPECT_EQ(3U, hcptr_->size());
// Common remove by identifier.
args = Element::createMap();
args->set("hw-address", Element::create(string("07:08:09:0a:0b:0c")));
del->set("arguments", args);
checkCommand(del_handler, del, 0, 0, "Host removed.");
- EXPECT_EQ(2, hcptr_->size());
+ EXPECT_EQ(2U, hcptr_->size());
// Subnet-id specification is flexible for by address.
args = Element::createMap();
args->set("ip-address", Element::create(string("2001:db8:dead:beef::")));
del->set("arguments", args);
checkCommand(del_handler, del, 0, 0, "Host removed.");
- EXPECT_EQ(1, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->size());
// Check errors.
checkCommand(del_handler, del, 1, 1, "invalid (empty) identifier");
// All of these failed.
- EXPECT_EQ(1, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->size());
}
// Verifies that global reservations are handled.
// Like fill() but replacing the subnet ID by global (0).
HostPtr host = createHost4();
host->setIPv4SubnetID(SUBNET_ID_GLOBAL);
- EXPECT_EQ(0, hcptr_->insert(host, false));
+ EXPECT_EQ(0U, hcptr_->insert(host, false));
host = createHost4bis();
host->setIPv4SubnetID(SUBNET_ID_GLOBAL);
- EXPECT_EQ(0, hcptr_->insert(host, false));
+ EXPECT_EQ(0U, hcptr_->insert(host, false));
host = createHost6();
host->setIPv6SubnetID(SUBNET_ID_GLOBAL);
- EXPECT_EQ(0, hcptr_->insert(host, false));
+ EXPECT_EQ(0U, hcptr_->insert(host, false));
host = createHost6bis();
host->setIPv6SubnetID(SUBNET_ID_GLOBAL);
- EXPECT_EQ(0, hcptr_->insert(host, false));
- EXPECT_EQ(4, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->insert(host, false));
+ EXPECT_EQ(4U, hcptr_->size());
// Copy of remove positive tests.
args->set("ip-address", Element::create(string("192.0.2.200")));
del->set("arguments", args);
checkCommand(del_handler, del, 0, 0, "Host removed.");
- EXPECT_EQ(3, hcptr_->size());
+ EXPECT_EQ(3U, hcptr_->size());
// Remove it a second time won't find it.
checkCommand(del_handler, del, 0, 3, "Host not removed (not found).");
- EXPECT_EQ(3, hcptr_->size());
+ EXPECT_EQ(3U, hcptr_->size());
// Common remove by identifier.
args = Element::createMap();
args->set("hw-address", Element::create(string("07:08:09:0a:0b:0c")));
del->set("arguments", args);
checkCommand(del_handler, del, 0, 0, "Host removed.");
- EXPECT_EQ(2, hcptr_->size());
+ EXPECT_EQ(2U, hcptr_->size());
// Subnet-id specification is flexible for by address.
args = Element::createMap();
args->set("ip-address", Element::create(string("2001:db8:dead:beef::")));
del->set("arguments", args);
checkCommand(del_handler, del, 0, 0, "Host removed.");
- EXPECT_EQ(1, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->size());
}
// Verifies that host-id is correctly handled.
///
/// @param subnets number of subnets to test
/// @param id Host identifier type.
- void hcMultipleSubnets(int subnets, const Host::IdentifierType& id);
+ void hcMultipleSubnets(size_t subnets, const Host::IdentifierType& id);
/// @brief Test if host reservations made for different IPv6 subnets
/// are handled correctly.
///
/// @param subnets number of subnets to test
/// @param id identifier type (IDENT_HWADDR or IDENT_DUID)
- void hcSubnetId6(int subnets, Host::IdentifierType id);
+ void hcSubnetId6(size_t subnets, Host::IdentifierType id);
/// @brief Test that DHCPv4 options can be inserted and retrieved from
/// the database.
/// Redefined tests
void
-HostDataSourceTest::hcMultipleSubnets(int subnets,
+HostDataSourceTest::hcMultipleSubnets(size_t subnets,
const Host::IdentifierType& id) {
// Make sure we have a pointer to the host data source.
ASSERT_TRUE(hdsptr_);
HostPtr host = HostDataSourceUtils::initializeHost4("192.0.2.1", id);
host->setIPv6SubnetID(SUBNET_ID_UNUSED);
- for (int i = 0; i < subnets; ++i) {
+ for (size_t i = 0; i < subnets; ++i) {
host->setIPv4SubnetID(i);
// Check that the same host can have reservations in multiple subnets.
// Now check that the reservations can be retrieved by IPv4 address from
// each subnet separately.
- for (int i = 0; i < subnets; ++i) {
+ for (size_t i = 0; i < subnets; ++i) {
// Try to retrieve the host by IPv4 address.
ConstHostPtr from_hds =
hdsptr_->get4(i, host->getIPv4Reservation());
}
void
-HostDataSourceTest::hcSubnetId6(int subnets, Host::IdentifierType id) {
+HostDataSourceTest::hcSubnetId6(size_t subnets, Host::IdentifierType id) {
// Make sure we have a pointer to the host data source.
ASSERT_TRUE(hdsptr_);
HostPtr host;
IOAddress current_address("2001:db8::");
ASSERT_LT(subnets, std::numeric_limits<uint16_t>::max()) << "Too many subnets. Broken test?";
- for (int i = 0; i < subnets; ++i) {
+ for (size_t i = 0; i < subnets; ++i) {
// Last boolean value set to false indicates that the same identifier
// must be used for each generated host.
host = HostDataSourceUtils::initializeHost6(current_address.toText(),
}
// Check that the reservations can be retrieved from each subnet separately.
- for (int i = 0; i < subnets; ++i) {
+ for (size_t i = 0; i < subnets; ++i) {
// Try to retrieve the host
ConstHostPtr from_hds = hdsptr_->get6(i, id, &host->getIdentifier()[0],
host->getIdentifier().size());
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
- EXPECT_EQ(0, CfgMgr::instance().getCurrentCfg()->getCfgHosts()->getAll4(SubnetID(1)).size());
+ EXPECT_EQ(0U, hds->size());
+ EXPECT_EQ(0U, CfgMgr::instance().getCurrentCfg()->getCfgHosts()->getAll4(SubnetID(1)).size());
string exp_rsp = "Host added.";
testCommand(boost::get<0>(test_case), CONTROL_RESULT_SUCCESS, exp_rsp);
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// The inserted reservation lacks IPv4 address. It should be added
// correctly.
testCommand(txt, CONTROL_RESULT_SUCCESS, exp_rsp);
// Now check that the host was really there.
- EXPECT_EQ(1, hds->size());
+ EXPECT_EQ(1U, hds->size());
}
// Check that adding new host works only when actual data source is
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Now send the command.
string txt =
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
string exp_rsp = "Host added.";
testCommand(boost::get<0>(test_case), CONTROL_RESULT_SUCCESS, exp_rsp);
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// The inserted reservation lacks IPv6 addresses and prefixes. It
// should be added correctly.
testCommand(txt, CONTROL_RESULT_SUCCESS, exp_rsp);
// Now check that the host was really there.
- EXPECT_EQ(1, hds->size());
+ EXPECT_EQ(1U, hds->size());
}
// Checks that the reservation without any subnet and IPv4 address is added
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// The inserted reservation lacks subnet id and IPv4 address.
string txt =
testCommand(txt, CONTROL_RESULT_SUCCESS, exp_rsp);
// Now check that the host was really there.
- EXPECT_EQ(1, hds->size());
+ EXPECT_EQ(1U, hds->size());
// Verify the host is global.
uint8_t hw_addr[] = { 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f };
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// The inserted reservation lacks subnet id and IPv6 address/prefixes.
string txt =
testCommand(txt, CONTROL_RESULT_SUCCESS, exp_rsp);
// Now check that the host was really there.
- EXPECT_EQ(1, hds->size());
+ EXPECT_EQ(1U, hds->size());
// Verify the host is global.
uint8_t hw_addr[] = { 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f };
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Add a reservation with a Prefix Exclude option.
string txt =
testCommand(txt, CONTROL_RESULT_SUCCESS, exp_rsp);
// Now check that the host was really there.
- EXPECT_EQ(1, hds->size());
+ EXPECT_EQ(1U, hds->size());
// Verify there is a host with the Prefix Exclude option.
uint8_t hw_addr[] = { 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f };
ASSERT_TRUE(hds);
// Check that there are no hosts.
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
uint8_t duid[21];
for (uint8_t i = 0; i < 21; ++i) {
// Create in-memory hosts database to be used for the test.
MemHostDataSourcePtr hds = setHostsDataSource(false, false);
ASSERT_TRUE(hds);
- ASSERT_EQ(0, hds->size());
+ ASSERT_EQ(0U, hds->size());
// Address for which the reservation is added is valid for the prefix
// of the configured subnet, but the subnet id is not matching.
testCommand(cmd, CONTROL_RESULT_ERROR, "IPv4 subnet with ID of '100' is not configured");
// Make sure the host wasn't added.
- ASSERT_EQ(0, hds->size());
+ ASSERT_EQ(0U, hds->size());
}
// Checks that the reservation is not added if the specified subnet identifier
// Create in-memory hosts database to be used for the test.
MemHostDataSourcePtr hds = setHostsDataSource(false, false);
ASSERT_TRUE(hds);
- ASSERT_EQ(0, hds->size());
+ ASSERT_EQ(0U, hds->size());
// Address for which the reservation is added is valid for the prefix
// of the configured subnet, but the subnet id is not matching.
testCommand(cmd, CONTROL_RESULT_ERROR, "IPv6 subnet with ID of '100' is not configured");
// Make sure the host wasn't added.
- ASSERT_EQ(0, hds->size());
+ ASSERT_EQ(0U, hds->size());
}
// Checks that the reservation is not added if the specified IP address
// Create in-memory hosts database to be used for the test.
MemHostDataSourcePtr hds = setHostsDataSource(false, false);
ASSERT_TRUE(hds);
- ASSERT_EQ(0, hds->size());
+ ASSERT_EQ(0U, hds->size());
// Subnet id matches the configured subnet, but the reserved IP
// address should be in range of the subnet prefix, so between
"IPv4 subnet prefix '192.0.2.64/26'");
// Make sure the host wasn't added.
- ASSERT_EQ(0, hds->size());
+ ASSERT_EQ(0U, hds->size());
}
// Checks that the reservation is not added if any of the specified IPv6
// Create in-memory hosts database to be used for the test.
MemHostDataSourcePtr hds = setHostsDataSource(false, false);
ASSERT_TRUE(hds);
- ASSERT_EQ(0, hds->size());
+ ASSERT_EQ(0U, hds->size());
// Subnet id matches the configured subnet, but all reserved IP
// addresses should be in range of the subnet prefix.
"IPv6 subnet prefix '2001:db8:1::/64'");
// Make sure the host wasn't added.
- ASSERT_EQ(0, hds->size());
+ ASSERT_EQ(0U, hds->size());
}
// Checks that reservation-get-all can handle a situation when the query is
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Now send the command.
string cmd =
IOAddress("192.0.3.5"),
"host5.example.org"));
hds->add(host5);
- EXPECT_EQ(5, hds->size());
+ EXPECT_EQ(5U, hds->size());
// Retry command.
exp_rsp = "5 IPv4 host(s) found.";
ConstElementPtr hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(5, hosts->size());
+ ASSERT_EQ(5U, hosts->size());
// Assume the order is kept.
ElementPtr rsp0 = host0->toElement4();
IOAddress("192.0.3.5"),
"host5.example.org"));
hds->add(host5);
- EXPECT_EQ(5, hds->size());
+ EXPECT_EQ(5U, hds->size());
// Add a host with illegal hardware address.
uint8_t duid[21];
EXPECT_NO_THROW(bad->setIdentifierType(Host::IDENT_HWADDR));
ASSERT_THROW(bad->getHWAddress(), BadValue);
hds->add(bad);
- EXPECT_EQ(6, hds->size());
+ EXPECT_EQ(6U, hds->size());
// Now send the command.
string cmd =
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Now send the command.
string cmd =
host5->addReservation(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:2::5")));
hds->add(host5);
- EXPECT_EQ(5, hds->size());
+ EXPECT_EQ(5U, hds->size());
// Retry command.
exp_rsp = "5 IPv6 host(s) found.";
ConstElementPtr hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(5, hosts->size());
+ ASSERT_EQ(5U, hosts->size());
// Assume the order is kept.
ElementPtr rsp0 = host0->toElement6();
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Now send the command.
string cmd_txt =
addr));
hds->add(host);
}
- EXPECT_EQ(25, hds->size());
+ EXPECT_EQ(25U, hds->size());
// Get all.
cmd_txt =
ConstElementPtr hosts_all = rsp_args->get("hosts");
ASSERT_TRUE(hosts_all);
ASSERT_EQ(Element::list, hosts_all->getType());
- ASSERT_EQ(25, hosts_all->size());
+ ASSERT_EQ(25U, hosts_all->size());
// Get first page.
ElementPtr cmd = Element::createMap();
ConstElementPtr page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- ASSERT_EQ(10, page->size());
+ ASSERT_EQ(10U, page->size());
ElementPtr hosts = data::copy(page);
ConstElementPtr count = rsp_args->get("count");
ASSERT_TRUE(count);
page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- EXPECT_EQ(10, page->size());
+ EXPECT_EQ(10U, page->size());
for (size_t i = 0; i < page->size(); ++i) {
hosts->add(data::copy(page->get(i)));
}
page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- EXPECT_EQ(5, page->size());
+ EXPECT_EQ(5U, page->size());
for (size_t i = 0; i < page->size(); ++i) {
hosts->add(data::copy(page->get(i)));
}
page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- EXPECT_EQ(0, page->size());
+ EXPECT_EQ(0U, page->size());
next = rsp_args->get("next");
EXPECT_FALSE(next);
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Now send the command.
string cmd_txt =
host->addReservation(IPv6Resrv(IPv6Resrv::TYPE_NA, addr));
hds->add(host);
}
- EXPECT_EQ(25, hds->size());
+ EXPECT_EQ(25U, hds->size());
// Get all.
cmd_txt =
ConstElementPtr hosts_all = rsp_args->get("hosts");
ASSERT_TRUE(hosts_all);
ASSERT_EQ(Element::list, hosts_all->getType());
- ASSERT_EQ(25, hosts_all->size());
+ ASSERT_EQ(25U, hosts_all->size());
// Get first page.
ElementPtr cmd = Element::createMap();
ConstElementPtr page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- ASSERT_EQ(10, page->size());
+ ASSERT_EQ(10U, page->size());
ElementPtr hosts = data::copy(page);
ConstElementPtr count = rsp_args->get("count");
ASSERT_TRUE(count);
page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- EXPECT_EQ(10, page->size());
+ EXPECT_EQ(10U, page->size());
for (size_t i = 0; i < page->size(); ++i) {
hosts->add(data::copy(page->get(i)));
}
page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- EXPECT_EQ(5, page->size());
+ EXPECT_EQ(5U, page->size());
for (size_t i = 0; i < page->size(); ++i) {
hosts->add(data::copy(page->get(i)));
}
page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- EXPECT_EQ(0, page->size());
+ EXPECT_EQ(0U, page->size());
next = rsp_args->get("next");
EXPECT_FALSE(next);
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Now send the command.
string cmd_txt =
hostu->addReservation(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:2::6")));
hds->add(hostu);
- EXPECT_EQ(26, hds->size());
+ EXPECT_EQ(26U, hds->size());
// Get first page.
ElementPtr cmd = Element::createMap();
ConstElementPtr page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- ASSERT_EQ(10, page->size());
+ ASSERT_EQ(10U, page->size());
ConstElementPtr count = rsp_args->get("count");
ASSERT_TRUE(count);
ASSERT_EQ(Element::integer, count->getType());
page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- EXPECT_EQ(10, page->size());
+ EXPECT_EQ(10U, page->size());
next = rsp_args->get("next");
ASSERT_TRUE(next);
ASSERT_EQ(Element::map, next->getType());
page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- EXPECT_EQ(5, page->size());
+ EXPECT_EQ(5U, page->size());
next = rsp_args->get("next");
ASSERT_TRUE(next);
ASSERT_EQ(Element::map, next->getType());
page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- EXPECT_EQ(0, page->size());
+ EXPECT_EQ(0U, page->size());
next = rsp_args->get("next");
EXPECT_FALSE(next);
}
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Now send the command.
string cmd_txt =
SubnetID(2), SubnetID(SUBNET_ID_UNUSED),
IOAddress("192.0.3.6")));
hds->add(hostu);
- EXPECT_EQ(26, hds->size());
+ EXPECT_EQ(26U, hds->size());
// Get first page.
ElementPtr cmd = Element::createMap();
ConstElementPtr page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- ASSERT_EQ(10, page->size());
+ ASSERT_EQ(10U, page->size());
ConstElementPtr count = rsp_args->get("count");
ASSERT_TRUE(count);
ASSERT_EQ(Element::integer, count->getType());
page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- EXPECT_EQ(10, page->size());
+ EXPECT_EQ(10U, page->size());
next = rsp_args->get("next");
ASSERT_TRUE(next);
ASSERT_EQ(Element::map, next->getType());
page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- EXPECT_EQ(5, page->size());
+ EXPECT_EQ(5U, page->size());
next = rsp_args->get("next");
ASSERT_TRUE(next);
ASSERT_EQ(Element::map, next->getType());
page = rsp_args->get("hosts");
ASSERT_TRUE(page);
ASSERT_EQ(Element::list, page->getType());
- EXPECT_EQ(0, page->size());
+ EXPECT_EQ(0U, page->size());
next = rsp_args->get("next");
EXPECT_FALSE(next);
}
// First, let's create a dummy host data source (don't insert any hosts)
MemHostDataSourcePtr hds = setHostsDataSource(false, false);
ASSERT_TRUE(hds);
- ASSERT_EQ(0, hds->size());
+ ASSERT_EQ(0U, hds->size());
// Command to add global host.
string cmd =
testCommand(cmd, CONTROL_RESULT_SUCCESS, "Host added.");
// Make sure we now have at least one host.
- ASSERT_EQ(1, hds->size());
+ ASSERT_EQ(1U, hds->size());
// Verify that we can fetch the host using global subnet id.
cmd =
testCommand(cmd, CONTROL_RESULT_SUCCESS, "Host deleted.");
// Make sure we now have at least one host.
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
}
// Checks that subnetID = SUBNET_ID_GLOBAL is ok for IPv6 host reservations
// First, let's create a dummy host data source (don't insert any hosts)
MemHostDataSourcePtr hds = setHostsDataSource(false, false);
ASSERT_TRUE(hds);
- ASSERT_EQ(0, hds->size());
+ ASSERT_EQ(0U, hds->size());
// Command to add global host.
string cmd =
testCommand(cmd, CONTROL_RESULT_SUCCESS, "Host added.");
// Make sure we now have at least one host.
- ASSERT_EQ(1, hds->size());
+ ASSERT_EQ(1U, hds->size());
// Verify that we can fetch the host using global subnet id.
cmd =
testCommand(cmd, CONTROL_RESULT_SUCCESS, "Host deleted.");
// Make sure we now have at least one host.
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
}
// Checks that reservation-get-by-hostname with some IPv4 hosts.
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Now send the command.
string cmd =
hostu->addReservation(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:2::6")));
hds->add(hostu);
- EXPECT_EQ(6, hds->size());
+ EXPECT_EQ(6U, hds->size());
// Retry command.
exp_rsp = "4 IPv4 host(s) found.";
ConstElementPtr hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(4, hosts->size());
+ ASSERT_EQ(4U, hosts->size());
// Assume the order is kept.
compResponseHost4(hosts->get(0), host1);
hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(3, hosts->size());
+ ASSERT_EQ(3U, hosts->size());
// Assume the order is kept.
ElementPtr expected = host1->toElement4();
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Now send the command.
string cmd =
SubnetID(2), SubnetID(SUBNET_ID_UNUSED),
IOAddress("192.0.3.6")));
hds->add(hostu);
- EXPECT_EQ(6, hds->size());
+ EXPECT_EQ(6U, hds->size());
// Retry command.
exp_rsp = "4 IPv6 host(s) found.";
ConstElementPtr hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(4, hosts->size());
+ ASSERT_EQ(4U, hosts->size());
// Assume the order is kept.
compResponseHost6(hosts->get(0), host1);
hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(3, hosts->size());
+ ASSERT_EQ(3U, hosts->size());
// Assume the order is kept.
ElementPtr expected = host1->toElement6();
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Now send the command.
string cmd =
hostu->addReservation(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:2::6")));
hds->add(hostu);
- EXPECT_EQ(6, hds->size());
+ EXPECT_EQ(6U, hds->size());
// Retry command.
exp_rsp = "4 IPv4 host(s) found.";
ConstElementPtr hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(4, hosts->size());
+ ASSERT_EQ(4U, hosts->size());
// Assume the order is kept.
compResponseHost4(hosts->get(0), host1);
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Now send the command.
string cmd =
SubnetID(2), SubnetID(SUBNET_ID_UNUSED),
IOAddress("192.0.3.6")));
hds->add(hostu);
- EXPECT_EQ(6, hds->size());
+ EXPECT_EQ(6U, hds->size());
// Retry command.
exp_rsp = "4 IPv6 host(s) found.";
ConstElementPtr hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(4, hosts->size());
+ ASSERT_EQ(4U, hosts->size());
// Assume the order is kept.
compResponseHost6(hosts->get(0), host1);
"Host updated.");
ConstHostCollection hosts = HostMgr::instance().getAll6(SubnetID(1));
- EXPECT_EQ(1, hosts.size());
+ EXPECT_EQ(1U, hosts.size());
EXPECT_EQ("domain.example.com", hosts[0]->getHostname());
}
"Host updated.");
ConstHostCollection hosts = HostMgr::instance().getAll6(SubnetID(1));
- EXPECT_EQ(2, hosts.size());
+ EXPECT_EQ(2U, hosts.size());
for (auto const& h : hosts) {
EXPECT_EQ("domain.example.com", h->getHostname());
}
ASSERT_TRUE(hds);
// Check that there are no hosts
- EXPECT_EQ(0, hds->size());
+ EXPECT_EQ(0U, hds->size());
// Add host to the configuration.
HostPtr host0(new Host("01:02:03:04:05:00", "hw-address",
IOAddress("192.0.2.10"),
"host0.example.org"));
hds->add(host0);
- EXPECT_EQ(1, hds->size());
+ EXPECT_EQ(1U, hds->size());
// Now send the command.
string cmd =
ConstElementPtr hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(1, hosts->size());
+ ASSERT_EQ(1U, hosts->size());
ElementPtr rsp0 = host0->toElement4();
SubnetID subnet_id0 = host0->getIPv4SubnetID();
ConstElementPtr hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(2, hosts->size());
+ ASSERT_EQ(2U, hosts->size());
// Let's verify if hosts received in a response are as expected.
compResponseHost4(hosts->get(0), host1);
hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(3, hosts->size());
+ ASSERT_EQ(3U, hosts->size());
// Let's verify if hosts received in a response are as expected.
compResponseHost4(hosts->get(0), host1);
MemHostDataSourcePtr hds = setHostsDataSource(false, true);
ASSERT_TRUE(hds);
- EXPECT_EQ(1, hds->size());
+ EXPECT_EQ(1U, hds->size());
// Now send the command.
string cmd =
ConstElementPtr hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(1, hosts->size());
+ ASSERT_EQ(1U, hosts->size());
}
// Checks that reservation-get-by-address detects not configured subnet IDs
ConstElementPtr hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(2, hosts->size());
+ ASSERT_EQ(2U, hosts->size());
// Let's verify if hosts received in a response are as expected.
compResponseHost6(hosts->get(0), host1);
hosts = args->get("hosts");
ASSERT_TRUE(hosts);
ASSERT_EQ(Element::list, hosts->getType());
- ASSERT_EQ(3, hosts->size());
+ ASSERT_EQ(3U, hosts->size());
// Let's verify if hosts received in a response are as expected.
compResponseHost6(hosts->get(0), host1);
// Make sure the lease has proper value set.
ASSERT_TRUE(l->hwaddr_);
EXPECT_EQ("1a:1b:1c:1d:1e:1f", l->hwaddr_->toText(false));
- EXPECT_EQ(3, l->valid_lft_); // taken from subnet configuration
+ EXPECT_EQ(3U, l->valid_lft_); // taken from subnet configuration
EXPECT_FALSE(l->fqdn_fwd_);
EXPECT_FALSE(l->fqdn_rev_);
EXPECT_EQ("", l->hostname_);
// Test execution is fast. The cltt should be set to now. In some rare
// cases we could have the seconds counter to tick, so having a value off
// by one is ok.
- EXPECT_LE(abs(l->cltt_ - time(NULL)), 1);
- EXPECT_EQ(0, l->state_);
+ EXPECT_LE(abs(l->cltt_ - time(0)), 1);
+ EXPECT_EQ(0U, l->state_);
}
void Lease4CmdsTest::testLease4AddDeclinedLeases() {
// Make sure the lease has proper value set.
ASSERT_TRUE(l->hwaddr_);
EXPECT_EQ("1a:1b:1c:1d:1e:1f", l->hwaddr_->toText(false));
- EXPECT_EQ(3, l->valid_lft_); // taken from subnet configuration
+ EXPECT_EQ(3U, l->valid_lft_); // taken from subnet configuration
EXPECT_FALSE(l->fqdn_fwd_);
EXPECT_FALSE(l->fqdn_rev_);
EXPECT_EQ("", l->hostname_);
// Test execution is fast. The cltt should be set to now. In some rare
// cases we could have the seconds counter to tick, so having a value off
// by one is ok.
- EXPECT_LE(abs(l->cltt_ - time(NULL)), 1);
- EXPECT_EQ(1, l->state_);
+ EXPECT_LE(abs(l->cltt_ - time(0)), 1);
+ EXPECT_EQ(1U, l->state_);
}
void Lease4CmdsTest::testLease4AddReleasedLeases() {
// Make sure the lease has proper value set.
ASSERT_TRUE(l->hwaddr_);
EXPECT_EQ("1a:1b:1c:1d:1e:1f", l->hwaddr_->toText(false));
- EXPECT_EQ(3, l->valid_lft_); // taken from subnet configuration
+ EXPECT_EQ(3U, l->valid_lft_); // taken from subnet configuration
EXPECT_FALSE(l->fqdn_fwd_);
EXPECT_FALSE(l->fqdn_rev_);
EXPECT_EQ("", l->hostname_);
// Test execution is fast. The cltt should be set to now. In some rare
// cases we could have the seconds counter to tick, so having a value off
// by one is ok.
- EXPECT_LE(abs(l->cltt_ - time(NULL)), 1);
- EXPECT_EQ(3, l->state_);
+ EXPECT_LE(abs(l->cltt_ - time(0)), 1);
+ EXPECT_EQ(3U, l->state_);
}
void Lease4CmdsTest::testLease4AddExisting() {
// Now check that the lease is really there and has correct subnet-id.
Lease4Ptr l = lmptr_->getLease4(IOAddress("192.0.2.202"));
ASSERT_TRUE(l);
- EXPECT_EQ(44, l->subnet_id_);
+ EXPECT_EQ(44U, l->subnet_id_);
}
void Lease4CmdsTest::testLease4AddSubnetIdMissingDeclinedLeases() {
// Now check that the lease is really there and has correct subnet-id.
Lease4Ptr l = lmptr_->getLease4(IOAddress("192.0.2.202"));
ASSERT_TRUE(l);
- EXPECT_EQ(44, l->subnet_id_);
+ EXPECT_EQ(44U, l->subnet_id_);
}
void Lease4CmdsTest::testLease4AddSubnetIdMissingBadAddr() {
EXPECT_EQ(true, l->fqdn_fwd_);
EXPECT_EQ(true, l->fqdn_rev_);
EXPECT_EQ("urania.example.org", l->hostname_);
- EXPECT_EQ(5, l->pool_id_);
+ EXPECT_EQ(5U, l->pool_id_);
ASSERT_TRUE(l->getContext());
EXPECT_EQ("{ \"foobar\": true }", l->getContext()->str());
}
leases = lmptr_->getLeases4ByRelayId(relay_id,
IOAddress::IPV4_ZERO_ADDRESS(),
LeasePageSize(10));
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_EQ(*l, *leases[0]);
leases = lmptr_->getLeases4ByRemoteId(remote_id,
IOAddress::IPV4_ZERO_ADDRESS(),
LeasePageSize(10));
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_EQ(*l, *leases[0]);
}
ASSERT_TRUE(leases);
ASSERT_EQ(Element::list, leases->getType());
- EXPECT_EQ(0, leases->size());
+ EXPECT_EQ(0U, leases->size());
}
void Lease4CmdsTest::testLease4GetAllBySubnetId() {
ASSERT_TRUE(leases);
ASSERT_EQ(Element::list, leases->getType());
- EXPECT_EQ(0, leases->size());
+ EXPECT_EQ(0U, leases->size());
}
void Lease4CmdsTest::testLease4GetAllByMultipleSubnetIds() {
}
// Check if all addresses were returned.
- EXPECT_EQ(1, lease_addresses.count("192.0.2.1"));
- EXPECT_EQ(1, lease_addresses.count("192.0.2.2"));
- EXPECT_EQ(1, lease_addresses.count("192.0.3.1"));
- EXPECT_EQ(1, lease_addresses.count("192.0.3.2"));
+ EXPECT_EQ(1U, lease_addresses.count("192.0.2.1"));
+ EXPECT_EQ(1U, lease_addresses.count("192.0.2.2"));
+ EXPECT_EQ(1U, lease_addresses.count("192.0.3.1"));
+ EXPECT_EQ(1U, lease_addresses.count("192.0.3.2"));
}
void Lease4CmdsTest::testLease4GetPagedZeroAddress() {
ConstElementPtr leases = map->get("leases");
ASSERT_TRUE(leases);
ASSERT_EQ(Element::list, leases->getType());
- ASSERT_EQ(2, leases->size());
+ ASSERT_EQ(2U, leases->size());
// Let's check if the response makes any sense.
ConstElementPtr lease = leases->get(0);
ConstElementPtr leases = map->get("leases");
ASSERT_TRUE(leases);
ASSERT_EQ(Element::list, leases->getType());
- ASSERT_EQ(2, leases->size());
+ ASSERT_EQ(2U, leases->size());
// Let's check if the response makes any sense.
ConstElementPtr lease = leases->get(0);
ConstElementPtr leases = map->get("leases");
ASSERT_TRUE(leases);
ASSERT_EQ(Element::list, leases->getType());
- ASSERT_EQ(4, leases->size());
+ ASSERT_EQ(4U, leases->size());
// Let's check if the response makes any sense.
ConstElementPtr lease = leases->get(0);
ConstElementPtr leases_rsp = map->get("leases");
ASSERT_TRUE(leases_rsp);
ASSERT_EQ(Element::list, leases_rsp->getType());
- ASSERT_EQ(1, leases_rsp->size());
+ ASSERT_EQ(1U, leases_rsp->size());
// Let's check if the response makes any sense.
ConstElementPtr lease = leases_rsp->get(0);
ConstElementPtr leases = map->get("leases");
ASSERT_TRUE(leases);
ASSERT_EQ(Element::list, leases->getType());
- ASSERT_EQ(4, leases->size());
+ ASSERT_EQ(4U, leases->size());
// Let's check if the response makes any sense.
ConstElementPtr lease = leases->get(0);
// Make sure the lease has been updated.
ASSERT_TRUE(l->hwaddr_);
EXPECT_EQ("1a:1b:1c:1d:1e:1f", l->hwaddr_->toText(false));
- EXPECT_EQ(3, l->pool_id_);
+ EXPECT_EQ(3U, l->pool_id_);
EXPECT_EQ("newhostname.example.org", l->hostname_);
EXPECT_FALSE(l->getContext());
}
// Make sure the lease has been updated.
ASSERT_TRUE(l->hwaddr_);
EXPECT_EQ("1a:1b:1c:1d:1e:1f", l->hwaddr_->toText(false));
- EXPECT_EQ(3, l->pool_id_);
+ EXPECT_EQ(3U, l->pool_id_);
EXPECT_EQ("newhostname.example.org", l->hostname_);
EXPECT_FALSE(l->getContext());
}
ASSERT_TRUE(l);
// Make sure the subnet-id is correct.
- EXPECT_EQ(44, l->subnet_id_);
+ EXPECT_EQ(44U, l->subnet_id_);
// Make sure the lease has been updated.
ASSERT_TRUE(l->hwaddr_);
ASSERT_TRUE(l);
// Make sure the subnet-id is correct.
- EXPECT_EQ(44, l->subnet_id_);
+ EXPECT_EQ(44U, l->subnet_id_);
// Make sure the lease has been updated.
ASSERT_TRUE(l->hwaddr_);
ASSERT_TRUE(l);
// Make sure the subnet-id is figured out correctly.
- EXPECT_EQ(44, l->subnet_id_);
+ EXPECT_EQ(44U, l->subnet_id_);
// Make sure the lease is correct.
ASSERT_TRUE(l->hwaddr_);
// Check user context.
ConstElementPtr ctx = l->getContext();
ASSERT_TRUE(ctx);
- EXPECT_EQ(2, ctx->size());
+ EXPECT_EQ(2U, ctx->size());
ASSERT_TRUE(ctx->contains("comment"));
EXPECT_EQ("\"a comment\"", ctx->get("comment")->str());
ASSERT_TRUE(ctx->contains("foobar"));
leases = lmptr_->getLeases4ByRelayId(relay_id,
IOAddress::IPV4_ZERO_ADDRESS(),
LeasePageSize(10));
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_EQ(*l, *leases[0]);
leases = lmptr_->getLeases4ByRemoteId(remote_id,
IOAddress::IPV4_ZERO_ADDRESS(),
LeasePageSize(10));
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_EQ(*l, *leases[0]);
}
testCommand(cmd, CONTROL_RESULT_SUCCESS,
"IPv4 lease database into '/tmp/kea-lease-write-test.txt'.");
- EXPECT_EQ(1, countFile(os.str()));
+ EXPECT_EQ(1U, countFile(os.str()));
}
TEST_F(Lease4CmdsTest, lease4AddMissingParams) {
// Make sure the lease has proper value set.
ASSERT_TRUE(l->duid_);
EXPECT_EQ("1a:1b:1c:1d:1e:1f", l->duid_->toText());
- EXPECT_EQ(4, l->valid_lft_); // taken from subnet configuration
+ EXPECT_EQ(4U, l->valid_lft_); // taken from subnet configuration
EXPECT_FALSE(l->fqdn_fwd_);
EXPECT_FALSE(l->fqdn_rev_);
EXPECT_EQ("", l->hostname_);
// cases we could have the seconds counter to tick, so having a value off
// by one is ok.
EXPECT_LE(abs(l->cltt_ - time(0)), 1);
- EXPECT_EQ(0, l->state_);
+ EXPECT_EQ(0U, l->state_);
}
void Lease6CmdsTest::testLease6AddDeclinedLeases() {
// Make sure the lease has proper value set.
ASSERT_TRUE(l->duid_);
EXPECT_EQ("1a:1b:1c:1d:1e:1f", l->duid_->toText());
- EXPECT_EQ(4, l->valid_lft_); // taken from subnet configuration
+ EXPECT_EQ(4U, l->valid_lft_); // taken from subnet configuration
EXPECT_FALSE(l->fqdn_fwd_);
EXPECT_FALSE(l->fqdn_rev_);
EXPECT_EQ("", l->hostname_);
// cases we could have the seconds counter to tick, so having a value off
// by one is ok.
EXPECT_LE(abs(l->cltt_ - time(0)), 1);
- EXPECT_EQ(1, l->state_);
+ EXPECT_EQ(1U, l->state_);
}
void Lease6CmdsTest::testLease6AddReleasedLeases() {
// Make sure the lease has proper value set.
ASSERT_TRUE(l->duid_);
EXPECT_EQ("1a:1b:1c:1d:1e:1f", l->duid_->toText());
- EXPECT_EQ(4, l->valid_lft_); // taken from subnet configuration
+ EXPECT_EQ(4U, l->valid_lft_); // taken from subnet configuration
EXPECT_FALSE(l->fqdn_fwd_);
EXPECT_FALSE(l->fqdn_rev_);
EXPECT_EQ("", l->hostname_);
// cases we could have the seconds counter to tick, so having a value off
// by one is ok.
EXPECT_LE(abs(l->cltt_ - time(0)), 1);
- EXPECT_EQ(3, l->state_);
+ EXPECT_EQ(3U, l->state_);
}
void Lease6CmdsTest::testLease6AddRegisteredLeases() {
// Make sure the lease has proper value set.
ASSERT_TRUE(l->duid_);
EXPECT_EQ("1a:1b:1c:1d:1e:1f", l->duid_->toText());
- EXPECT_EQ(4, l->valid_lft_); // taken from subnet configuration
+ EXPECT_EQ(4U, l->valid_lft_); // taken from subnet configuration
EXPECT_FALSE(l->fqdn_fwd_);
EXPECT_FALSE(l->fqdn_rev_);
EXPECT_EQ("", l->hostname_);
// cases we could have the seconds counter to tick, so having a value off
// by one is ok.
EXPECT_LE(abs(l->cltt_ - time(0)), 1);
- EXPECT_EQ(4, l->state_);
+ EXPECT_EQ(4U, l->state_);
}
void Lease6CmdsTest::testLease6AddExisting() {
// Now check that the lease is really there and has correct subnet-id.
Lease6Ptr l = lmptr_->getLease6(Lease::TYPE_NA, IOAddress("2001:db8:1::3"));
ASSERT_TRUE(l);
- EXPECT_EQ(66, l->subnet_id_);
+ EXPECT_EQ(66U, l->subnet_id_);
}
void Lease6CmdsTest::testLease6AddSubnetIdMissingDeclinedLeases() {
// Now check that the lease is really there and has correct subnet-id.
Lease6Ptr l = lmptr_->getLease6(Lease::TYPE_NA, IOAddress("2001:db8:1::3"));
ASSERT_TRUE(l);
- EXPECT_EQ(66, l->subnet_id_);
+ EXPECT_EQ(66U, l->subnet_id_);
}
void Lease6CmdsTest::testLease6AddSubnetIdMissingBadAddr() {
Lease6Ptr l = lmptr_->getLease6(Lease::TYPE_PD, IOAddress("2001:db8:abcd::"));
ASSERT_TRUE(l);
EXPECT_EQ(Lease::TYPE_PD, l->type_);
- EXPECT_EQ(48, l->prefixlen_);
+ EXPECT_EQ(48U, l->prefixlen_);
EXPECT_EQ("", l->hostname_);
EXPECT_FALSE(l->getContext());
}
EXPECT_EQ(true, l->fqdn_fwd_);
EXPECT_EQ(true, l->fqdn_rev_);
EXPECT_EQ("urania.example.org", l->hostname_);
- EXPECT_EQ(5, l->pool_id_);
+ EXPECT_EQ(5U, l->pool_id_);
ASSERT_TRUE(l->getContext());
EXPECT_EQ("{ \"foobar\": true }", l->getContext()->str());
}
ASSERT_TRUE(l->duid_);
EXPECT_EQ("88:88:88:88:88:88:88:88", l->duid_->toText());
EXPECT_EQ("newhostname.example.org", l->hostname_);
- EXPECT_EQ(7654321, l->iaid_);
+ EXPECT_EQ(7654321U, l->iaid_);
// Check the user context / extended info too.
ConstElementPtr ctx = l->getContext();
IOAddress::IPV6_ZERO_ADDRESS(),
LeasePageSize(10));
// The lease must be retrieved from the remote id table.
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
Lease6Ptr lx = leases[0];
ASSERT_TRUE(lx);
EXPECT_EQ(IOAddress("2001:db8:1::1"), lx->addr_);
leases = lmptr_->getLeases6ByRelayId(*relay_id,
IOAddress::IPV6_ZERO_ADDRESS(),
LeasePageSize(10));
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
lx = leases[0];
ASSERT_TRUE(lx);
EXPECT_EQ(IOAddress("2001:db8:1::1"), lx->addr_);
ASSERT_TRUE(leases);
ASSERT_EQ(Element::list, leases->getType());
- EXPECT_EQ(0, leases->size());
+ EXPECT_EQ(0U, leases->size());
}
void Lease6CmdsTest::testLease6GetAllBySubnetId() {
ASSERT_TRUE(leases);
ASSERT_EQ(Element::list, leases->getType());
- EXPECT_EQ(0, leases->size());
+ EXPECT_EQ(0U, leases->size());
}
void Lease6CmdsTest::testLease6GetAllByMultipleSubnetIds() {
}
// Check if all addresses were returned.
- EXPECT_EQ(1, lease_addresses.count("2001:db8:1::1"));
- EXPECT_EQ(1, lease_addresses.count("2001:db8:1::2"));
- EXPECT_EQ(1, lease_addresses.count("2001:db8:2::1"));
- EXPECT_EQ(1, lease_addresses.count("2001:db8:2::2"));
+ EXPECT_EQ(1U, lease_addresses.count("2001:db8:1::1"));
+ EXPECT_EQ(1U, lease_addresses.count("2001:db8:1::2"));
+ EXPECT_EQ(1U, lease_addresses.count("2001:db8:2::1"));
+ EXPECT_EQ(1U, lease_addresses.count("2001:db8:2::2"));
}
void Lease6CmdsTest::testLease6GetPagedZeroAddress() {
ConstElementPtr leases = map->get("leases");
ASSERT_TRUE(leases);
ASSERT_EQ(Element::list, leases->getType());
- ASSERT_EQ(2, leases->size());
+ ASSERT_EQ(2U, leases->size());
// Let's check if the response makes any sense.
ConstElementPtr lease = leases->get(0);
ConstElementPtr leases = map->get("leases");
ASSERT_TRUE(leases);
ASSERT_EQ(Element::list, leases->getType());
- ASSERT_EQ(2, leases->size());
+ ASSERT_EQ(2U, leases->size());
// Let's check if the response makes any sense.
ConstElementPtr lease = leases->get(0);
ConstElementPtr leases = map->get("leases");
ASSERT_TRUE(leases);
ASSERT_EQ(Element::list, leases->getType());
- ASSERT_EQ(4, leases->size());
+ ASSERT_EQ(4U, leases->size());
// Let's check if the response makes any sense.
ConstElementPtr lease = leases->get(0);
ConstElementPtr leases_rsp = map->get("leases");
ASSERT_TRUE(leases_rsp);
ASSERT_EQ(Element::list, leases_rsp->getType());
- ASSERT_EQ(1, leases_rsp->size());
+ ASSERT_EQ(1U, leases_rsp->size());
// Let's check if the response makes any sense.
ConstElementPtr lease = leases_rsp->get(0);
ConstElementPtr leases = map->get("leases");
ASSERT_TRUE(leases);
ASSERT_EQ(Element::list, leases->getType());
- ASSERT_EQ(4, leases->size());
+ ASSERT_EQ(4U, leases->size());
// Let's check if the response makes any sense.
ConstElementPtr lease = leases->get(0);
// Make sure the lease has been updated.
ASSERT_TRUE(l->duid_);
EXPECT_EQ("88:88:88:88:88:88:88:88", l->duid_->toText());
- EXPECT_EQ(3, l->pool_id_);
+ EXPECT_EQ(3U, l->pool_id_);
EXPECT_EQ("newhostname.example.org", l->hostname_);
- EXPECT_EQ(7654321, l->iaid_);
+ EXPECT_EQ(7654321U, l->iaid_);
EXPECT_FALSE(l->getContext());
}
// Make sure the lease has been updated.
ASSERT_TRUE(l->duid_);
EXPECT_EQ("88:88:88:88:88:88:88:88", l->duid_->toText());
- EXPECT_EQ(3, l->pool_id_);
+ EXPECT_EQ(3U, l->pool_id_);
EXPECT_EQ("newhostname.example.org", l->hostname_);
- EXPECT_EQ(7654321, l->iaid_);
+ EXPECT_EQ(7654321U, l->iaid_);
EXPECT_FALSE(l->getContext());
}
ASSERT_TRUE(l);
// Make sure the subnet-id is correct.
- EXPECT_EQ(66, l->subnet_id_);
+ EXPECT_EQ(66U, l->subnet_id_);
// Make sure the lease has been updated.
ASSERT_TRUE(l->duid_);
EXPECT_EQ("88:88:88:88:88:88:88:88", l->duid_->toText());
EXPECT_EQ("newhostname.example.org", l->hostname_);
- EXPECT_EQ(7654321, l->iaid_);
+ EXPECT_EQ(7654321U, l->iaid_);
EXPECT_FALSE(l->getContext());
}
ASSERT_TRUE(l);
// Make sure the subnet-id is correct.
- EXPECT_EQ(66, l->subnet_id_);
+ EXPECT_EQ(66U, l->subnet_id_);
// Make sure the lease has been updated.
ASSERT_TRUE(l->duid_);
EXPECT_EQ("88:88:88:88:88:88:88:88", l->duid_->toText());
EXPECT_EQ("newhostname.example.org", l->hostname_);
- EXPECT_EQ(7654321, l->iaid_);
+ EXPECT_EQ(7654321U, l->iaid_);
EXPECT_FALSE(l->getContext());
}
ASSERT_TRUE(l->duid_);
EXPECT_EQ("88:88:88:88:88:88:88:88", l->duid_->toText());
EXPECT_EQ("newhostname.example.org", l->hostname_);
- EXPECT_EQ(7654321, l->iaid_);
+ EXPECT_EQ(7654321U, l->iaid_);
EXPECT_FALSE(l->getContext());
}
ASSERT_TRUE(l);
// Make sure the subnet-id is figured out correctly.
- EXPECT_EQ(66, l->subnet_id_);
+ EXPECT_EQ(66U, l->subnet_id_);
// Make sure the lease is correct.
ASSERT_TRUE(l->duid_);
EXPECT_EQ("88:88:88:88:88:88:88:88", l->duid_->toText());
EXPECT_EQ("newhostname.example.org", l->hostname_);
- EXPECT_EQ(7654321, l->iaid_);
+ EXPECT_EQ(7654321U, l->iaid_);
EXPECT_FALSE(l->getContext());
}
// Check user context.
ConstElementPtr ctx = l->getContext();
ASSERT_TRUE(ctx);
- EXPECT_EQ(2, ctx->size());
+ EXPECT_EQ(2U, ctx->size());
ASSERT_TRUE(ctx->contains("comment"));
EXPECT_EQ("\"a comment\"", ctx->get("comment")->str());
ASSERT_TRUE(ctx->contains("foobar"));
ASSERT_TRUE(l->duid_);
EXPECT_EQ("88:88:88:88:88:88:88:88", l->duid_->toText());
EXPECT_EQ("newhostname.example.org", l->hostname_);
- EXPECT_EQ(7654321, l->iaid_);
+ EXPECT_EQ(7654321U, l->iaid_);
// Check the user context / extended info too.
ConstElementPtr ctx = l->getContext();
IOAddress::IPV6_ZERO_ADDRESS(),
LeasePageSize(10));
// The lease must be retrieved from the remote id table.
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
Lease6Ptr lx = leases[0];
ASSERT_TRUE(lx);
EXPECT_EQ(IOAddress("2001:db8:1::1"), lx->addr_);
leases = lmptr_->getLeases6ByRelayId(*relay_id,
IOAddress::IPV6_ZERO_ADDRESS(),
LeasePageSize(10));
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
lx = leases[0];
ASSERT_TRUE(lx);
EXPECT_EQ(IOAddress("2001:db8:1::1"), lx->addr_);
ASSERT_TRUE(l->duid_);
EXPECT_EQ("88:88:88:88:88:88:88:88", l->duid_->toText());
EXPECT_EQ("newhostname.example.org", l->hostname_);
- EXPECT_EQ(7654321, l->iaid_);
- EXPECT_EQ(4, l->state_);
- EXPECT_EQ(99, l->subnet_id_);
+ EXPECT_EQ(7654321U, l->iaid_);
+ EXPECT_EQ(4U, l->state_);
+ EXPECT_EQ(99U, l->subnet_id_);
}
void Lease6CmdsTest::testLease6DelMissingParams() {
ASSERT_TRUE(lease1);
// The IAID should have not been updated for the existing lease.
- EXPECT_EQ(42, lease1->iaid_);
+ EXPECT_EQ(42U, lease1->iaid_);
}
void Lease6CmdsTest::testLease6BulkApplyUpdatesOnly() {
ASSERT_TRUE(lease2);
// The IAIDs should have been updated for the existing leases.
- EXPECT_EQ(1234, lease1->iaid_);
- EXPECT_EQ(1234, lease2->iaid_);
+ EXPECT_EQ(1234U, lease1->iaid_);
+ EXPECT_EQ(1234U, lease2->iaid_);
}
void Lease6CmdsTest::testLease6BulkApplyUpdatesOnlyExtendedInfo() {
ASSERT_TRUE(lease2);
// The IAIDs should have been updated for the existing leases.
- EXPECT_EQ(1234, lease1->iaid_);
- EXPECT_EQ(1234, lease2->iaid_);
+ EXPECT_EQ(1234U, lease1->iaid_);
+ EXPECT_EQ(1234U, lease2->iaid_);
// The user context have been updated too.
EXPECT_FALSE(lease1->getContext());
leases = lmptr_->getLeases6ByRemoteId(remote_id,
IOAddress::IPV6_ZERO_ADDRESS(),
LeasePageSize(10));
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
Lease6Ptr lx = leases[0];
ASSERT_TRUE(lx);
EXPECT_EQ(IOAddress("2001:db8:1::2"), lx->addr_);
leases = lmptr_->getLeases6ByRelayId(*relay_id,
IOAddress::IPV6_ZERO_ADDRESS(),
LeasePageSize(10));
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
lx = leases[0];
ASSERT_TRUE(lx);
EXPECT_EQ(IOAddress("2001:db8:1::2"), lx->addr_);
auto failed_deleted_leases = args->get("failed-deleted-leases");
ASSERT_TRUE(failed_deleted_leases);
ASSERT_EQ(Element::list, failed_deleted_leases->getType());
- ASSERT_EQ(2, failed_deleted_leases->size());
+ ASSERT_EQ(2U, failed_deleted_leases->size());
{
SCOPED_TRACE("lease address 2001:db8:1::123");
auto failed_leases = args->get("failed-leases");
ASSERT_TRUE(failed_leases);
ASSERT_EQ(Element::list, failed_leases->getType());
- ASSERT_EQ(1, failed_leases->size());
+ ASSERT_EQ(1U, failed_leases->size());
checkFailedLease(failed_leases, "IA_NA", locked_addr.toText(),
CONTROL_RESULT_CONFLICT,
"ResourceBusy: IP address:2001:db8:2::77 could not be updated.");
cmd_rsp = testCommand(command, CONTROL_RESULT_SUCCESS, "2 pool(s) found.");
pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(2, pool_infos->size());
+ ASSERT_EQ(2U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pools[0], __LINE__);
checkPoolInfos(*(*pool_infos)[1], *test_pools[2], __LINE__);
cmd_rsp = testCommand(command, CONTROL_RESULT_SUCCESS, "1 pool(s) found.");
pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
+ ASSERT_EQ(1U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pools[1], __LINE__);
// Fetch by subnet id for subnet_id = 99
cmd_rsp = testCommand(command, CONTROL_RESULT_EMPTY, "0 pool(s) found.");
pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(0, pool_infos->size());
+ ASSERT_EQ(0U, pool_infos->size());
// Fetch by a range that excludes them all.
pool_infos.reset();
cmd_rsp = testCommand(command, CONTROL_RESULT_EMPTY, "0 pool(s) found.");
pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(0, pool_infos->size());
+ ASSERT_EQ(0U, pool_infos->size());
// Fetch by a range that includes them all.
pool_infos.reset();
pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(3, pool_infos->size());
+ ASSERT_EQ(3U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pools[0], __LINE__);
checkPoolInfos(*(*pool_infos)[1], *test_pools[1], __LINE__);
checkPoolInfos(*(*pool_infos)[2], *test_pools[2], __LINE__);
cmd_rsp = testCommand(command, CONTROL_RESULT_SUCCESS, "1 pool(s) found.");
pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
+ ASSERT_EQ(1U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pool, __LINE__);
}
auto cmd_rsp = testCommand(command, CONTROL_RESULT_EMPTY, "0 pool(s) found.");
auto pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(0, pool_infos->size());
+ ASSERT_EQ(0U, pool_infos->size());
// Create three test pool infos.
SflqPoolInfoCollection test_pools;
cmd_rsp = testCommand(command, CONTROL_RESULT_SUCCESS, "2 pool(s) found.");
pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(2, pool_infos->size());
+ ASSERT_EQ(2U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pools[0], __LINE__);
checkPoolInfos(*(*pool_infos)[1], *test_pools[2], __LINE__);
cmd_rsp = testCommand(command, CONTROL_RESULT_SUCCESS, "1 pool(s) found.");
pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
+ ASSERT_EQ(1U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pools[1], __LINE__);
// Fetch by subnet id for subnet_id = 99
cmd_rsp = testCommand(command, CONTROL_RESULT_EMPTY, "0 pool(s) found.");
pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(0, pool_infos->size());
+ ASSERT_EQ(0U, pool_infos->size());
// Fetch by a range that excludes them all.
pool_infos.reset();
cmd_rsp = testCommand(command, CONTROL_RESULT_EMPTY, "0 pool(s) found.");
pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(0, pool_infos->size());
+ ASSERT_EQ(0U, pool_infos->size());
// Fetch by a range that includes them all.
pool_infos.reset();
cmd_rsp = testCommand(command, CONTROL_RESULT_SUCCESS, "3 pool(s) found.");
pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(3, pool_infos->size());
+ ASSERT_EQ(3U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pools[0], __LINE__);
checkPoolInfos(*(*pool_infos)[1], *test_pools[1], __LINE__);
checkPoolInfos(*(*pool_infos)[2], *test_pools[2], __LINE__);
cmd_rsp = testCommand(command, CONTROL_RESULT_SUCCESS, "1 pool(s) found.");
pool_infos = extractPools(cmd_rsp);
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
+ ASSERT_EQ(1U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pool, __LINE__);
}
BindingVariableListPtr var_list;
ASSERT_NO_THROW_LOG(var_list = cache->getAll());
ASSERT_TRUE(var_list);
- EXPECT_EQ(var_list->size(), 0);
+ EXPECT_EQ(var_list->size(), 0U);
BindingVariablePtr var;
ASSERT_NO_THROW_LOG(var = cache->getByName("foo"));
ASSERT_NO_THROW_LOG(var_list = cache->getBySource(BindingVariable::QUERY));
ASSERT_TRUE(var_list);
- EXPECT_EQ(var_list->size(), 0);
+ EXPECT_EQ(var_list->size(), 0U);
ASSERT_NO_THROW_LOG(var_list = cache->getBySource(BindingVariable::RESPONSE));
ASSERT_TRUE(var_list);
- EXPECT_EQ(var_list->size(), 0);
+ EXPECT_EQ(var_list->size(), 0U);
// Add four variables.
std::string valid_v6_exp = "pkt6.transid";
// Make sure getAll() returns all four in order added.
ASSERT_NO_THROW_LOG(var_list = cache->getAll());
ASSERT_TRUE(var_list);
- EXPECT_EQ(var_list->size(), 4);
+ EXPECT_EQ(var_list->size(), 4U);
auto var_iter = var_list->begin();
for (auto const& ref_iter : ref_list) {
// Make sure getBySource() works for QUERY.
ASSERT_NO_THROW_LOG(var_list = cache->getBySource(BindingVariable::QUERY));
ASSERT_TRUE(var_list);
- ASSERT_EQ(var_list->size(), 2);
+ ASSERT_EQ(var_list->size(), 2U);
var_iter = var_list->begin();
for (auto const& ref_iter : ref_list) {
// Make sure getBySource() works for RESPONSE.
ASSERT_NO_THROW_LOG(var_list = cache->getBySource(BindingVariable::RESPONSE));
ASSERT_TRUE(var_list);
- ASSERT_EQ(var_list->size(), 2);
+ ASSERT_EQ(var_list->size(), 2U);
var_iter = var_list->begin();
for (auto const& ref_iter : ref_list) {
// Sleep 1s so we can check flush time gets updated.
usleep(1000000);
ASSERT_NO_THROW_LOG(cache->clear());
- EXPECT_EQ(cache->size(), 0);
+ EXPECT_EQ(cache->size(), 0U);
EXPECT_GT(cache->getLastFlushTime(), ref_time);
}
bool add_flag;
ASSERT_NO_THROW_LOG(add_flag = cache->add(var1));
EXPECT_TRUE(add_flag);
- EXPECT_EQ(cache->size(), 1);
+ EXPECT_EQ(cache->size(), 1U);
// Make sure getByName returns the added variable.
BindingVariablePtr found_var;
// Adding a duplicate should fail.
ASSERT_NO_THROW_LOG(add_flag = cache->add(var2));
EXPECT_FALSE(add_flag);
- EXPECT_EQ(cache->size(), 1);
+ EXPECT_EQ(cache->size(), 1U);
// Make sure getByName returns the original variable.
ASSERT_NO_THROW_LOG(found_var = cache->getByName("one"));
ASSERT_NO_THROW_LOG(mgr->configure(config));
auto cache = mgr->getCache();
ASSERT_TRUE(cache);
- ASSERT_EQ(cache->size(), 2);
+ ASSERT_EQ(cache->size(), 2U);
ASSERT_TRUE(cache->getByName("one"));
ASSERT_TRUE(cache->getByName("two"));
ASSERT_NO_THROW_LOG(mgr->configure(config));
cache = mgr->getCache();
ASSERT_TRUE(cache);
- ASSERT_EQ(cache->size(), 2);
+ ASSERT_EQ(cache->size(), 2U);
ASSERT_FALSE(cache->getByName("one"));
ASSERT_FALSE(cache->getByName("two"));
ASSERT_TRUE(cache->getByName("three"));
scenario.expected_error_);
auto cache = mgr->getCache();
ASSERT_TRUE(cache);
- EXPECT_EQ(cache->size(), 0);
+ EXPECT_EQ(cache->size(), 0U);
}
}
rejected_counter0_ + 1);
// Only 2 should be usable.
- EXPECT_EQ(2, countUsable());
+ EXPECT_EQ(2U, countUsable());
}
/// @brief Verify that acceptFilter with more than one configured requesters
rejected_counter0_ + 1);
// Only 2 should be usable.
- EXPECT_EQ(2, countUsable());
+ EXPECT_EQ(2U, countUsable());
}
/// @brief Verify that acceptFilter with more than one configured requesters
rejected_counter0_ + 1);
// Clients should be usable.
- EXPECT_EQ(2, countUsable());
+ EXPECT_EQ(2U, countUsable());
// Reduce the number of allowed connections to 2.
blq_srv_->setMaxRequesterConnections(2);
rejected_counter0_ + 1);
// One client should be usable.
- EXPECT_EQ(1, countUsable());
+ EXPECT_EQ(1U, countUsable());
}
} // end of anonymous namespace
rejected_counter0_ + 1);
// Only 2 should be usable.
- EXPECT_EQ(2, countUsable());
+ EXPECT_EQ(2U, countUsable());
}
/// @brief Verify that acceptFilter with more than one configured requesters
rejected_counter0_ + 1);
// Only 2 should be usable.
- EXPECT_EQ(2, countUsable());
+ EXPECT_EQ(2U, countUsable());
}
/// @brief Verify that acceptFilter with more than one configured requesters
rejected_counter0_ + 1);
// Clients should be usable.
- EXPECT_EQ(2, countUsable());
+ EXPECT_EQ(2U, countUsable());
// Reduce the number of allowed connections to 2.
blq_srv_->setMaxRequesterConnections(2);
rejected_counter0_ + 1);
// One client should be usable.
- EXPECT_EQ(1, countUsable());
+ EXPECT_EQ(1U, countUsable());
}
} // end of anonymous namespace
ASSERT_NO_THROW_LOG(impl.reset(new LeaseQueryImpl4(config)));
// Verify known and unknown requesters check correctly.
- EXPECT_EQ(2, impl->getNumRequesters());
+ EXPECT_EQ(2U, impl->getNumRequesters());
EXPECT_FALSE(impl->isRequester(IOAddress("192.0.2.1")));
EXPECT_TRUE(impl->isRequester(IOAddress("127.0.0.1")));
EXPECT_TRUE(impl->isRequester(IOAddress("192.0.2.2")));
EXPECT_FALSE(mgr->getActiveQueryEnabled());
EXPECT_FALSE(mgr->getExtendedInfoTablesEnabled());
EXPECT_EQ(IOAddress("127.0.0.1"), mgr->getLeaseQueryIp());
- EXPECT_EQ(12345, mgr->getLeaseQueryTcpPort());
- EXPECT_EQ(10, mgr->getMaxBulkQueryThreads());
- EXPECT_EQ(10, mgr->getMaxRequesterConnections());
- EXPECT_EQ(5, mgr->getMaxConcurrentQueries());
- EXPECT_EQ(300, mgr->getMaxRequesterIdleTime());
- EXPECT_EQ(100, mgr->getMaxLeasePerFetch());
+ EXPECT_EQ(12345U, mgr->getLeaseQueryTcpPort());
+ EXPECT_EQ(10U, mgr->getMaxBulkQueryThreads());
+ EXPECT_EQ(10U, mgr->getMaxRequesterConnections());
+ EXPECT_EQ(5U, mgr->getMaxConcurrentQueries());
+ EXPECT_EQ(300U, mgr->getMaxRequesterIdleTime());
+ EXPECT_EQ(100U, mgr->getMaxLeasePerFetch());
// Verify setters.
EXPECT_NO_THROW(mgr->setMaxBulkQueryThreads(20));
- EXPECT_EQ(20, mgr->getMaxBulkQueryThreads());
+ EXPECT_EQ(20U, mgr->getMaxBulkQueryThreads());
EXPECT_THROW_MSG(mgr->setMaxRequesterConnections(0), BadValue,
"new max requester connections is 0");
EXPECT_NO_THROW(mgr->setMaxRequesterConnections(20));
- EXPECT_EQ(20, mgr->getMaxRequesterConnections());
+ EXPECT_EQ(20U, mgr->getMaxRequesterConnections());
EXPECT_NO_THROW(mgr->setMaxConcurrentQueries(0));
- EXPECT_EQ(0, mgr->getMaxConcurrentQueries());
+ EXPECT_EQ(0U, mgr->getMaxConcurrentQueries());
EXPECT_THROW_MSG(mgr->setMaxLeasePerFetch(0), BadValue,
"new max leases per fetch is 0");
EXPECT_NO_THROW(mgr->setMaxLeasePerFetch(200));
- EXPECT_EQ(200, mgr->getMaxLeasePerFetch());
+ EXPECT_EQ(200U, mgr->getMaxLeasePerFetch());
// Make sure listener involved functions do not misbehave.
ASSERT_NO_THROW(mgr->startListener());
ASSERT_NO_THROW_LOG(unpackRelayForwardMsg(relay_forw_data, relay_infos));
// We should have one relay.
- EXPECT_EQ(1, relay_infos.size());
+ EXPECT_EQ(1U, relay_infos.size());
// Verify the first instance.
ASSERT_EQ(hop, relay_infos[0]->hop_count_);
ASSERT_NO_THROW_LOG(impl.reset(new LeaseQueryImpl6(config)));
// Verify known and unknown requesters check correctly.
- EXPECT_EQ(2, impl->getNumRequesters());
+ EXPECT_EQ(2U, impl->getNumRequesters());
EXPECT_FALSE(impl->isRequester(IOAddress("2001:db8:1::")));
EXPECT_TRUE(impl->isRequester(IOAddress("2001:db8:1::1")));
EXPECT_FALSE(impl->isRequester(IOAddress("2001:db8:1::2")));
// Verify prefix length list.
PrefixLengthList prefix_lengths;
ASSERT_NO_THROW_LOG(prefix_lengths = impl->getPrefixLengthList());
- EXPECT_EQ(2, prefix_lengths.size());
+ EXPECT_EQ(2U, prefix_lengths.size());
auto it = prefix_lengths.crbegin();
- EXPECT_EQ(*it++, 72);
- EXPECT_EQ(*it, 64);
+ EXPECT_EQ(*it++, 72U);
+ EXPECT_EQ(*it, 64U);
// Verify the advanced config.
auto mgr = BulkLeaseQueryService::instance();
EXPECT_FALSE(mgr->getActiveQueryEnabled());
EXPECT_FALSE(mgr->getExtendedInfoTablesEnabled());
EXPECT_EQ(IOAddress("::1"), mgr->getLeaseQueryIp());
- EXPECT_EQ(12345, mgr->getLeaseQueryTcpPort());
- EXPECT_EQ(10, mgr->getMaxBulkQueryThreads());
- EXPECT_EQ(10, mgr->getMaxRequesterConnections());
- EXPECT_EQ(5, mgr->getMaxConcurrentQueries());
- EXPECT_EQ(300, mgr->getMaxRequesterIdleTime());
- EXPECT_EQ(100, mgr->getMaxLeasePerFetch());
+ EXPECT_EQ(12345U, mgr->getLeaseQueryTcpPort());
+ EXPECT_EQ(10U, mgr->getMaxBulkQueryThreads());
+ EXPECT_EQ(10U, mgr->getMaxRequesterConnections());
+ EXPECT_EQ(5U, mgr->getMaxConcurrentQueries());
+ EXPECT_EQ(300U, mgr->getMaxRequesterIdleTime());
+ EXPECT_EQ(100U, mgr->getMaxLeasePerFetch());
// Verify setters.
EXPECT_NO_THROW(mgr->setMaxBulkQueryThreads(20));
- EXPECT_EQ(20, mgr->getMaxBulkQueryThreads());
+ EXPECT_EQ(20U, mgr->getMaxBulkQueryThreads());
EXPECT_THROW_MSG(mgr->setMaxRequesterConnections(0), BadValue,
"new max requester connections is 0");
EXPECT_NO_THROW(mgr->setMaxRequesterConnections(20));
- EXPECT_EQ(20, mgr->getMaxRequesterConnections());
+ EXPECT_EQ(20U, mgr->getMaxRequesterConnections());
EXPECT_NO_THROW(mgr->setMaxConcurrentQueries(0));
- EXPECT_EQ(0, mgr->getMaxConcurrentQueries());
+ EXPECT_EQ(0U, mgr->getMaxConcurrentQueries());
EXPECT_THROW_MSG(mgr->setMaxLeasePerFetch(0), BadValue,
"new max leases per fetch is 0");
EXPECT_NO_THROW(mgr->setMaxLeasePerFetch(200));
- EXPECT_EQ(200, mgr->getMaxLeasePerFetch());
+ EXPECT_EQ(200U, mgr->getMaxLeasePerFetch());
// Make sure listener involved functions do not misbehave.
ASSERT_NO_THROW(mgr->startListener());
// We should have D6O_CLIENT_DATA option.
OptionCollection options;
verifyClientData(rsp, options);
- EXPECT_EQ(3, options.size());
+ EXPECT_EQ(3U, options.size());
// Verify client id.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(100, options);
+ verifyCLTT(100U, options);
// Now let's check w should have one TYPE_NA lease.
verifyIAADDR(active_lease->addr_, options);
// We should have D6O_CLIENT_DATA option.
OptionCollection options;
verifyClientData(rsp, options);
- EXPECT_EQ(3, options.size());
+ EXPECT_EQ(3U, options.size());
// Verify client id.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(100, options);
+ verifyCLTT(100U, options);
// Now let's check w should have one TYPE_NA lease.
// Most recent lease is lease2.
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(3, options.size());
+ EXPECT_EQ(3U, options.size());
// Verify client id.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(200, options);
+ verifyCLTT(200U, options);
// Now let's check w should have one TYPE_NA lease.
// Second lease is lease3.
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(3, options.size());
+ EXPECT_EQ(3U, options.size());
// Verify client id.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(300, options);
+ verifyCLTT(300U, options);
// Now let's check w should have one TYPE_NA lease.
// Third lease is lease1.
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(3, options.size());
+ EXPECT_EQ(3U, options.size());
// Verify client id.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(400, options);
+ verifyCLTT(400U, options);
// Now let's check w should have one TYPE_PD lease.
verifyIAPREFIX(pd_lease->addr_, options);
// Should have client data option.
OptionCollection options;
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
// Verify client id.
verifyClientId(cid1_, options);
// Verify that CLTT comes from lease2.
- verifyCLTT(100, options);
+ verifyCLTT(100U, options);
// Now let's check we should have one TYPE_NA lease.
auto opt_iter = options.find(D6O_IAADDR);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(3, options.size());
+ EXPECT_EQ(3U, options.size());
// Verify client id.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(200, options);
+ verifyCLTT(200U, options);
// Now let's check we should have one TYPE_PD lease.
opt_iter = options.find(D6O_IAPREFIX);
// We should have D6O_CLIENT_DATA option.
OptionCollection options;
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
if (link_addr.isV6Zero()) {
// First lease is lease2.
verifyClientId(cid2_, options);
// Verify CLTT.
- verifyCLTT(300, options);
+ verifyCLTT(300U, options);
// Verify IAADDR.
verifyIAADDR(lease2->addr_, options);
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(200, options);
+ verifyCLTT(200U, options);
// Verify IAADDR.
verifyIAADDR(lease3->addr_, options);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
if (link_addr.isV6Zero()) {
// Second lease is lease 3.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(200, options);
+ verifyCLTT(200U, options);
// Verify IAADDR.
verifyIAADDR(lease3->addr_, options);
verifyClientId(cid2_, options);
// Verify CLTT.
- verifyCLTT(100, options);
+ verifyCLTT(100U, options);
// Verify IAADDR.
verifyIAADDR(lease4->addr_, options);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
if (link_addr.isV6Zero()) {
// Next lease is lease 4.
verifyClientId(cid2_, options);
// Verify CLTT.
- verifyCLTT(100, options);
+ verifyCLTT(100U, options);
// Verify IAADDR.
verifyIAADDR(lease4->addr_, options);
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(50, options);
+ verifyCLTT(50U, options);
// Verify IAPREFIX.
verifyIAPREFIX(pd_lease->addr_, options);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
if (link_addr.isV6Zero()) {
// Next lease is pd_lease.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(50, options);
+ verifyCLTT(50U, options);
// Verify IAPREFIX.
verifyIAPREFIX(pd_lease->addr_, options);
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(50, options);
+ verifyCLTT(50U, options);
// Verify IAPREFIX.
verifyIAPREFIX(pd_lease2->addr_, options);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
// Last lease is pd lease 2.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(50, options);
+ verifyCLTT(50U, options);
// Verify IAPREFIX.
verifyIAPREFIX(pd_lease2->addr_, options);
// We should have D6O_CLIENT_DATA option.
OptionCollection options;
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
if (link_addr.isV6Zero()) {
// First lease is lease2.
verifyClientId(cid2_, options);
// Verify CLTT.
- verifyCLTT(300, options);
+ verifyCLTT(300U, options);
// Verify IAADDR.
verifyIAADDR(lease2->addr_, options);
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(200, options);
+ verifyCLTT(200U, options);
// Verify IAADDR.
verifyIAADDR(lease3->addr_, options);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
if (link_addr.isV6Zero()) {
// Second lease is lease 3.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(200, options);
+ verifyCLTT(200U, options);
// Verify IAADDR.
verifyIAADDR(lease3->addr_, options);
verifyClientId(cid2_, options);
// Verify CLTT.
- verifyCLTT(100, options);
+ verifyCLTT(100U, options);
// Verify IAADDR.
verifyIAADDR(lease4->addr_, options);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
if (link_addr.isV6Zero()) {
// Next lease is lease 4.
verifyClientId(cid2_, options);
// Verify CLTT.
- verifyCLTT(100, options);
+ verifyCLTT(100U, options);
// Verify IAADDR.
verifyIAADDR(lease4->addr_, options);
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(50, options);
+ verifyCLTT(50U, options);
// Verify IAPREFIX.
verifyIAPREFIX(pd_lease->addr_, options);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
if (link_addr.isV6Zero()) {
// Next lease is pd_lease.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(50, options);
+ verifyCLTT(50U, options);
// Verify IAPREFIX.
verifyIAPREFIX(pd_lease->addr_, options);
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(50, options);
+ verifyCLTT(50U, options);
// Verify IAPREFIX.
verifyIAPREFIX(pd_lease2->addr_, options);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
// Last lease is pd lease 2.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(50, options);
+ verifyCLTT(50U, options);
// Verify IAPREFIX.
verifyIAPREFIX(pd_lease2->addr_, options);
// We should have D6O_CLIENT_DATA option.
OptionCollection options;
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
// First lease is lease 3.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(200, options);
+ verifyCLTT(200U, options);
// Verify IAADDR.
verifyIAADDR(lease3->addr_, options);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(3, options.size());
+ EXPECT_EQ(3U, options.size());
// Second lease is lease 4.
verifyClientId(cid2_, options);
// Verify CLTT.
- verifyCLTT(100, options);
+ verifyCLTT(100U, options);
// Verify IAADDR.
verifyIAADDR(lease4->addr_, options);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
// Third lease is lease 5.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(300, options);
+ verifyCLTT(300U, options);
// Verify IAADDR.
verifyIAADDR(lease5->addr_, options);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
// Forth lease is pd_lease.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(50, options);
+ verifyCLTT(50U, options);
// Verify IAPREFIX.
verifyIAPREFIX(pd_lease->addr_, options);
// We should have D6O_CLIENT_DATA option.
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
// Last lease is pd_lease2,
verifyClientId(cid2_, options);
// Verify CLTT.
- verifyCLTT(50, options);
+ verifyCLTT(50U, options);
// Verify IAPREFIX.
verifyIAPREFIX(pd_lease2->addr_, options);
}
OptionCollection options;
verifyClientData(rsp, options);
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
// Verify CLTT.
- verifyCLTT(100, options);
+ verifyCLTT(100U, options);
switch (i) {
case 0:
// We should have D6O_CLIENT_DATA option.
OptionCollection options;
verifyClientData(rsp, options);
- EXPECT_EQ(3, options.size());
+ EXPECT_EQ(3U, options.size());
// Verify client id.
verifyClientId(cid1_, options);
// Verify CLTT.
- verifyCLTT(100, options);
+ verifyCLTT(100U, options);
// Now let's check we should have one TYPE_NA lease.
verifyIAPREFIX(pd_lease->addr_, options);
void checkStat(const std::string& name, uint64_t exp_value) {
ObservationPtr obs = StatsMgr::instance().getObservation(name);
ASSERT_TRUE(obs) << "no such stat: " << name;
- EXPECT_EQ(exp_value, obs->getInteger().first)
+ EXPECT_EQ(exp_value, static_cast<uint64_t>(obs->getInteger().first))
<< name << " has wrong value ";
}
void checkStat(const std::string& name, uint64_t exp_value) {
ObservationPtr obs = StatsMgr::instance().getObservation(name);
ASSERT_TRUE(obs) << "no such stat: " << name;
- EXPECT_EQ(exp_value, obs->getInteger().first);
+ EXPECT_EQ(exp_value, static_cast<uint64_t>(obs->getInteger().first));
}
/// @brief Callout manager accessed by this CalloutHandle.
// Verify that an empty list in produces an empty list out.
output_leases = LeaseQueryImpl4::winnowLeases(input_leases);
- EXPECT_EQ(0, output_leases.size());
+ EXPECT_EQ(0U, output_leases.size());
// Verify that an list with only inactive leases
// in produces an empty list out.
input_leases.push_back(declined);
input_leases.push_back(reclaimed);
output_leases = LeaseQueryImpl4::winnowLeases(input_leases);
- EXPECT_EQ(0, output_leases.size());
+ EXPECT_EQ(0U, output_leases.size());
// Now let's make sure a mixed list gives us only
// active leases and in the proper order.
IOAddress addr1("192.0.2.101");
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByIpAddress(addr1, leases));
EXPECT_EQ(DHCPLEASEUNASSIGNED, ret_type);
- EXPECT_EQ(0, leases.size());
+ EXPECT_EQ(0U, leases.size());
// Look for an known address with active lease.
// We should return active and the lease in the collection.
Lease4Ptr lease = addLease(addr1, subnet2_, HWAddrPtr(), ClientIdPtr(), time(0));
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByIpAddress(addr1, leases));
EXPECT_EQ(DHCPLEASEACTIVE, ret_type);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_TRUE(*leases[0] == *lease);
// Look for an known address with inactive lease
leases.clear();
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByIpAddress(addr2, leases));
EXPECT_EQ(DHCPLEASEUNASSIGNED, ret_type);
- EXPECT_EQ(0, leases.size());
+ EXPECT_EQ(0U, leases.size());
// Look for an known address with an expired active lease
// We should return unassigned and an empty lease collection
leases.clear();
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByIpAddress(addr2, leases));
EXPECT_EQ(DHCPLEASEUNASSIGNED, ret_type);
- EXPECT_EQ(0, leases.size());
+ EXPECT_EQ(0U, leases.size());
// Look for an out-of-subnet address.
// We should return unknown and an empty collection.
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByIpAddress(IOAddress("192.0.9.101"), leases));
EXPECT_EQ(DHCPLEASEUNKNOWN, ret_type);
- EXPECT_EQ(0, leases.size());
+ EXPECT_EQ(0U, leases.size());
// Look for an in-subnet but out-of-pool address.
// We should return unknown and an empty collection.
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByIpAddress(IOAddress("192.0.3.99"), leases));
EXPECT_EQ(DHCPLEASEUNKNOWN, ret_type);
- EXPECT_EQ(0, leases.size());
+ EXPECT_EQ(0U, leases.size());
}
// Exercises LeaseQueryImpl4::queryByClientId().
// We should return unknown and an empty collection.
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByClientId(cid1_, leases));
EXPECT_EQ(DHCPLEASEUNKNOWN, ret_type);
- EXPECT_EQ(0, leases.size());
+ EXPECT_EQ(0U, leases.size());
// Look for a ClientId with a inactive lease.
// We should return unknown and an empty lease collection.
Lease::STATE_EXPIRED_RECLAIMED);
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByClientId(cid1_, leases));
EXPECT_EQ(DHCPLEASEUNKNOWN, ret_type);
- EXPECT_EQ(0, leases.size());
+ EXPECT_EQ(0U, leases.size());
// Look for a ClientId with an active lease.
// We should return active with the lease in the collection.
Lease4Ptr lease2 = addLease(addr2, subnet2_, HWAddrPtr(), cid1_, time(0) - 50);
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByClientId(cid1_, leases));
EXPECT_EQ(DHCPLEASEACTIVE, ret_type);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_TRUE(*leases[0] == *lease2);
// Look for a ClientId with more than one active lease.
Lease4Ptr lease3 = addLease(addr3, subnet3_, HWAddrPtr(), cid1_, time(0) - 100);
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByClientId(cid1_, leases));
EXPECT_EQ(DHCPLEASEACTIVE, ret_type);
- ASSERT_EQ(2, leases.size());
+ ASSERT_EQ(2U, leases.size());
EXPECT_TRUE(*leases[0] == *lease2);
EXPECT_TRUE(*leases[1] == *lease3);
}
// We should return unknown and an empty collection.
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByHWAddr(hwaddr1_, leases));
EXPECT_EQ(DHCPLEASEUNKNOWN, ret_type);
- EXPECT_EQ(0, leases.size());
+ EXPECT_EQ(0U, leases.size());
// Look for a HWAddress with a inactive lease.
// We should return unknown and an empty lease collection.
Lease::STATE_EXPIRED_RECLAIMED);
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByHWAddr(hwaddr1_, leases));
EXPECT_EQ(DHCPLEASEUNKNOWN, ret_type);
- EXPECT_EQ(0, leases.size());
+ EXPECT_EQ(0U, leases.size());
// Look for a HWAddress with an active lease.
// We should return active with the lease in the collection.
Lease4Ptr lease2 = addLease(addr2, subnet2_, hwaddr1_, ClientIdPtr(), time(0) - 50);
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByHWAddr(hwaddr1_, leases));
EXPECT_EQ(DHCPLEASEACTIVE, ret_type);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_TRUE(*leases[0] == *lease2);
// Look for a HWAddress with more than one active lease.
Lease4Ptr lease3 = addLease(addr3, subnet3_, hwaddr1_, ClientIdPtr(), time(0) - 100);
ASSERT_NO_THROW_LOG(ret_type = LeaseQueryImpl4::queryByHWAddr(hwaddr1_, leases));
EXPECT_EQ(DHCPLEASEACTIVE, ret_type);
- ASSERT_EQ(2, leases.size());
+ ASSERT_EQ(2U, leases.size());
EXPECT_TRUE(*leases[0] == *lease2);
EXPECT_TRUE(*leases[1] == *lease3);
}
EXPECT_EQ(DHCPLEASEACTIVE, ret_type);
// We should have found three leases. Lease2 should be first in the list.
- ASSERT_EQ(3, leases.size());
+ ASSERT_EQ(3U, leases.size());
ASSERT_EQ(lease2->addr_, leases[0]->addr_);
// Build a response for DHCPLEASEACTIVE.
// in that order. Note subnet3_ should only be in the list once
// despite they're being two of its leases in the collection.
Option6AddrLst::AddressContainer links = link_opt->getAddresses();
- ASSERT_EQ(3, links.size());
+ ASSERT_EQ(3U, links.size());
EXPECT_EQ(subnet2_->get().first, links[0]);
EXPECT_EQ(subnet3_->get().first, links[1]);
EXPECT_EQ(subnet4_->get().first, links[2]);
ASSERT_TRUE(data_option);
auto options = data_option->getOptions();
- EXPECT_EQ(8, options.size());
+ EXPECT_EQ(8U, options.size());
// Verify client id.
auto opt_iter = options.find(D6O_CLIENTID);
ASSERT_TRUE(relay_info);
// Make sure the field contents are correct.
- ASSERT_EQ(relay_info->hop_count_, 1);
+ ASSERT_EQ(relay_info->hop_count_, 1U);
ASSERT_EQ(relay_info->peeraddr_, IOAddress("2001:db8:1::1"));
ASSERT_EQ(relay_info->linkaddr_, IOAddress("2001:db8:1::2"));
// Make sure there are no options.
- ASSERT_EQ(0, relay_info->options_.size());
+ ASSERT_EQ(0U, relay_info->options_.size());
// Now Add a valid options member: D6O_INTERFACE_ID = "eth0"
relay_elem->set("options", Element::create("0x0012000465746830"));
ASSERT_TRUE(relay_info);
// Make sure the field contents are correct.
- ASSERT_EQ(relay_info->hop_count_, 1);
+ ASSERT_EQ(relay_info->hop_count_, 1U);
ASSERT_EQ(relay_info->peeraddr_, IOAddress("2001:db8:1::1"));
ASSERT_EQ(relay_info->linkaddr_, IOAddress("2001:db8:1::2"));
// Under the covers this relies on LibDHCP::unpackOptions6()
// which is tested pretty exhaustively elsewhere, so we're not
// going to go nuts with testing here.
- ASSERT_EQ(1, relay_info->options_.size());
+ ASSERT_EQ(1U, relay_info->options_.size());
auto x = relay_info->options_.find(0x12);
ASSERT_TRUE(x != relay_info->options_.end());
ASSERT_EQ(std::string("type=00018, len=00004: 65:74:68:30 'eth0'"), x->second->toString());
ASSERT_NO_THROW_LOG(LeaseQueryImpl6::parseRelayInfoList(relay_list, relay_infos));
// We should have three instances.
- ASSERT_EQ(3, relay_infos.size());
+ ASSERT_EQ(3U, relay_infos.size());
// Verify the first instance.
// Make sure the field contents are correct.
- ASSERT_EQ(relay_infos[0]->hop_count_, 3);
+ ASSERT_EQ(relay_infos[0]->hop_count_, 3U);
ASSERT_EQ(relay_infos[0]->peeraddr_, IOAddress("2001:db8:3::1"));
ASSERT_EQ(relay_infos[0]->linkaddr_, IOAddress("2001:db8:3::2"));
// It should have no options.
- ASSERT_EQ(0, relay_infos[0]->options_.size());
+ ASSERT_EQ(0U, relay_infos[0]->options_.size());
// Verify the second instance.
- ASSERT_EQ(relay_infos[1]->hop_count_, 2);
+ ASSERT_EQ(relay_infos[1]->hop_count_, 2U);
ASSERT_EQ(relay_infos[1]->peeraddr_, IOAddress("2001:db8:2::1"));
ASSERT_EQ(relay_infos[1]->linkaddr_, IOAddress("2001:db8:2::2"));
// It should have one option.
- ASSERT_EQ(1, relay_infos[1]->options_.size());
+ ASSERT_EQ(1U, relay_infos[1]->options_.size());
auto x = relay_infos[1]->options_.find(0x12);
ASSERT_TRUE(x != relay_infos[1]->options_.end());
ASSERT_EQ(std::string("type=00018, len=00004: 65:74:68:30 'eth0'"), x->second->toString());
// Verify the third instance.
- ASSERT_EQ(relay_infos[2]->hop_count_, 1);
+ ASSERT_EQ(relay_infos[2]->hop_count_, 1U);
ASSERT_EQ(relay_infos[2]->peeraddr_, IOAddress("2001:db8:1::1"));
ASSERT_EQ(relay_infos[2]->linkaddr_, IOAddress("2001:db8:1::2"));
// We should have two options, "foo" and then "bar"
- ASSERT_EQ(2, relay_infos[2]->options_.size());
+ ASSERT_EQ(2U, relay_infos[2]->options_.size());
// Option "foo"
x = relay_infos[2]->options_.find(0x1FF);
ASSERT_NO_THROW_LOG(unpackRelayForwardMsg(relay_forw_data, relay_infos));
// We should have two relays.
- EXPECT_EQ(2, relay_infos.size());
+ EXPECT_EQ(2U, relay_infos.size());
// Verify the first instance.
// Make sure the field contents are correct.
- ASSERT_EQ(relay_infos[0]->hop_count_, 1);
+ ASSERT_EQ(relay_infos[0]->hop_count_, 1U);
ASSERT_EQ(relay_infos[0]->peeraddr_, IOAddress("2001:db8:2::1"));
ASSERT_EQ(relay_infos[0]->linkaddr_, IOAddress("2001:db8:2::2"));
// It should have one option.
- ASSERT_EQ(1, relay_infos[0]->options_.size());
+ ASSERT_EQ(1U, relay_infos[0]->options_.size());
auto x = relay_infos[0]->options_.find(0x12);
ASSERT_TRUE(x != relay_infos[0]->options_.end());
ASSERT_EQ(std::string("type=00018, len=00004: 65:74:68:30 'eth0'"), x->second->toString());
// Verify the second instance.
- ASSERT_EQ(relay_infos[1]->hop_count_, 0);
+ ASSERT_EQ(relay_infos[1]->hop_count_, 0U);
ASSERT_EQ(relay_infos[1]->peeraddr_, IOAddress("2001:db8:1::1"));
ASSERT_EQ(relay_infos[1]->linkaddr_, IOAddress("2001:db8:1::2"));
// It should have no options.
- ASSERT_EQ(0, relay_infos[1]->options_.size());
+ ASSERT_EQ(0U, relay_infos[1]->options_.size());
}
TEST_F(MemfileLeaseQueryImpl6ProcessTest, makeRelayOptionRelayInfo) {
ASSERT_NO_THROW_LOG(unpackRelayForwardMsg(relay_forw_data, relay_infos));
// We should have two relays.
- EXPECT_EQ(2, relay_infos.size());
+ EXPECT_EQ(2U, relay_infos.size());
// Verify the first instance.
// Make sure the field contents are correct.
- ASSERT_EQ(relay_infos[0]->hop_count_, 1);
+ ASSERT_EQ(relay_infos[0]->hop_count_, 1U);
ASSERT_EQ(relay_infos[0]->peeraddr_, IOAddress("2001:db8:2::1"));
ASSERT_EQ(relay_infos[0]->linkaddr_, IOAddress("2001:db8:2::2"));
// It should have one option.
- ASSERT_EQ(1, relay_infos[0]->options_.size());
+ ASSERT_EQ(1U, relay_infos[0]->options_.size());
auto x = relay_infos[0]->options_.find(0x12);
ASSERT_TRUE(x != relay_infos[0]->options_.end());
ASSERT_EQ(std::string("type=00018, len=00004: 65:74:68:30 'eth0'"), x->second->toString());
// Verify the second instance.
- ASSERT_EQ(relay_infos[1]->hop_count_, 0);
+ ASSERT_EQ(relay_infos[1]->hop_count_, 0U);
ASSERT_EQ(relay_infos[1]->peeraddr_, IOAddress("2001:db8:1::1"));
ASSERT_EQ(relay_infos[1]->linkaddr_, IOAddress("2001:db8:1::2"));
// It should have no options.
- ASSERT_EQ(0, relay_infos[1]->options_.size());
+ ASSERT_EQ(0U, relay_infos[1]->options_.size());
}
TEST_F(MemfileLeaseQueryImpl6ProcessTest, oldMakeRelayOptionRelayInfo) {
ASSERT_TRUE(data_option);
auto options = data_option->getOptions();
- EXPECT_EQ(3, options.size());
+ EXPECT_EQ(3U, options.size());
// Verify client id.
auto opt_iter = options.find(D6O_CLIENTID);
// We should have the addresses for subnet2_, subnet3_, and subnet4_
// in that order.
Option6AddrLst::AddressContainer links = link_opt->getAddresses();
- ASSERT_EQ(3, links.size());
+ ASSERT_EQ(3U, links.size());
EXPECT_EQ(subnet2_->get().first, links[0]);
EXPECT_EQ(subnet3_->get().first, links[1]);
EXPECT_EQ(subnet4_->get().first, links[2]);
// Client data option should have four sub options.
auto options = data_option->getOptions();
- EXPECT_EQ(4, options.size());
+ EXPECT_EQ(4U, options.size());
// Verify client id.
auto opt_iter = options.find(D6O_CLIENTID);
ASSERT_NO_THROW_LOG(unpackRelayForwardMsg(relay_forw_data, relay_infos));
// We should have two relays.
- EXPECT_EQ(1, relay_infos.size());
+ EXPECT_EQ(1U, relay_infos.size());
// Verify the first instance.
// Make sure the field contents are correct.
- ASSERT_EQ(relay_infos[0]->hop_count_, 1);
+ ASSERT_EQ(relay_infos[0]->hop_count_, 1U);
ASSERT_EQ(relay_infos[0]->peeraddr_, IOAddress("2001:db8:2::1"));
ASSERT_EQ(relay_infos[0]->linkaddr_, IOAddress("2001:db8:2::2"));
// It should have one option.
- ASSERT_EQ(1, relay_infos[0]->options_.size());
+ ASSERT_EQ(1U, relay_infos[0]->options_.size());
auto x = relay_infos[0]->options_.find(0x12);
ASSERT_TRUE(x != relay_infos[0]->options_.end());
ASSERT_EQ(std::string("type=00018, len=00004: 65:74:68:30 'eth0'"), x->second->toString());
leases.clear();
ASSERT_NO_THROW_LOG(status = impl->queryByClientId(cid1_, IOAddress("3001::"), leases));
checkStatus(status, STATUS_NotConfigured, "not a configured link");
- ASSERT_EQ(0, leases.size());
+ ASSERT_EQ(0U, leases.size());
// With no link address filter. We should get all three cid1_ leases
// ordered by CLTT : lease2, lease4, lease1
ASSERT_NO_THROW_LOG(status = impl->queryByClientId(cid1_, IOAddress("::"), leases));
checkStatus(status, STATUS_Success, "active lease(s) found");
- ASSERT_EQ(3, leases.size());
+ ASSERT_EQ(3U, leases.size());
EXPECT_EQ(lease2->addr_, leases[0]->addr_);
EXPECT_EQ(lease4->addr_, leases[1]->addr_);
EXPECT_EQ(lease1->addr_, leases[2]->addr_);
leases.clear();
ASSERT_NO_THROW_LOG(status = impl->queryByClientId(cid1_, IOAddress("2001:db8:4::"), leases));
checkStatus(status, STATUS_Success, "active lease(s) found");
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_EQ(lease4->addr_, leases[0]->addr_);
// With link address filter = subnet3, we should no active lease for cid1_.
leases.clear();
ASSERT_NO_THROW_LOG(status = impl->queryByClientId(cid1_, IOAddress("2001:db8:3::"), leases));
- ASSERT_EQ(0, leases.size());
+ ASSERT_EQ(0U, leases.size());
checkStatus(status, STATUS_Success, "no active leases");
// With link address filter = subnet3, we should get one active lease for cid2_.
leases.clear();
ASSERT_NO_THROW_LOG(status = impl->queryByClientId(cid2_, IOAddress("2001:db8:3::"), leases));
checkStatus(status, STATUS_Success, "active lease(s) found");
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_EQ(lease3->addr_, leases[0]->addr_);
}
ASSERT_TRUE(data_option);
auto options = data_option->getOptions();
- EXPECT_EQ(3, options.size());
+ EXPECT_EQ(3U, options.size());
// Now let's check we should have one TYPE_PD lease.
auto opt_iter = options.find(D6O_IAPREFIX);
// Create an empty list.
XidQueue<TestQuery> queries;
- ASSERT_EQ(0, queries.size());
+ ASSERT_EQ(0U, queries.size());
// Add a query to the list.
ASSERT_NO_THROW(queries.add(query1));
- EXPECT_EQ(1, queries.size());
+ EXPECT_EQ(1U, queries.size());
TestQueryPtr query;
// Verify we can find the query.
// Add a second one.
ASSERT_NO_THROW(queries.add(query2));
- EXPECT_EQ(2, queries.size());
+ EXPECT_EQ(2U, queries.size());
// Verify we can find it.
ASSERT_NO_THROW(query = queries.find(query2->getXid()));
// Add another one.
ASSERT_NO_THROW(queries.add(query3));
- EXPECT_EQ(3, queries.size());
+ EXPECT_EQ(3U, queries.size());
// Verify we can find the last one.
ASSERT_NO_THROW(query = queries.find(query3->getXid()));
// Remove one.
ASSERT_NO_THROW(queries.remove(query2->getXid()));
- EXPECT_EQ(2, queries.size());
+ EXPECT_EQ(2U, queries.size());
// Verify it's gone.
ASSERT_NO_THROW(query = queries.find(query2->getXid()));
ASSERT_NO_THROW(query = queries.pop());
ASSERT_TRUE(query);
EXPECT_EQ(query, query1);
- EXPECT_EQ(1, queries.size());
+ EXPECT_EQ(1U, queries.size());
// Clear the list.
ASSERT_NO_THROW(queries.clear());
- EXPECT_EQ(0, queries.size());
+ EXPECT_EQ(0U, queries.size());
}
/// @brief Test fixture class for @ref LeaseQueryListener. It exercises
ASSERT_NO_THROW(startRequest(request));
ASSERT_NO_THROW(runIOService());
- ASSERT_EQ(1, clients_.size());
+ ASSERT_EQ(1U, clients_.size());
LeaseQueryTestClientPtr client = *clients_.begin();
ASSERT_TRUE(client);
EXPECT_TRUE(client->receiveDone());
ASSERT_EQ(SERVER_ADDRESS, listener->getLocalAddress().toText());
ASSERT_EQ(SERVER_PORT, listener->getLocalPort());
ASSERT_NO_THROW(connectClient());
- ASSERT_EQ(1, clients_.size());
+ ASSERT_EQ(1U, clients_.size());
LeaseQueryTestClientPtr client = *clients_.begin();
ASSERT_TRUE(client);
ASSERT_NO_THROW(startRequests(requests));
ASSERT_NO_THROW(runIOService());
- ASSERT_EQ(1, clients_.size());
+ ASSERT_EQ(1U, clients_.size());
LeaseQueryTestClientPtr client = *clients_.begin();
ASSERT_TRUE(client);
EXPECT_TRUE(client->receiveDone());
// These clients should have been accepted and received responses.
EXPECT_TRUE(client->receiveDone());
EXPECT_FALSE(client->expectedEof());
- EXPECT_EQ(1, client->getResponses().size());
+ EXPECT_EQ(1U, client->getResponses().size());
client->checkResponses();
} else {
// These clients should have been rejected and gotten EOF'd.
EXPECT_FALSE(client->receiveDone());
EXPECT_TRUE(client->expectedEof());
- EXPECT_EQ(0, client->getResponses().size());
+ EXPECT_EQ(0U, client->getResponses().size());
}
++i;
// Create an empty list.
XidQueue<TestQuery> queries;
- ASSERT_EQ(0, queries.size());
+ ASSERT_EQ(0U, queries.size());
// Add a query to the list.
ASSERT_NO_THROW(queries.add(query1));
- EXPECT_EQ(1, queries.size());
+ EXPECT_EQ(1U, queries.size());
TestQueryPtr query;
// Verify we can find the query.
// Add a second one.
ASSERT_NO_THROW(queries.add(query2));
- EXPECT_EQ(2, queries.size());
+ EXPECT_EQ(2U, queries.size());
// Verify we can find it.
ASSERT_NO_THROW(query = queries.find(query2->getXid()));
// Add another one.
ASSERT_NO_THROW(queries.add(query3));
- EXPECT_EQ(3, queries.size());
+ EXPECT_EQ(3U, queries.size());
// Verify we can find the last one.
ASSERT_NO_THROW(query = queries.find(query3->getXid()));
// Remove one.
ASSERT_NO_THROW(queries.remove(query2->getXid()));
- EXPECT_EQ(2, queries.size());
+ EXPECT_EQ(2U, queries.size());
// Verify it's gone.
ASSERT_NO_THROW(query = queries.find(query2->getXid()));
ASSERT_NO_THROW(query = queries.pop());
ASSERT_TRUE(query);
EXPECT_EQ(query, query1);
- EXPECT_EQ(1, queries.size());
+ EXPECT_EQ(1U, queries.size());
// Clear the list.
ASSERT_NO_THROW(queries.clear());
- EXPECT_EQ(0, queries.size());
+ EXPECT_EQ(0U, queries.size());
}
/// @brief Test fixture class for @ref LeaseQueryListener. It exercises
ASSERT_NO_THROW(startRequest(request));
ASSERT_NO_THROW(runIOService());
- ASSERT_EQ(1, clients_.size());
+ ASSERT_EQ(1U, clients_.size());
LeaseQueryTestClientPtr client = *clients_.begin();
ASSERT_TRUE(client);
EXPECT_TRUE(client->receiveDone());
ASSERT_EQ(SERVER_ADDRESS, listener->getLocalAddress().toText());
ASSERT_EQ(SERVER_PORT, listener->getLocalPort());
ASSERT_NO_THROW(connectClient());
- ASSERT_EQ(1, clients_.size());
+ ASSERT_EQ(1U, clients_.size());
LeaseQueryTestClientPtr client = *clients_.begin();
ASSERT_TRUE(client);
ASSERT_NO_THROW(startRequests(requests));
ASSERT_NO_THROW(runIOService());
- ASSERT_EQ(1, clients_.size());
+ ASSERT_EQ(1U, clients_.size());
LeaseQueryTestClientPtr client = *clients_.begin();
ASSERT_TRUE(client);
EXPECT_TRUE(client->receiveDone());
// These clients should have been accepted and received responses.
EXPECT_TRUE(client->receiveDone());
EXPECT_FALSE(client->expectedEof());
- EXPECT_EQ(1, client->getResponses().size());
+ EXPECT_EQ(1U, client->getResponses().size());
client->checkResponses();
} else {
// These clients should have been rejected and gotten EOF'd.
EXPECT_FALSE(client->receiveDone());
EXPECT_TRUE(client->expectedEof());
- EXPECT_EQ(0, client->getResponses().size());
+ EXPECT_EQ(0U, client->getResponses().size());
}
++i;
// We should have had the expected number of pauses.
if (!num_pauses) {
- ASSERT_EQ(pause_cnt_, 0);
+ ASSERT_EQ(pause_cnt_, 0U);
} else {
// We allow a range on pauses of +-1.
ASSERT_TRUE((num_pauses - 1) <= pause_cnt_ &&
/// @brief Number of times client has been paused during the test.
size_t pause_cnt_;
-
- /// @brief Number of clients that have completed their assignment or
- /// failed
- size_t clients_done_;
};
/// Verifies the construction, starting, stopping, pausing, resuming,
// We should have had the expected number of pauses.
if (!num_pauses) {
- ASSERT_EQ(pause_cnt_, 0);
+ ASSERT_EQ(pause_cnt_, 0U);
} else {
// We allow a range on pauses of +-1.
ASSERT_TRUE((num_pauses - 1) <= pause_cnt_ &&
/// @brief Number of times client has been paused during the test.
size_t pause_cnt_;
- /// @brief Number of clients that have completed their assignment or
- /// failed
- size_t clients_done_;
-
/// @brief Convenience values.</font>
DuidPtr server_id_;
};
ASSERT_FALSE(binding->amNull());
ASSERT_EQ(MYSQL_TYPE_LONG, binding->getType());
// Check that the correct value was stored in the binding.
- EXPECT_EQ(123, binding->getInteger<uint32_t>());
+ EXPECT_EQ(123U, binding->getInteger<uint32_t>());
}
// Test that the triplet can be created from the MySQL binding.
// The triplet should be specified and equal to the value stored in the
// binding.
ASSERT_FALSE(triplet.unspecified());
- EXPECT_EQ(234, triplet.get());
+ EXPECT_EQ(234U, triplet.get());
// Create a null binding and then use it to create a triplet.
binding = MySqlBinding::createNull();
vector<string> output;
EXPECT_TRUE(getOutput(output));
ASSERT_FALSE(output.empty());
- EXPECT_EQ(1, output.size());
+ EXPECT_EQ(1U, output.size());
ostringstream s;
s << version.first << "\t" << version.second;
EXPECT_EQ(s.str(), output[0]);
io_service_->poll();
// Our lost and recovered connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(1, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(1U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_TRUE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost and recovered connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(1, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(1U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
io_service_->poll();
// Our lost and recovered connectivity callback should have been invoked.
- EXPECT_EQ(2, db_lost_callback_called_);
- EXPECT_EQ(1, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(2U, db_lost_callback_called_);
+ EXPECT_EQ(1U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_TRUE(LegalLogMgrFactory::instance());
io_service_->poll();
// No callback should have been invoked.
- EXPECT_EQ(2, db_lost_callback_called_);
- EXPECT_EQ(1, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(2U, db_lost_callback_called_);
+ EXPECT_EQ(1U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_TRUE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
io_service_->poll();
// Our lost connectivity callback should have been invoked.
- EXPECT_EQ(2, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(2U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
io_service_->poll();
// Our lost and failed connectivity callback should have been invoked.
- EXPECT_EQ(3, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(1, db_failed_callback_called_);
+ EXPECT_EQ(3U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(1U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
}
io_service_->poll();
- EXPECT_EQ(0, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(0U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost and recovered connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(1, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(1U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_TRUE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost and failed connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(1, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(1U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
io_service_->poll();
// Our lost and recovered connectivity callback should have been invoked.
- EXPECT_EQ(2, db_lost_callback_called_);
- EXPECT_EQ(1, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(2U, db_lost_callback_called_);
+ EXPECT_EQ(1U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_TRUE(LegalLogMgrFactory::instance());
io_service_->poll();
// No callback should have been invoked.
- EXPECT_EQ(2, db_lost_callback_called_);
- EXPECT_EQ(1, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(2U, db_lost_callback_called_);
+ EXPECT_EQ(1U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_TRUE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
io_service_->poll();
// Our lost connectivity callback should have been invoked.
- EXPECT_EQ(2, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(2U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
io_service_->poll();
// Our lost and failed connectivity callback should have been invoked.
- EXPECT_EQ(3, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(1, db_failed_callback_called_);
+ EXPECT_EQ(3U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(1U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
}
MySqlConnection::convertToDatabaseTime(cltt, valid_lft, mysql_expire);
// Are the times the same?
- EXPECT_EQ(tm_expire.tm_year + 1900, mysql_expire.year);
- EXPECT_EQ(tm_expire.tm_mon + 1, mysql_expire.month);
- EXPECT_EQ(tm_expire.tm_mday, mysql_expire.day);
- EXPECT_EQ(tm_expire.tm_hour, mysql_expire.hour);
- EXPECT_EQ(tm_expire.tm_min, mysql_expire.minute);
- EXPECT_EQ(tm_expire.tm_sec, mysql_expire.second);
- EXPECT_EQ(0, mysql_expire.second_part);
+ EXPECT_EQ(tm_expire.tm_year + 1900,
+ static_cast<int>(mysql_expire.year));
+ EXPECT_EQ(tm_expire.tm_mon + 1,
+ static_cast<int>(mysql_expire.month));
+ EXPECT_EQ(tm_expire.tm_mday,
+ static_cast<int>(mysql_expire.day));
+ EXPECT_EQ(tm_expire.tm_hour,
+ static_cast<int>(mysql_expire.hour));
+ EXPECT_EQ(tm_expire.tm_min,
+ static_cast<int>(mysql_expire.minute));
+ EXPECT_EQ(tm_expire.tm_sec,
+ static_cast<int>(mysql_expire.second));
+ EXPECT_EQ(0U, mysql_expire.second_part);
EXPECT_EQ(0, mysql_expire.neg);
// Convert back
MySqlConnection::convertToDatabaseTime(cltt, valid_lft, mysql_expire);
// Are the times the same?
- EXPECT_EQ(tm_expire.tm_year + 1900, mysql_expire.year);
- EXPECT_EQ(tm_expire.tm_mon + 1, mysql_expire.month);
- EXPECT_EQ(tm_expire.tm_mday, mysql_expire.day);
- EXPECT_EQ(tm_expire.tm_hour, mysql_expire.hour);
- EXPECT_EQ(tm_expire.tm_min, mysql_expire.minute);
- EXPECT_EQ(tm_expire.tm_sec, mysql_expire.second);
- EXPECT_EQ(0, mysql_expire.second_part);
+ EXPECT_EQ(tm_expire.tm_year + 1900,
+ static_cast<int>(mysql_expire.year));
+ EXPECT_EQ(tm_expire.tm_mon + 1,
+ static_cast<int>(mysql_expire.month));
+ EXPECT_EQ(tm_expire.tm_mday,
+ static_cast<int>(mysql_expire.day));
+ EXPECT_EQ(tm_expire.tm_hour,
+ static_cast<int>(mysql_expire.hour));
+ EXPECT_EQ(tm_expire.tm_min,
+ static_cast<int>(mysql_expire.minute));
+ EXPECT_EQ(tm_expire.tm_sec,
+ static_cast<int>(mysql_expire.second));
+ EXPECT_EQ(0U, mysql_expire.second_part);
EXPECT_EQ(0, mysql_expire.neg);
// Convert back
// Check that the countRows is working. It's used extensively in other
// tests, so basic check is enough here.
- EXPECT_EQ(0, countRows(conn, "lease4"));
+ EXPECT_EQ(0U, countRows(conn, "lease4"));
}
// Verifies that v4 class lease counts are correctly adjusted
// Verify we added three of them.
auto alarms = store.getAll();
- ASSERT_EQ(alarms->size(), 3);
+ ASSERT_EQ(alarms->size(), 3U);
// Fetch the second alarm.
AlarmPtr alarm;
// Verify there are two left.
alarms = store.getAll();
- ASSERT_EQ(alarms->size(), 2);
+ ASSERT_EQ(alarms->size(), 2U);
}
/// @brief Verify an invalid alarm key on delete is detected.
EXPECT_EQ(alarm->getResponseType(), DHCPV6_ADVERTISE);
EXPECT_EQ(alarm->getStartEventLabel(), "mt_queued");
EXPECT_EQ(alarm->getStopEventLabel(), "process_started");
- EXPECT_EQ(alarm->getSubnetId(), 77);
+ EXPECT_EQ(alarm->getSubnetId(), 77U);
EXPECT_EQ("SOLICIT-ADVERTISE.mt_queued-process_started.77", alarm->getLabel());
EXPECT_EQ(alarm->getLowWater(), low_water);
EXPECT_EQ(alarm->getHighWater(), high_water);
// Verify we added three of them.
auto durations = store.getAll();
- ASSERT_EQ(durations->size(), 3);
+ ASSERT_EQ(durations->size(), 3U);
// Fetch the second duration.
MonitoredDurationPtr mond;
// Verify there are two left.
durations = store.getAll();
- ASSERT_EQ(durations->size(), 2);
+ ASSERT_EQ(durations->size(), 2U);
}
/// @brief Verify an invalid duration key on delete is detected.
DurationDataIntervalPtr current;
ASSERT_TRUE(current = found->getCurrentInterval());
ASSERT_NE(current, mond->getCurrentInterval());
- EXPECT_EQ(current->getOccurrences(), 1);
+ EXPECT_EQ(current->getOccurrences(), 1U);
EXPECT_EQ(current->getTotalDuration(), milliseconds(75));
}
ASSERT_TRUE(mond);
auto current_interval = mond->getCurrentInterval();
ASSERT_TRUE(current_interval);
- EXPECT_EQ(current_interval->getOccurrences(), 1);
+ EXPECT_EQ(current_interval->getOccurrences(), 1U);
EXPECT_EQ(current_interval->getTotalDuration(), (five_ms));
auto previous_interval = mond->getPreviousInterval();
ASSERT_FALSE(previous_interval);
ASSERT_TRUE(mond);
current_interval = mond->getCurrentInterval();
ASSERT_TRUE(current_interval);
- EXPECT_EQ(current_interval->getOccurrences(), 2);
+ EXPECT_EQ(current_interval->getOccurrences(), 2U);
EXPECT_EQ(current_interval->getTotalDuration(), (five_ms * 2));
previous_interval = mond->getPreviousInterval();
ASSERT_FALSE(previous_interval);
// Make sure the duration's current interval and prevous intervals correct.
current_interval = mond->getCurrentInterval();
ASSERT_TRUE(current_interval);
- EXPECT_EQ(current_interval->getOccurrences(), 1);
+ EXPECT_EQ(current_interval->getOccurrences(), 1U);
EXPECT_EQ(current_interval->getTotalDuration(), (five_ms));
previous_interval = mond->getPreviousInterval();
ASSERT_TRUE(previous_interval);
- EXPECT_EQ(previous_interval->getOccurrences(), 2);
+ EXPECT_EQ(previous_interval->getOccurrences(), 2U);
EXPECT_EQ(previous_interval->getTotalDuration(), (five_ms) * 2);
}
// Key[3] and key[2] should be returned by getOverdueReports().
ASSERT_NO_THROW_LOG(durations = store.getOverdueReports());
ASSERT_TRUE(durations);
- EXPECT_EQ(durations->size(), 2);
+ EXPECT_EQ(durations->size(), 2U);
EXPECT_EQ(*(*durations)[0], *keys[3]);
EXPECT_EQ(*(*durations)[1], *keys[2]);
auto add_samples_time = PktEvent::now();
- EXPECT_GT(report_count, 0);
+ EXPECT_GT(report_count, 0U);
auto durations = store.getAll();
EXPECT_EQ(durations->size(), num_subnets);
// Get all should retrieve all four in ascending order.
MonitoredDurationCollectionPtr durations = store.getAll();
- ASSERT_EQ(durations->size(), 2);
+ ASSERT_EQ(durations->size(), 2U);
auto mond = (*durations)[0];
ASSERT_EQ(*key2, *mond);
// Verify contents.
// Start time is set to current time by default.
EXPECT_GE(interval->getStartTime(), start_time);
- EXPECT_EQ(interval->getOccurrences(), 0);
+ EXPECT_EQ(interval->getOccurrences(), 0U);
EXPECT_EQ(interval->getMinDuration(), pos_infin);
EXPECT_EQ(interval->getMaxDuration(), neg_infin);
EXPECT_EQ(interval->getTotalDuration(), DurationDataInterval::ZERO_DURATION());
// Add 100ms duration and check contents.
Duration d100(milliseconds(100));
interval->addDuration(d100);
- EXPECT_EQ(interval->getOccurrences(), 1);
+ EXPECT_EQ(interval->getOccurrences(), 1U);
EXPECT_EQ(interval->getMinDuration(), d100);
EXPECT_EQ(interval->getMaxDuration(), d100);
EXPECT_EQ(interval->getTotalDuration(), d100);
// Add 300ms duration and check contents.
Duration d300(milliseconds(300));
interval->addDuration(d300);
- EXPECT_EQ(interval->getOccurrences(), 2);
+ EXPECT_EQ(interval->getOccurrences(), 2U);
EXPECT_EQ(interval->getMinDuration(), d100);
EXPECT_EQ(interval->getMaxDuration(), d300);
EXPECT_EQ(interval->getTotalDuration(), d100 + d300);
// Add 50ms duration and check contents.
Duration d50(milliseconds(50));
interval->addDuration(d50);
- EXPECT_EQ(interval->getOccurrences(), 3);
+ EXPECT_EQ(interval->getOccurrences(), 3U);
EXPECT_EQ(interval->getMinDuration(), d50);
EXPECT_EQ(interval->getMaxDuration(), d300);
EXPECT_EQ(interval->getTotalDuration(), d100 + d300 + d50);
// Add a zero duration and check contents.
interval->addDuration(DurationDataInterval::ZERO_DURATION());
- EXPECT_EQ(interval->getOccurrences(), 4);
+ EXPECT_EQ(interval->getOccurrences(), 4U);
EXPECT_EQ(interval->getMinDuration(), DurationDataInterval::ZERO_DURATION());
EXPECT_EQ(interval->getMaxDuration(), d300);
EXPECT_EQ(interval->getTotalDuration(), d100 + d300 + d50);
EXPECT_EQ(key->getResponseType(), DHCPV6_ADVERTISE);
EXPECT_EQ(key->getStartEventLabel(), "mt_queued");
EXPECT_EQ(key->getStopEventLabel(), "process_started");
- EXPECT_EQ(key->getSubnetId(), 77);
+ EXPECT_EQ(key->getSubnetId(), 77U);
EXPECT_EQ("SOLICIT-ADVERTISE.mt_queued-process_started.77",
key->getLabel());
EXPECT_EQ("subnet-id[77].perfmon.SOLICIT-ADVERTISE.mt_queued-process_started.mean-usecs",
EXPECT_EQ(mond->getResponseType(), DHCPV6_ADVERTISE);
EXPECT_EQ(mond->getStartEventLabel(), "mt_queued");
EXPECT_EQ(mond->getStopEventLabel(), "process_started");
- EXPECT_EQ(mond->getSubnetId(), 77);
+ EXPECT_EQ(mond->getSubnetId(), 77U);
EXPECT_EQ("SOLICIT-ADVERTISE.mt_queued-process_started.77", mond->getLabel());
EXPECT_EQ(mond->getIntervalDuration(), interval_duration);
EXPECT_FALSE(mond->getCurrentInterval());
// nothing to report, one occurrence and a total duration of 10ms.
EXPECT_FALSE(mond->getPreviousInterval());
EXPECT_FALSE(should_report);
- EXPECT_EQ(current_interval->getOccurrences(), 1);
+ EXPECT_EQ(current_interval->getOccurrences(), 1U);
EXPECT_EQ(current_interval->getTotalDuration(), two_ms);
// Save a copy of the current interval pointer.
// Add 4 two ms samples during the current interval.
DurationDataIntervalPtr previous_interval;
- for (int i = 1; i < 5; ++i) {
+ for (unsigned i = 1; i < 5; ++i) {
// Add a two ms sample, it should return false as its not
// time to report.
ASSERT_NO_THROW(should_report = mond->addSample(two_ms));
EXPECT_TRUE(previous_interval);
EXPECT_EQ(previous_interval, original_interval);
EXPECT_TRUE(should_report);
- EXPECT_EQ(current_interval->getOccurrences(), 1);
+ EXPECT_EQ(current_interval->getOccurrences(), 1U);
EXPECT_EQ(current_interval->getTotalDuration(), two_ms);
// Verify that clear wipes the intervals.
ASSERT_NO_THROW(mond->addSample(ten_ms));
auto current_interval = mond->getCurrentInterval();
ASSERT_TRUE(current_interval);
- EXPECT_EQ(current_interval->getOccurrences(), 1);
+ EXPECT_EQ(current_interval->getOccurrences(), 1U);
EXPECT_EQ(current_interval->getTotalDuration(), ten_ms);
EXPECT_FALSE(mond->getPreviousInterval());
EXPECT_GE(mond->getCurrentIntervalStart(), start_time);
ASSERT_NO_THROW_LOG(config.reset(new PerfMonConfig(family_)));
ASSERT_TRUE(config);
EXPECT_FALSE(config->getEnableMonitoring());
- EXPECT_EQ(config->getIntervalWidthSecs(), 60);
+ EXPECT_EQ(config->getIntervalWidthSecs(), 60U);
EXPECT_TRUE(config->getStatsMgrReporting());
- EXPECT_EQ(config->getAlarmReportSecs(), 300);
+ EXPECT_EQ(config->getAlarmReportSecs(), 300U);
EXPECT_TRUE(config->getAlarmStore());
// Verify accessors.
EXPECT_TRUE(config->getEnableMonitoring());
EXPECT_NO_THROW_LOG(config->setIntervalWidthSecs(4));
- EXPECT_EQ(config->getIntervalWidthSecs(), 4);
+ EXPECT_EQ(config->getIntervalWidthSecs(), 4U);
EXPECT_NO_THROW_LOG(config->setStatsMgrReporting(false));
EXPECT_FALSE(config->getStatsMgrReporting());
EXPECT_NO_THROW_LOG(config->setAlarmReportSecs(120));
- EXPECT_EQ(config->getAlarmReportSecs(), 120);
+ EXPECT_EQ(config->getAlarmReportSecs(), 120U);
}
/// @brief Exercises PerfMonConfig parameter parsing with valid configuration
EXPECT_TRUE(mgr_->getAlarmStore());
EXPECT_EQ(mgr_->getAlarmStore()->getFamily(), family_);
AlarmCollectionPtr alarms = mgr_->getAlarmStore()->getAll();
- ASSERT_EQ(alarms->size(), 0);
+ ASSERT_EQ(alarms->size(), 0U);
// Duration store should exist but be empty.
EXPECT_TRUE(mgr_->getDurationStore());
EXPECT_EQ(mgr_->getDurationStore()->getFamily(), family_);
MonitoredDurationCollectionPtr durations = mgr_->getDurationStore()->getAll();
- ASSERT_EQ(durations->size(), 0);
+ ASSERT_EQ(durations->size(), 0U);
}
/// @brief Exercises PerfMonConfig parameter parsing with valid configuration
EXPECT_TRUE(mgr_->getAlarmStore());
EXPECT_EQ(mgr_->getAlarmStore()->getFamily(), family_);
AlarmCollectionPtr alarms = mgr_->getAlarmStore()->getAll();
- ASSERT_EQ(alarms->size(), 1);
+ ASSERT_EQ(alarms->size(), 1U);
DurationKeyPtr key(new DurationKey(family_, 0, 0, "process-started",
"process-completed", 70));
AlarmPtr alarm = (*alarms)[0];
EXPECT_TRUE(mgr_->getDurationStore());
EXPECT_EQ(mgr_->getDurationStore()->getFamily(), family_);
MonitoredDurationCollectionPtr durations = mgr_->getDurationStore()->getAll();
- ASSERT_EQ(durations->size(), 0);
+ ASSERT_EQ(durations->size(), 0U);
}
/// @brief Verifies that PerfMonConfig handles a configuration error properly.
EXPECT_TRUE(mgr_->getAlarmStore());
EXPECT_EQ(mgr_->getAlarmStore()->getFamily(), family_);
AlarmCollectionPtr alarms = mgr_->getAlarmStore()->getAll();
- ASSERT_EQ(alarms->size(), 0);
+ ASSERT_EQ(alarms->size(), 0U);
// Duration store should exist but be empty.
EXPECT_TRUE(mgr_->getDurationStore());
EXPECT_EQ(mgr_->getDurationStore()->getFamily(), family_);
MonitoredDurationCollectionPtr durations = mgr_->getDurationStore()->getAll();
- ASSERT_EQ(durations->size(), 0);
+ ASSERT_EQ(durations->size(), 0U);
}
/// @brief Exercises PerfMonMgr::reportToStatsMgr().
beforeAndAfterAlarm(__LINE__, before_alarm, Alarm::CLEAR, false);
// No stats should have been reported.
- EXPECT_EQ(0, StatsMgr::instance().count());
+ EXPECT_EQ(0U, StatsMgr::instance().count());
// Sleep 100ms second to make sure the current interval duration elapses.
usleep(100 * 1000);
checkDuration(__LINE__, key, 95, true, 160);
// Should have one stat reported with a mean value of 80.
- EXPECT_EQ(1, StatsMgr::instance().count());
+ EXPECT_EQ(1U, StatsMgr::instance().count());
auto obs = StatsMgr::instance().getObservation(key->getStatName("mean-usecs"));
ASSERT_TRUE(obs);
EXPECT_EQ(80000, obs->getInteger().first);
addString("reported mean duration 00:00:00.100000 exceeds high-water-ms: 50");
// Should have one stat reported with a value of 100.
- EXPECT_EQ(1, StatsMgr::instance().count());
+ EXPECT_EQ(1U, StatsMgr::instance().count());
obs = StatsMgr::instance().getObservation(key->getStatName("mean-usecs"));
ASSERT_TRUE(obs);
EXPECT_EQ(100000, obs->getInteger().first);
addString("reported mean duration 00:00:00.010000 is now below low-water-ms: 25");
// Should have one stat reported with a value of 10.
- EXPECT_EQ(1, StatsMgr::instance().count());
+ EXPECT_EQ(1U, StatsMgr::instance().count());
obs = StatsMgr::instance().getObservation(key->getStatName("mean-usecs"));
ASSERT_TRUE(obs);
EXPECT_EQ(10000, obs->getInteger().first);
// Fetch all the durations in primary key order.
MonitoredDurationCollectionPtr durations = mgr_->getDurationStore()->getAll();
- ASSERT_EQ(durations->size(), 0);
+ ASSERT_EQ(durations->size(), 0U);
// Enabled monitoring and process the queries again.
mgr_->setEnableMonitoring(true);
// Fetch all the durations in primary key order.
durations = mgr_->getDurationStore()->getAll();
- ASSERT_EQ(durations->size(), 12);
+ ASSERT_EQ(durations->size(), 12U);
// Contains the expected values for single duration.
struct ExpectedDuration {
vector<string> output;
EXPECT_TRUE(getOutput(output));
ASSERT_FALSE(output.empty());
- EXPECT_EQ(1, output.size());
+ EXPECT_EQ(1U, output.size());
ostringstream s;
s << version.first << "|" << version.second;
EXPECT_EQ(s.str(), output[0]);
io_service_->poll();
// Our lost and recovered connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(1, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(1U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_TRUE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost and recovered connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(1, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(1U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
io_service_->poll();
// Our lost and recovered connectivity callback should have been invoked.
- EXPECT_EQ(2, db_lost_callback_called_);
- EXPECT_EQ(1, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(2U, db_lost_callback_called_);
+ EXPECT_EQ(1U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_TRUE(LegalLogMgrFactory::instance());
io_service_->poll();
// No callback should have been invoked.
- EXPECT_EQ(2, db_lost_callback_called_);
- EXPECT_EQ(1, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(2U, db_lost_callback_called_);
+ EXPECT_EQ(1U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_TRUE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
io_service_->poll();
// Our lost connectivity callback should have been invoked.
- EXPECT_EQ(2, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(2U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
io_service_->poll();
// Our lost and failed connectivity callback should have been invoked.
- EXPECT_EQ(3, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(1, db_failed_callback_called_);
+ EXPECT_EQ(3U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(1U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
}
io_service_->poll();
- EXPECT_EQ(0, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(0U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost and recovered connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(1, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(1U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_TRUE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost and failed connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(1, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(1U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
io_service_->poll();
// Our lost and recovered connectivity callback should have been invoked.
- EXPECT_EQ(2, db_lost_callback_called_);
- EXPECT_EQ(1, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(2U, db_lost_callback_called_);
+ EXPECT_EQ(1U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_TRUE(LegalLogMgrFactory::instance());
io_service_->poll();
// No callback should have been invoked.
- EXPECT_EQ(2, db_lost_callback_called_);
- EXPECT_EQ(1, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(2U, db_lost_callback_called_);
+ EXPECT_EQ(1U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_TRUE(LegalLogMgrFactory::instance());
}
io_service_->poll();
// Our lost connectivity callback should have been invoked.
- EXPECT_EQ(1, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(1U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
io_service_->poll();
// Our lost connectivity callback should have been invoked.
- EXPECT_EQ(2, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(0, db_failed_callback_called_);
+ EXPECT_EQ(2U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(0U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
io_service_->poll();
// Our lost and failed connectivity callback should have been invoked.
- EXPECT_EQ(3, db_lost_callback_called_);
- EXPECT_EQ(0, db_recovered_callback_called_);
- EXPECT_EQ(1, db_failed_callback_called_);
+ EXPECT_EQ(3U, db_lost_callback_called_);
+ EXPECT_EQ(0U, db_recovered_callback_called_);
+ EXPECT_EQ(1U, db_failed_callback_called_);
ASSERT_FALSE(LegalLogMgrFactory::instance());
}
// Check that the countRows is working. It's used extensively in other
// tests, so basic check is enough here.
- EXPECT_EQ(0, countRows(conn, "lease4"));
+ EXPECT_EQ(0U, countRows(conn, "lease4"));
}
// Verifies that v4 class lease counts are correctly adjusted
*handle));
EXPECT_EQ(CalloutHandle::CalloutNextStep::NEXT_STEP_CONTINUE, handle->getStatus());
- EXPECT_EQ(1, countFile("PING_CHECK_NO_LEASE_OR_LEASE_REUSED Ping check skipped: no lease"));
+ EXPECT_EQ(1U, countFile("PING_CHECK_NO_LEASE_OR_LEASE_REUSED Ping check skipped: no lease"));
}
} // end of anonymous namespace
// Create a new cache.
TestConfigCache configs;
- EXPECT_EQ(configs.size(), 0);
+ EXPECT_EQ(configs.size(), 0U);
// Verify that last_flush_time_ has been set and that the
// cache has no entries.
void testInvalidConfig() {
// Create a new cache.
TestConfigCache configs;
- EXPECT_EQ(configs.size(), 0);
+ EXPECT_EQ(configs.size(), 0U);
// An invalid keyword should fail.
std::string json =
ASSERT_THROW_MSG(configs.parseAndCacheConfig(1, user_context), DhcpConfigError,
"spurious 'bogus' parameter");
- EXPECT_EQ(configs.size(), 0);
+ EXPECT_EQ(configs.size(), 0U);
}
/// @brief Verifies that valid user-context supplied config are cached correctly.
void testValidConfig() {
// Create a new cache.
TestConfigCache configs;
- EXPECT_EQ(configs.size(), 0);
+ EXPECT_EQ(configs.size(), 0U);
// A valid config should get cached.
std::string json =
PingCheckConfigPtr config;
ASSERT_NO_THROW_LOG(config = configs.parseAndCacheConfig(1, user_context));
ASSERT_TRUE(config);
- EXPECT_EQ(configs.size(), 1);
+ EXPECT_EQ(configs.size(), 1U);
// Verify we can retrieve the cached config.
PingCheckConfigPtr fetched_config;
void testConfigCacheEmptyConfig() {
// Create a new cache.
TestConfigCache configs;
- EXPECT_EQ(configs.size(), 0);
+ EXPECT_EQ(configs.size(), 0U);
// Verify that we can cache an empty config pointer.
PingCheckConfigPtr no_config;
ASSERT_NO_THROW_LOG(configs.cacheConfig(1, no_config));
- EXPECT_EQ(configs.size(), 1);
+ EXPECT_EQ(configs.size(), 1U);
// Verify we can retrieve the cached empty config pointer.
PingCheckConfigPtr fetched_config;
void testFlushCache() {
// Create a new cache.
TestConfigCache configs;
- EXPECT_EQ(configs.size(), 0);
+ EXPECT_EQ(configs.size(), 0U);
ptime last_flush_time = configs.getLastFlushTime();
ConstElementPtr user_context;
ASSERT_NO_THROW_LOG(user_context = Element::fromJSON(json));
- for (int id = 1; id < 5; ++id) {
+ for (unsigned id = 1; id < 5; ++id) {
PingCheckConfigPtr config;
ASSERT_NO_THROW_LOG(config = configs.parseAndCacheConfig(id, user_context));
ASSERT_TRUE(config);
// and last_flush_time should be updated.
configs.flush();
EXPECT_GT(configs.getLastFlushTime(), last_flush_time);
- EXPECT_EQ(configs.size(), 0);
+ EXPECT_EQ(configs.size(), 0U);
}
};
});
// Sanity check, we should have sent one less than we targeted.
- EXPECT_EQ(echos_sent_.size(), 9);
+ EXPECT_EQ(echos_sent_.size(), 9U);
}
}
});
// Sanity check, we should have sent one less than we targeted.
- EXPECT_EQ(echos_sent_.size(), 9);
+ EXPECT_EQ(echos_sent_.size(), 9U);
}
}
// Verify initial values.
EXPECT_TRUE(config.getEnablePingCheck());
- EXPECT_EQ(1, config.getMinPingRequests());
- EXPECT_EQ(100, config.getReplyTimeout());
- EXPECT_EQ(60, config.getPingClttSecs());
- EXPECT_EQ(0, config.getPingChannelThreads());
+ EXPECT_EQ(1U, config.getMinPingRequests());
+ EXPECT_EQ(100U, config.getReplyTimeout());
+ EXPECT_EQ(60U, config.getPingClttSecs());
+ EXPECT_EQ(0U, config.getPingChannelThreads());
// Verify accessors.
EXPECT_NO_THROW_LOG(config.setEnablePingCheck(false));
EXPECT_FALSE(config.getEnablePingCheck());
EXPECT_NO_THROW_LOG(config.setMinPingRequests(4));
- EXPECT_EQ(4, config.getMinPingRequests());
+ EXPECT_EQ(4U, config.getMinPingRequests());
EXPECT_NO_THROW_LOG(config.setReplyTimeout(250));
- EXPECT_EQ(250, config.getReplyTimeout());
+ EXPECT_EQ(250U, config.getReplyTimeout());
EXPECT_NO_THROW_LOG(config.setPingClttSecs(120));
- EXPECT_EQ(120, config.getPingClttSecs());
+ EXPECT_EQ(120U, config.getPingClttSecs());
EXPECT_NO_THROW_LOG(config.setPingChannelThreads(6));
- EXPECT_EQ(6, config.getPingChannelThreads());
+ EXPECT_EQ(6U, config.getPingChannelThreads());
// Verify copy construction.
PingCheckConfig config2(config);
EXPECT_FALSE(config2.getEnablePingCheck());
- EXPECT_EQ(4, config2.getMinPingRequests());
- EXPECT_EQ(250, config2.getReplyTimeout());
- EXPECT_EQ(120, config2.getPingClttSecs());
- EXPECT_EQ(6, config2.getPingChannelThreads());
+ EXPECT_EQ(4U, config2.getMinPingRequests());
+ EXPECT_EQ(250U, config2.getReplyTimeout());
+ EXPECT_EQ(120U, config2.getPingClttSecs());
+ EXPECT_EQ(6U, config2.getPingChannelThreads());
}
// Exercises PingCheckConfig parameter parsing with valid configuration
// elsewhere.
auto& config = mgr->getGlobalConfig();
EXPECT_TRUE(config->getEnablePingCheck());
- EXPECT_EQ(1, config->getMinPingRequests());
- EXPECT_EQ(100, config->getReplyTimeout());
- EXPECT_EQ(60, config->getPingClttSecs());
- EXPECT_EQ(0, config->getPingChannelThreads());
+ EXPECT_EQ(1U, config->getMinPingRequests());
+ EXPECT_EQ(100U, config->getReplyTimeout());
+ EXPECT_EQ(60U, config->getPingClttSecs());
+ EXPECT_EQ(0U, config->getPingChannelThreads());
// Verify we report as stopped.
EXPECT_FALSE(mgr->isRunning());
// elsewhere.
auto& config = mgr->getGlobalConfig();
EXPECT_TRUE(config->getEnablePingCheck());
- EXPECT_EQ(1, config->getMinPingRequests());
- EXPECT_EQ(100, config->getReplyTimeout());
- EXPECT_EQ(60, config->getPingClttSecs());
- EXPECT_EQ(3, config->getPingChannelThreads());
+ EXPECT_EQ(1U, config->getMinPingRequests());
+ EXPECT_EQ(100U, config->getReplyTimeout());
+ EXPECT_EQ(60U, config->getPingClttSecs());
+ EXPECT_EQ(3U, config->getPingChannelThreads());
// It should not be running yet.
EXPECT_FALSE(mgr->isRunning());
// Verify initial global configuration.
auto& default_config = mgr->getGlobalConfig();
EXPECT_TRUE(default_config->getEnablePingCheck());
- EXPECT_EQ(1, default_config->getMinPingRequests());
- EXPECT_EQ(100, default_config->getReplyTimeout());
- EXPECT_EQ(60, default_config->getPingClttSecs());
- EXPECT_EQ(0, default_config->getPingChannelThreads());
+ EXPECT_EQ(1U, default_config->getMinPingRequests());
+ EXPECT_EQ(100U, default_config->getReplyTimeout());
+ EXPECT_EQ(60U, default_config->getPingClttSecs());
+ EXPECT_EQ(0U, default_config->getPingChannelThreads());
//Create a valid configuration.
std::string valid_json_cfg =
auto& config = mgr->getGlobalConfig();
ASSERT_TRUE(config);
EXPECT_FALSE(config->getEnablePingCheck());
- EXPECT_EQ(2, config->getMinPingRequests());
- EXPECT_EQ(250, config->getReplyTimeout());
- EXPECT_EQ(90, config->getPingClttSecs());
- EXPECT_EQ(3, config->getPingChannelThreads());
+ EXPECT_EQ(2U, config->getMinPingRequests());
+ EXPECT_EQ(250U, config->getReplyTimeout());
+ EXPECT_EQ(90U, config->getPingClttSecs());
+ EXPECT_EQ(3U, config->getPingChannelThreads());
// Create an invalid configuration.
std::string invalid_json_cfg =
auto store = mgr_->getStore();
ASSERT_TRUE(store);
auto pings = store->getAll();
- ASSERT_EQ(0, pings->size());
+ ASSERT_EQ(0U, pings->size());
// Destruction should be graceful.
ASSERT_NO_THROW_LOG(mgr_.reset());
// Our context should be present.
auto const& store = mgr_->getStore();
auto pings = store->getAll();
- ASSERT_EQ(1, pings->size());
+ ASSERT_EQ(1U, pings->size());
PingContextPtr context1;
ASSERT_NO_THROW_LOG(context1 = store->getContextByAddress(lqp1.lease_->addr_));
ASSERT_TRUE(context1);
// Verify the context's state.
- EXPECT_EQ(2, context1->getMinEchos());
- EXPECT_EQ(250, context1->getReplyTimeout());
- EXPECT_EQ(0, context1->getEchosSent());
+ EXPECT_EQ(2U, context1->getMinEchos());
+ EXPECT_EQ(250U, context1->getReplyTimeout());
+ EXPECT_EQ(0U, context1->getEchosSent());
EXPECT_EQ(PingContext::EMPTY_TIME(), context1->getLastEchoSentTime());
EXPECT_LE(test_start_time_, context1->getSendWaitStart());
EXPECT_EQ(PingContext::EMPTY_TIME(), context1->getNextExpiry());
// Both contexts should be present.
pings = store->getAll();
- ASSERT_EQ(2, pings->size());
+ ASSERT_EQ(2U, pings->size());
// Fetch the second context by address.
PingContextPtr context2;
ASSERT_TRUE(context2);
// Verify the second context's state.
- EXPECT_EQ(2, context2->getMinEchos());
- EXPECT_EQ(250, context2->getReplyTimeout());
- EXPECT_EQ(0, context2->getEchosSent());
+ EXPECT_EQ(2U, context2->getMinEchos());
+ EXPECT_EQ(250U, context2->getReplyTimeout());
+ EXPECT_EQ(0U, context2->getEchosSent());
EXPECT_EQ(PingContext::EMPTY_TIME(), context2->getLastEchoSentTime());
// Its send_wait_start_time_ should be more recent than context1.
EXPECT_LE(context1->getSendWaitStart(), context2->getSendWaitStart());
ASSERT_TRUE(context);
// Verify the context's initial state is correct.
- EXPECT_EQ(0, context->getEchosSent());
+ EXPECT_EQ(0U, context->getEchosSent());
EXPECT_EQ(PingContext::EMPTY_TIME(), context->getLastEchoSentTime());
EXPECT_LE(test_start_time_, context->getSendWaitStart());
EXPECT_EQ(PingContext::EMPTY_TIME(), context->getNextExpiry());
ASSERT_TRUE(context);
// Verify the state has properly moved to SENDING.
- EXPECT_EQ(0, context->getEchosSent());
+ EXPECT_EQ(0U, context->getEchosSent());
EXPECT_EQ(PingContext::EMPTY_TIME(), context->getLastEchoSentTime());
EXPECT_EQ(PingContext::EMPTY_TIME(), context->getNextExpiry());
EXPECT_EQ(PingContext::SENDING, context->getState());
context = getContext(context->getLease()->addr_);
EXPECT_EQ(PingContext::WAITING_FOR_REPLY, context->getState());
- EXPECT_EQ(1, context->getEchosSent());
+ EXPECT_EQ(1U, context->getEchosSent());
EXPECT_GE(context->getLastEchoSentTime(), test_start_time_);
// Verify the mgr has the same next expiration as the context and
ASSERT_NO_THROW_LOG(mgr_->sendCompleted(echo_request, false));
// Should still have one parked query.
- EXPECT_EQ(1, mgr_->parkingLotSize());
+ EXPECT_EQ(1U, mgr_->parkingLotSize());
// Verify the expiration timer is running.
EXPECT_TRUE(fuzzyEqual(mgr_->getExpirationTimerInterval(), 500));
EXPECT_FALSE(getContext(lqp));
// We should have dropped the query from the lot rather than unparking it.
- EXPECT_EQ(mgr_->parkingLotSize(), 0);
- EXPECT_EQ(unparked_, 1);
+ EXPECT_EQ(mgr_->parkingLotSize(), 0U);
+ EXPECT_EQ(unparked_, 1U);
// We should have one decline that matches our lease query pair.
compareLeaseQueryPairs(declines_);
ASSERT_NO_THROW_LOG(mgr_->sendCompleted(echo_request, false));
// Should still have one parked query.
- EXPECT_EQ(1, mgr_->parkingLotSize());
+ EXPECT_EQ(1U, mgr_->parkingLotSize());
// Verify the expiration timer is running.
EXPECT_TRUE(fuzzyEqual(mgr_->getExpirationTimerInterval(), 500));
EXPECT_FALSE(getContext(lqp));
// We should have unparked the query from the lot.
- EXPECT_EQ(mgr_->parkingLotSize(), 0);
- EXPECT_EQ(unparked_, 1);
+ EXPECT_EQ(mgr_->parkingLotSize(), 0U);
+ EXPECT_EQ(unparked_, 1U);
// We should have one free that matches our lease query pair.
compareLeaseQueryPairs(frees_);
IOAddress address = lease_query_pairs_[1].lease_->addr_;
context2 = getContext(address);
ASSERT_FALSE(context2);
- EXPECT_EQ(unparked_, 1);
- ASSERT_EQ(frees_.size(), 1);
+ EXPECT_EQ(unparked_, 1U);
+ ASSERT_EQ(frees_.size(), 1U);
EXPECT_EQ(frees_[0].lease_->addr_, address);
// Context3 should be in WAITING_TO_SEND.
EXPECT_FALSE(getContext(lqp));
// We should have unparked the query from the lot.
- EXPECT_EQ(mgr_->parkingLotSize(), 0);
- EXPECT_EQ(unparked_, 1);
+ EXPECT_EQ(mgr_->parkingLotSize(), 0U);
+ EXPECT_EQ(unparked_, 1U);
// We should have one free that matches our lease query pair.
compareLeaseQueryPairs(frees_);
ASSERT_NO_THROW_LOG(config = mgr_->getScopedConfig(lease));
ASSERT_TRUE(config);
ASSERT_NE(config, mgr_->getGlobalConfig());
- EXPECT_EQ(config->getMinPingRequests(), 13);
+ EXPECT_EQ(config->getMinPingRequests(), 13U);
}
/// @brief Exercises checkSuspended().
auto store = mgr_->getStore();
ASSERT_TRUE(store);
auto pings = store->getAll();
- ASSERT_EQ(0, pings->size());
+ ASSERT_EQ(0U, pings->size());
// Make a lease query pair.
auto lqp1 = makeLeaseQueryPair(IOAddress("127.0.0.2"), 111);
// Verify we have an entry in the store.
pings = store->getAll();
- ASSERT_EQ(1, pings->size());
+ ASSERT_EQ(1U, pings->size());
// Disable the DHCP service.
network_state->disableService(NetworkState::USER_COMMAND);
// Store should be empty, having been flushed by suspension detection.
pings = store->getAll();
- ASSERT_EQ(0, pings->size());
+ ASSERT_EQ(0U, pings->size());
// Ping checking should report as suspended.
ASSERT_TRUE(mgr_->checkSuspended());
// Store should have one check in it.
pings = store->getAll();
- ASSERT_EQ(1, pings->size());
+ ASSERT_EQ(1U, pings->size());
// Ping checking should report as not suspended.
ASSERT_FALSE(mgr_->checkSuspended());
// Check initial values.
EXPECT_EQ(PingContext::WAITING_TO_SEND, context->getState());
EXPECT_LE(now, context->getSendWaitStart());
- EXPECT_EQ(2, context->getMinEchos());
- EXPECT_EQ(300, context->getReplyTimeout());
+ EXPECT_EQ(2U, context->getMinEchos());
+ EXPECT_EQ(300U, context->getReplyTimeout());
}
// Make sure they can be fetched by address and by query individually.
PingContextCollectionPtr expired_since;
ASSERT_NO_THROW_LOG(expired_since = store.getExpiredSince());
ASSERT_TRUE(expired_since);
- EXPECT_EQ(0, expired_since->size());
+ EXPECT_EQ(0U, expired_since->size());
// Fetch all that have expired since start time + 750 ms, should be third context.
ASSERT_NO_THROW_LOG(expired_since = store.getExpiredSince(start_time + milliseconds(750)));
ASSERT_TRUE(expired_since);
- EXPECT_EQ(1, expired_since->size());
+ EXPECT_EQ(1U, expired_since->size());
context = (*expired_since)[0];
EXPECT_EQ(leases_[2], context->getLease());
EXPECT_EQ(queries_[2], context->getQuery());
// Should be the third and second contexts
ASSERT_NO_THROW_LOG(expired_since = store.getExpiredSince(start_time + milliseconds(1500)));
ASSERT_TRUE(expired_since);
- EXPECT_EQ(2, expired_since->size());
+ EXPECT_EQ(2U, expired_since->size());
// First in list should be the third context.
context = (*expired_since)[0];
// Now clear the store. Verify it's empty.
ASSERT_NO_THROW_LOG(store.clear());
ASSERT_NO_THROW_LOG(contexts = store.getAll());
- ASSERT_EQ(0, contexts->size());
+ ASSERT_EQ(0U, contexts->size());
// Verify clearing an empty store does no harm.
ASSERT_NO_THROW_LOG(store.clear());
// Verify initial content.
EXPECT_EQ(lease->addr_, context->getTarget());
- EXPECT_EQ(1, context->getMinEchos());
- EXPECT_EQ(100, context->getReplyTimeout());
- EXPECT_EQ(0, context->getEchosSent());
+ EXPECT_EQ(1U, context->getMinEchos());
+ EXPECT_EQ(100U, context->getReplyTimeout());
+ EXPECT_EQ(0U, context->getEchosSent());
EXPECT_EQ(PingContext::EMPTY_TIME(), context->getLastEchoSentTime());
EXPECT_EQ(PingContext::EMPTY_TIME(), context->getSendWaitStart());
EXPECT_EQ(PingContext::EMPTY_TIME(), context->getNextExpiry());
ASSERT_NO_THROW_LOG(context.reset(new PingContext(lease, query, 1, 50)));
EXPECT_NO_THROW_LOG(context->setMinEchos(4));
- EXPECT_EQ(4, context->getMinEchos());
+ EXPECT_EQ(4U, context->getMinEchos());
EXPECT_NO_THROW_LOG(context->setReplyTimeout(200));
- EXPECT_EQ(200, context->getReplyTimeout());
+ EXPECT_EQ(200U, context->getReplyTimeout());
EXPECT_NO_THROW_LOG(context->setEchosSent(7));
- EXPECT_EQ(7, context->getEchosSent());
+ EXPECT_EQ(7U, context->getEchosSent());
EXPECT_NO_THROW_LOG(context->setLastEchoSentTime(time_now));
EXPECT_EQ(time_now, context->getLastEchoSentTime());
mutex mutex_;
/// @brief Histogram of next steps set after callouts.
- unordered_map<CalloutHandle::CalloutNextStep, int> steps_;
+ unordered_map<CalloutHandle::CalloutNextStep, size_t> steps_;
/// @brief Number of unparked packets.
uint32_t unparked_;
// Start the core thread pool with 4 threads.
// Pause the thread pool and resume only after work items have
// been added to it to increase the chance of finding race conditions.
- EXPECT_EQ(4, impl_.thread_pool_size_);
+ EXPECT_EQ(4U, impl_.thread_pool_size_);
EXPECT_TRUE(impl_.udp_client_);
- EXPECT_EQ(4, impl_.udp_client_->getThreadPoolSize());
+ EXPECT_EQ(4U, impl_.udp_client_->getThreadPoolSize());
EXPECT_NO_THROW_LOG(thread_pool_.start(impl_.thread_pool_size_));
EXPECT_NO_THROW_LOG(thread_pool_.pause());
map->set("radius", attrs->toElement());
host->setContext(map);
host->setNegative(true);
- ASSERT_EQ(0, cache_->insert(host, true));
+ ASSERT_EQ(0U, cache_->insert(host, true));
HooksManager::park("subnet4_select", pkt,
[] () { FAIL() << "unparked"; });
subnet.reset();
handle->getArgument("subnet4", subnet);
ASSERT_TRUE(subnet);
- EXPECT_EQ(1, subnet->getID());
+ EXPECT_EQ(1U, subnet->getID());
EXPECT_EQ("192.0.2.0/24", subnet->toText());
}
map->set("radius", attrs->toElement());
host->setContext(map);
host->setNegative(true);
- ASSERT_EQ(0, cache_->insert(host, true));
+ ASSERT_EQ(0U, cache_->insert(host, true));
HooksManager::park("subnet6_select", pkt,
[] () { FAIL() << "unparked"; });
subnet.reset();
handle->getArgument("subnet6", subnet);
ASSERT_TRUE(subnet);
- EXPECT_EQ(1, subnet->getID());
+ EXPECT_EQ(1U, subnet->getID());
EXPECT_EQ("2001:db8::/64", subnet->toText());
}
Element::create(static_cast<int64_t>(subnet2->getID())));
host1->setContext(map);
host1->setNegative(true);
- ASSERT_EQ(0, cache_->insert(host1, true));
+ ASSERT_EQ(0U, cache_->insert(host1, true));
// Add a RADIUS with pool cache entry for the host in subnet 2.
HostPtr host2(new Host(&id[1], id.size() - 1, impl_.id_type4_,
map->set("radius", attrs->toElement());
host2->setContext(map);
host2->setNegative(true); // no reserved address nor hostname
- ASSERT_EQ(0, cache_->insert(host2, true));
+ ASSERT_EQ(0U, cache_->insert(host2, true));
// Now call subnet4_select callout and check the second subnet is selected.
// Note reselect is checked twice: on the return of host cache
Element::create(static_cast<int64_t>(subnet2->getID())));
host1->setContext(map);
host1->setNegative(true);
- ASSERT_EQ(0, cache_->insert(host1, true));
+ ASSERT_EQ(0U, cache_->insert(host1, true));
// Add a RADIUS with pool cache entry for the host in subnet 2.
HostPtr host2(new Host(&id[2], id.size() - 2, impl_.id_type6_,
map->set("radius", attrs->toElement());
host2->setContext(map);
host2->setNegative(true); // no reserved address nor hostname
- ASSERT_EQ(0, cache_->insert(host2, true));
+ ASSERT_EQ(0U, cache_->insert(host2, true));
// Now call subnet6_select callout and check the second subnet is selected.
// Note reselect is checked twice: on the return of host cache
subnet.reset();
handle->getArgument("subnet6", subnet);
ASSERT_TRUE(subnet);
- EXPECT_EQ(2, subnet->getID());
+ EXPECT_EQ(2U, subnet->getID());
EXPECT_EQ("2001:db8:0:2::/64", subnet->toText());
}
attrs->add(Attribute::fromString(PW_FRAMED_POOL, "foobar"));
map->set("radius", attrs->toElement());
host->setContext(map);
- ASSERT_EQ(0, cache_->insert(host, true));
+ ASSERT_EQ(0U, cache_->insert(host, true));
HooksManager::park("subnet4_select", pkt,
[] () { FAIL() << "unparked"; });
subnet.reset();
handle->getArgument("subnet4", subnet);
ASSERT_TRUE(subnet);
- EXPECT_EQ(1, subnet->getID());
+ EXPECT_EQ(1U, subnet->getID());
EXPECT_EQ("192.0.2.0/24", subnet->toText());
}
attrs->add(Attribute::fromString(PW_FRAMED_POOL, "foobar"));
map->set("radius", attrs->toElement());
host->setContext(map);
- ASSERT_EQ(0, cache_->insert(host, true));
+ ASSERT_EQ(0U, cache_->insert(host, true));
HooksManager::park("subnet6_select", pkt,
[] () { FAIL() << "unparked"; });
subnet.reset();
handle->getArgument("subnet6", subnet);
ASSERT_TRUE(subnet);
- EXPECT_EQ(1, subnet->getID());
+ EXPECT_EQ(1U, subnet->getID());
EXPECT_EQ("2001:db8::/64", subnet->toText());
}
attrs->add(Attribute::fromString(PW_FRAMED_POOL, "foobar"));
map->set("radius", attrs->toElement());
host->setContext(map);
- ASSERT_EQ(0, cache_->insert(host, true));
+ ASSERT_EQ(0U, cache_->insert(host, true));
HooksManager::park("subnet6_select", pkt,
[] () { FAIL() << "unparked"; });
subnet.reset();
handle->getArgument("subnet6", subnet);
ASSERT_TRUE(subnet);
- EXPECT_EQ(1, subnet->getID());
+ EXPECT_EQ(1U, subnet->getID());
EXPECT_EQ("2001:db8::/64", subnet->toText());
}
attrs->add(Attribute::fromString(PW_FRAMED_POOL, "foobar"));
map->set("radius", attrs->toElement());
host->setContext(map);
- ASSERT_EQ(0, cache_->insert(host, true));
+ ASSERT_EQ(0U, cache_->insert(host, true));
HooksManager::park("subnet6_select", pkt,
[] () { FAIL() << "unparked"; });
subnet.reset();
handle->getArgument("subnet6", subnet);
ASSERT_TRUE(subnet);
- EXPECT_EQ(1, subnet->getID());
+ EXPECT_EQ(1U, subnet->getID());
EXPECT_EQ("2001:db8::/64", subnet->toText());
}
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- EXPECT_EQ(1, saved_attrs->size());
+ EXPECT_EQ(1U, saved_attrs->size());
for (PktPtr const& pkt : packets_) {
EXPECT_TRUE(pkt->inClass("foobar"));
ConstSubnet4Ptr subneth;
EXPECT_NO_THROW(handle->getContext("subnet4", subneth));
ASSERT_TRUE(subneth);
- EXPECT_EQ(1, subneth->getID());
+ EXPECT_EQ(1U, subneth->getID());
}
}
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- EXPECT_EQ(1, saved_attrs->size());
+ EXPECT_EQ(1U, saved_attrs->size());
for (PktPtr const& pkt : packets_) {
EXPECT_TRUE(pkt->inClass("foobar"));
ConstSubnet6Ptr subneth;
EXPECT_NO_THROW(handle->getContext("subnet6", subneth));
ASSERT_TRUE(subneth);
- EXPECT_EQ(1, subneth->getID());
+ EXPECT_EQ(1U, subneth->getID());
}
}
ASSERT_NO_THROW(ret = subnet4_select(*handle));
EXPECT_EQ(0, ret);
EXPECT_EQ(CalloutHandle::NEXT_STEP_SKIP, handle->getStatus());
- EXPECT_EQ(0, impl_.auth_->requests4_.size());
+ EXPECT_EQ(0U, impl_.auth_->requests4_.size());
subnet.reset();
handle->getArgument("subnet4", subnet);
ASSERT_TRUE(subnet);
- EXPECT_EQ(1, subnet->getID());
+ EXPECT_EQ(1U, subnet->getID());
EXPECT_EQ("192.0.2.0/24", subnet->toText());
}
ASSERT_NO_THROW(ret = subnet6_select(*handle));
EXPECT_EQ(0, ret);
EXPECT_EQ(CalloutHandle::NEXT_STEP_SKIP, handle->getStatus());
- EXPECT_EQ(0, impl_.auth_->requests6_.size());
+ EXPECT_EQ(0U, impl_.auth_->requests6_.size());
}
/// Verify that getIdentifier handles correctly IPv4 packets using
ASSERT_NO_THROW(handler = impl_.auth_->buildAuth(*pkt, 1, id, text));
ASSERT_TRUE(handler);
- EXPECT_EQ(1, handler->env_.subnet_id_);
+ EXPECT_EQ(1U, handler->env_.subnet_id_);
ASSERT_EQ(id.size(), handler->env_.id_.size());
EXPECT_EQ(0, memcmp(&id[0], &handler->env_.id_[0], id.size()));
ASSERT_TRUE(handler->env_.send_attrs_);
- EXPECT_LE(2, handler->env_.send_attrs_->size());
+ EXPECT_LE(2U, handler->env_.send_attrs_->size());
ConstAttributePtr user_name = handler->env_.send_attrs_->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
string expected = "User-Name='" + text + "'";
ASSERT_NO_THROW(handler = impl_.auth_->buildAuth(*pkt, 1, id, text));
ASSERT_TRUE(handler);
- EXPECT_EQ(1, handler->env_.subnet_id_);
+ EXPECT_EQ(1U, handler->env_.subnet_id_);
ASSERT_EQ(id.size(), handler->env_.id_.size());
EXPECT_EQ(0, memcmp(&id[0], &handler->env_.id_[0], id.size()));
ASSERT_TRUE(handler->env_.send_attrs_);
- EXPECT_LE(2, handler->env_.send_attrs_->size());
+ EXPECT_LE(2U, handler->env_.send_attrs_->size());
ConstAttributePtr user_name = handler->env_.send_attrs_->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
string expected = "User-Name='" + text + "'";
ASSERT_TRUE(handler);
ASSERT_TRUE(handler->env_.send_attrs_);
- EXPECT_LE(2, handler->env_.send_attrs_->size());
+ EXPECT_LE(2U, handler->env_.send_attrs_->size());
ConstAttributePtr calling_station_id =
handler->env_.send_attrs_->get(PW_CALLING_STATION_ID);
ASSERT_TRUE(calling_station_id);
ASSERT_TRUE(handler);
ASSERT_TRUE(handler->env_.send_attrs_);
- EXPECT_LE(2, handler->env_.send_attrs_->size());
+ EXPECT_LE(2U, handler->env_.send_attrs_->size());
ConstAttributePtr calling_station_id =
handler->env_.send_attrs_->get(PW_CALLING_STATION_ID);
ASSERT_TRUE(calling_station_id);
ASSERT_TRUE(handler);
ASSERT_TRUE(handler->env_.send_attrs_);
- EXPECT_LE(1, handler->env_.send_attrs_->size());
+ EXPECT_LE(1U, handler->env_.send_attrs_->size());
ConstAttributePtr calling_station_id =
handler->env_.send_attrs_->get(PW_CALLING_STATION_ID);
ASSERT_FALSE(calling_station_id);
ASSERT_TRUE(handler);
ASSERT_TRUE(handler->env_.send_attrs_);
- EXPECT_LE(1, handler->env_.send_attrs_->size());
+ EXPECT_LE(1U, handler->env_.send_attrs_->size());
ConstAttributePtr calling_station_id =
handler->env_.send_attrs_->get(PW_CALLING_STATION_ID);
ASSERT_FALSE(calling_station_id);
// Simple Solicit has no hardware address.
ASSERT_TRUE(handler->env_.send_attrs_);
- EXPECT_LE(1, handler->env_.send_attrs_->size());
+ EXPECT_LE(1U, handler->env_.send_attrs_->size());
ConstAttributePtr calling_station_id =
handler->env_.send_attrs_->get(PW_CALLING_STATION_ID);
ASSERT_FALSE(calling_station_id);
drop = false;
ASSERT_NO_THROW(impl_.auth_->terminate4Internal(env, -3, attrs,
pkt, drop));
- EXPECT_EQ(1, env.subnet_id_);
+ EXPECT_EQ(1U, env.subnet_id_);
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_FALSE(impl_.auth_->requests4_.get(id));
- EXPECT_EQ(0, cache_->size());
+ EXPECT_EQ(0U, cache_->size());
impl_.auth_->requests4_.set(id, Pkt4Ptr());
ASSERT_NO_THROW(impl_.auth_->terminate4Internal(env, BADRESP_RC, attrs,
pkt, drop));
- EXPECT_EQ(1, env.subnet_id_);
+ EXPECT_EQ(1U, env.subnet_id_);
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_FALSE(impl_.auth_->requests4_.get(id));
- EXPECT_EQ(0, cache_->size());
+ EXPECT_EQ(0U, cache_->size());
impl_.auth_->requests4_.set(id, Pkt4Ptr());
ASSERT_NO_THROW(impl_.auth_->terminate4Internal(env, ERROR_RC, attrs,
pkt, drop));
- EXPECT_EQ(1, env.subnet_id_);
+ EXPECT_EQ(1U, env.subnet_id_);
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_FALSE(impl_.auth_->requests4_.get(id));
- EXPECT_EQ(0, cache_->size());
+ EXPECT_EQ(0U, cache_->size());
impl_.auth_->requests4_.set(id, Pkt4Ptr());
ASSERT_NO_THROW(impl_.auth_->terminate4Internal(env, TIMEOUT_RC, attrs,
pkt, drop));
- EXPECT_EQ(1, env.subnet_id_);
+ EXPECT_EQ(1U, env.subnet_id_);
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_FALSE(impl_.auth_->requests4_.get(id));
- EXPECT_EQ(0, cache_->size());
+ EXPECT_EQ(0U, cache_->size());
}
/// Verify the terminate behavior on error - IPv6.
drop = false;
ASSERT_NO_THROW(impl_.auth_->terminate6Internal(env, -3, attrs,
pkt, drop));
- EXPECT_EQ(1, env.subnet_id_);
+ EXPECT_EQ(1U, env.subnet_id_);
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
- EXPECT_EQ(0, cache_->size());
+ EXPECT_EQ(0U, cache_->size());
impl_.auth_->requests6_.set(id, Pkt6Ptr());
ASSERT_NO_THROW(impl_.auth_->terminate6Internal(env, BADRESP_RC, attrs,
pkt, drop));
- EXPECT_EQ(1, env.subnet_id_);
+ EXPECT_EQ(1U, env.subnet_id_);
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
- EXPECT_EQ(0, cache_->size());
+ EXPECT_EQ(0U, cache_->size());
impl_.auth_->requests6_.set(id, Pkt6Ptr());
ASSERT_NO_THROW(impl_.auth_->terminate6Internal(env, ERROR_RC, attrs,
pkt, drop));
- EXPECT_EQ(1, env.subnet_id_);
+ EXPECT_EQ(1U, env.subnet_id_);
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
- EXPECT_EQ(0, cache_->size());
+ EXPECT_EQ(0U, cache_->size());
impl_.auth_->requests6_.set(id, Pkt6Ptr());
ASSERT_NO_THROW(impl_.auth_->terminate6Internal(env, TIMEOUT_RC, attrs,
pkt, drop));
- EXPECT_EQ(1, env.subnet_id_);
+ EXPECT_EQ(1U, env.subnet_id_);
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
- EXPECT_EQ(0, cache_->size());
+ EXPECT_EQ(0U, cache_->size());
}
/// Verify the terminate behavior on reject - IPv4.
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_EQ(SUBNET_ID_UNUSED, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get4Any(1, impl_.id_type4_,
&id[0], id.size());
ASSERT_TRUE(host);
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_EQ(SUBNET_ID_UNUSED, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(1, impl_.id_type6_,
&id[0], id.size());
ASSERT_TRUE(host);
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(1, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_TRUE(host->getHostname().empty());
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_EQ(SUBNET_ID_UNUSED, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get4Any(SUBNET_ID_GLOBAL,
impl_.id_type4_,
&id[0], id.size());
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_EQ(SUBNET_ID_UNUSED, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(SUBNET_ID_GLOBAL,
impl_.id_type6_,
&id[0], id.size());
EXPECT_FALSE(impl_.auth_->requests4_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- ASSERT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ ASSERT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get4Any(1, impl_.id_type4_,
&id[0], id.size());
ASSERT_TRUE(host);
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(1, impl_.id_type6_,
&id[0], id.size());
ASSERT_TRUE(host);
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(1, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_TRUE(host->getHostname().empty());
EXPECT_FALSE(impl_.auth_->requests4_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- ASSERT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ ASSERT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get4Any(SUBNET_ID_GLOBAL,
impl_.id_type4_,
&id[0], id.size());
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(SUBNET_ID_GLOBAL,
impl_.id_type6_,
&id[0], id.size());
EXPECT_FALSE(impl_.auth_->requests4_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- ASSERT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ ASSERT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get4Any(1, impl_.id_type4_,
&id[0], id.size());
ASSERT_TRUE(host);
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(1, impl_.id_type6_,
&id[0], id.size());
ASSERT_TRUE(host);
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(1, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_TRUE(host->getHostname().empty());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- EXPECT_EQ(1, saved_attrs->size());
+ EXPECT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_EQ(SUBNET_ID_UNUSED, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get4Any(1, impl_.id_type4_,
&id[0], id.size());
ASSERT_TRUE(host);
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
EXPECT_EQ(SUBNET_ID_UNUSED, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(1, impl_.id_type6_,
&id[0], id.size());
ASSERT_TRUE(host);
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(1, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_TRUE(host->getHostname().empty());
ASSERT_TRUE(pkt2);
EXPECT_EQ(pkt, pkt2);
EXPECT_FALSE(drop);
- ASSERT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ ASSERT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get4Any(1, impl_.id_type4_,
&id[0], id.size());
ASSERT_TRUE(host);
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(pkt->inClass("foobar"));
}
ASSERT_TRUE(pkt2);
EXPECT_EQ(pkt, pkt2);
EXPECT_FALSE(drop);
- ASSERT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ ASSERT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(1, impl_.id_type6_,
&id[0], id.size());
ASSERT_TRUE(host);
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(1, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_TRUE(host->getHostname().empty());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- EXPECT_EQ(1, saved_attrs->size());
+ EXPECT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(pkt->inClass("foobar"));
}
ASSERT_TRUE(pkt2);
EXPECT_EQ(pkt, pkt2);
EXPECT_FALSE(drop);
- ASSERT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ ASSERT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get4Any(SUBNET_ID_GLOBAL,
impl_.id_type4_,
&id[0], id.size());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(pkt->inClass("foobar"));
}
ASSERT_TRUE(pkt2);
EXPECT_EQ(pkt, pkt2);
EXPECT_FALSE(drop);
- ASSERT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ ASSERT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(SUBNET_ID_GLOBAL,
impl_.id_type6_,
&id[0], id.size());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- EXPECT_EQ(1, saved_attrs->size());
+ EXPECT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(pkt->inClass("foobar"));
}
EXPECT_FALSE(impl_.auth_->requests4_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get4Any(1, impl_.id_type4_,
&id[0], id.size());
ASSERT_TRUE(host);
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.1", host->getIPv4Reservation().toText());
EXPECT_FALSE(host->hasIPv6Reservation());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
EXPECT_FALSE(impl_.auth_->requests4_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get4Any(SUBNET_ID_GLOBAL,
impl_.id_type4_,
&id[0], id.size());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(1, impl_.id_type6_,
&id[0], id.size());
ASSERT_TRUE(host);
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(1, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_TRUE(host->getHostname().empty());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- EXPECT_EQ(1, saved_attrs->size());
+ EXPECT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(1, impl_.id_type6_,
&id[0], id.size());
ASSERT_TRUE(host);
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(1, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_TRUE(host->hasIPv6Reservation());
IPv6ResrvRange resrvs = host->getIPv6Reservations();
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- EXPECT_EQ(1, saved_attrs->size());
+ EXPECT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(SUBNET_ID_GLOBAL,
impl_.id_type6_,
&id[0], id.size());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- EXPECT_EQ(1, saved_attrs->size());
+ EXPECT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(1, impl_.id_type6_,
&id[0], id.size());
ASSERT_TRUE(host);
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(1, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_TRUE(host->hasIPv6Reservation());
IPv6ResrvRange resrvs = host->getIPv6Reservations();
ASSERT_EQ(1, std::distance(resrvs.first, resrvs.second));
EXPECT_EQ("2001:db8:1::", resrvs.first->second.getPrefix().toText());
- EXPECT_EQ(64, resrvs.first->second.getPrefixLen());
+ EXPECT_EQ(64U, resrvs.first->second.getPrefixLen());
EXPECT_TRUE(host->getHostname().empty());
EXPECT_TRUE(host->getClientClasses4().empty());
EXPECT_TRUE(host->getClientClasses6().empty());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- EXPECT_EQ(1, saved_attrs->size());
+ EXPECT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(SUBNET_ID_GLOBAL,
impl_.id_type6_,
&id[0], id.size());
IPv6ResrvRange resrvs = host->getIPv6Reservations();
ASSERT_EQ(1, std::distance(resrvs.first, resrvs.second));
EXPECT_EQ("2001:db8:1::", resrvs.first->second.getPrefix().toText());
- EXPECT_EQ(64, resrvs.first->second.getPrefixLen());
+ EXPECT_EQ(64U, resrvs.first->second.getPrefixLen());
EXPECT_TRUE(host->getHostname().empty());
EXPECT_TRUE(host->getClientClasses4().empty());
EXPECT_TRUE(host->getClientClasses6().empty());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- EXPECT_EQ(1, saved_attrs->size());
+ EXPECT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(1, impl_.id_type6_,
&id[0], id.size());
ASSERT_TRUE(host);
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(1, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_TRUE(host->hasIPv6Reservation());
IPv6ResrvRange resrvs = host->getIPv6Reservations(IPv6Resrv::TYPE_NA);
resrvs = host->getIPv6Reservations(IPv6Resrv::TYPE_PD);
ASSERT_EQ(1, std::distance(resrvs.first, resrvs.second));
EXPECT_EQ("2001:db8:1::", resrvs.first->second.getPrefix().toText());
- EXPECT_EQ(64, resrvs.first->second.getPrefixLen());
+ EXPECT_EQ(64U, resrvs.first->second.getPrefixLen());
EXPECT_TRUE(host->getHostname().empty());
EXPECT_TRUE(host->getClientClasses4().empty());
EXPECT_TRUE(host->getClientClasses6().empty());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- EXPECT_EQ(2, saved_attrs->size());
+ EXPECT_EQ(2U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
EXPECT_FALSE(impl_.auth_->requests6_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get6Any(SUBNET_ID_GLOBAL,
impl_.id_type6_,
&id[0], id.size());
resrvs = host->getIPv6Reservations(IPv6Resrv::TYPE_PD);
ASSERT_EQ(1, std::distance(resrvs.first, resrvs.second));
EXPECT_EQ("2001:db8:1::", resrvs.first->second.getPrefix().toText());
- EXPECT_EQ(64, resrvs.first->second.getPrefixLen());
+ EXPECT_EQ(64U, resrvs.first->second.getPrefixLen());
EXPECT_TRUE(host->getHostname().empty());
EXPECT_TRUE(host->getClientClasses4().empty());
EXPECT_TRUE(host->getClientClasses6().empty());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- EXPECT_EQ(2, saved_attrs->size());
+ EXPECT_EQ(2U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
EXPECT_FALSE(impl_.auth_->requests4_.get(id));
EXPECT_FALSE(pkt);
EXPECT_FALSE(drop);
- EXPECT_EQ(1, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(1U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
ConstHostPtr host = HostMgr::instance().get4Any(1, impl_.id_type4_,
&id[0], id.size());
ASSERT_TRUE(host);
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
this_thread::sleep_for(1ms);
}
EXPECT_EQ(expected_received_, unparked_);
- EXPECT_EQ(0, ServerHooks::getServerHooks().getParkingLotPtr("subnet4_select")->size());
+ EXPECT_EQ(0U, ServerHooks::getServerHooks().getParkingLotPtr("subnet4_select")->size());
// Join threads.
EXPECT_NO_THROW_LOG(thread_pool_.wait());
EXPECT_NO_THROW_LOG(impl_.udp_client_->stop());
// Half should be parked and then unparked. Half should be dropped.
- EXPECT_EQ(0, steps_[CalloutHandle::NEXT_STEP_CONTINUE]);
- EXPECT_EQ(0, steps_[CalloutHandle::NEXT_STEP_SKIP]);
- EXPECT_EQ(0, steps_[CalloutHandle::NEXT_STEP_DROP]);
+ EXPECT_EQ(0U, steps_[CalloutHandle::NEXT_STEP_CONTINUE]);
+ EXPECT_EQ(0U, steps_[CalloutHandle::NEXT_STEP_SKIP]);
+ EXPECT_EQ(0U, steps_[CalloutHandle::NEXT_STEP_DROP]);
EXPECT_EQ(expected_received_, steps_[CalloutHandle::NEXT_STEP_PARK]);
EXPECT_EQ(expected_received_, unparked_);
this_thread::sleep_for(1ms);
}
EXPECT_EQ(expected_received_, unparked_);
- EXPECT_EQ(0, ServerHooks::getServerHooks().getParkingLotPtr("subnet6_select")->size());
+ EXPECT_EQ(0U, ServerHooks::getServerHooks().getParkingLotPtr("subnet6_select")->size());
// Join threads.
EXPECT_NO_THROW_LOG(thread_pool_.wait());
EXPECT_NO_THROW_LOG(impl_.udp_client_->stop());
// Half should be parked and then unparked. Half should be dropped.
- EXPECT_EQ(0, steps_[CalloutHandle::NEXT_STEP_CONTINUE]);
- EXPECT_EQ(0, steps_[CalloutHandle::NEXT_STEP_SKIP]);
- EXPECT_EQ(0, steps_[CalloutHandle::NEXT_STEP_DROP]);
+ EXPECT_EQ(0U, steps_[CalloutHandle::NEXT_STEP_CONTINUE]);
+ EXPECT_EQ(0U, steps_[CalloutHandle::NEXT_STEP_SKIP]);
+ EXPECT_EQ(0U, steps_[CalloutHandle::NEXT_STEP_DROP]);
EXPECT_EQ(expected_received_, steps_[CalloutHandle::NEXT_STEP_PARK]);
EXPECT_EQ(expected_received_, unparked_);
uint32_t id = 14;
bool both = false;
EXPECT_FALSE(RadiusAccess::reselectSubnet(query, id, both, "foo"));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
// Retrying using global reservations.
subnet->setReservationsGlobal(true);
subnet->setReservationsInSubnet(false);
EXPECT_FALSE(RadiusAccess::reselectSubnet(query, id, both, "foo"));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
}
uint32_t id = 13;
bool both = false;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, "foo"));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
// Retrying using global reservations.
subnet1->setReservationsInSubnet(false);
id = 13;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, "foo"));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
// Both subnets.
subnet2->setReservationsInSubnet(false);
id = 13;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, "foo"));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_TRUE(both);
// Last case.
subnet1->setReservationsOutOfPool(false);
id = 13;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, "foo"));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
}
uint32_t id = 14;
bool both = false;
EXPECT_FALSE(RadiusAccess::reselectSubnet(query, id, both, "foo"));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
// Retrying using global reservations.
subnet->setReservationsGlobal(true);
subnet->setReservationsInSubnet(false);
EXPECT_FALSE(RadiusAccess::reselectSubnet(query, id, both, "foo"));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
}
uint32_t id = 13;
bool both = false;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, "foo"));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
// Retrying using global reservations.
subnet1->setReservationsInSubnet(false);
id = 13;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, "foo"));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
// Both subnets.
subnet2->setReservationsInSubnet(false);
id = 13;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, "foo"));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_TRUE(both);
// Last case.
subnet1->setReservationsOutOfPool(false);
id = 13;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, "foo"));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
}
uint32_t id = 14;
bool both = false;
EXPECT_FALSE(RadiusAccess::reselectSubnet(query, id, both, addr));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
// Retrying using global reservations.
subnet->setReservationsGlobal(true);
subnet->setReservationsInSubnet(false);
EXPECT_FALSE(RadiusAccess::reselectSubnet(query, id, both, addr));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
}
uint32_t id = 13;
bool both = false;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, addr));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
// Retrying using global reservations.
subnet1->setReservationsInSubnet(false);
id = 13;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, addr));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
// Both subnets.
subnet2->setReservationsInSubnet(false);
id = 13;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, addr));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_TRUE(both);
// Last case.
subnet1->setReservationsOutOfPool(false);
id = 13;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, addr));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
}
uint32_t id = 14;
bool both = false;
EXPECT_FALSE(RadiusAccess::reselectSubnet(query, id, both, addr));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
// Retrying using global reservations.
subnet->setReservationsGlobal(true);
subnet->setReservationsInSubnet(false);
EXPECT_FALSE(RadiusAccess::reselectSubnet(query, id, both, addr));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
}
uint32_t id = 13;
bool both = false;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, addr));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
// Retrying using global reservations.
subnet1->setReservationsInSubnet(false);
id = 13;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, addr));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
// Both subnets.
subnet2->setReservationsInSubnet(false);
id = 13;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, addr));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_TRUE(both);
// Last case.
subnet1->setReservationsOutOfPool(false);
id = 13;
EXPECT_TRUE(RadiusAccess::reselectSubnet(query, id, both, addr));
- EXPECT_EQ(14, id);
+ EXPECT_EQ(14U, id);
EXPECT_FALSE(both);
}
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(2, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(2U, cache_->size());
// Check reselect host entry.
ConstHostPtr host = HostMgr::instance().get4Any(13, impl_.id_type4_,
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(13, host->getIPv4SubnetID());
+ EXPECT_EQ(13U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
// Check class host entry.
host = HostMgr::instance().get4Any(14, impl_.id_type4_, &id[0], id.size());
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(14, host->getIPv4SubnetID());
+ EXPECT_EQ(14U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(query->inClass("foo"));
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(2, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(2U, cache_->size());
// Check reselect host entry.
ConstHostPtr host = HostMgr::instance().get4Any(SUBNET_ID_GLOBAL,
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
// Check class host entry.
host = HostMgr::instance().get4Any(14, impl_.id_type4_, &id[0], id.size());
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(14, host->getIPv4SubnetID());
+ EXPECT_EQ(14U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(query->inClass("foo"));
}
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(2, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(2U, cache_->size());
// Check reselect host entry.
ConstHostPtr host = HostMgr::instance().get4Any(13, impl_.id_type4_,
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(13, host->getIPv4SubnetID());
+ EXPECT_EQ(13U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
// Check class host entry.
host = HostMgr::instance().get4Any(SUBNET_ID_GLOBAL,
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(query->inClass("foo"));
}
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
// Check merged host entry.
ConstHostPtr host = HostMgr::instance().get4Any(SUBNET_ID_GLOBAL,
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(query->inClass("foo"));
}
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(2, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(2U, cache_->size());
// Check reselect host entry.
ConstHostPtr host = HostMgr::instance().get6Any(13, impl_.id_type6_,
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(13, host->getIPv6SubnetID());
+ EXPECT_EQ(13U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_TRUE(host->getHostname().empty());
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
// Check class host entry.
host = HostMgr::instance().get6Any(14, impl_.id_type6_, &id[0], id.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(14, host->getIPv6SubnetID());
+ EXPECT_EQ(14U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_TRUE(host->getHostname().empty());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(query->inClass("foo"));
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(2, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(2U, cache_->size());
// Check reselect host entry.
ConstHostPtr host = HostMgr::instance().get6Any(SUBNET_ID_GLOBAL,
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
// Check class host entry.
host = HostMgr::instance().get6Any(14, impl_.id_type6_, &id[0], id.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(14, host->getIPv6SubnetID());
+ EXPECT_EQ(14U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_TRUE(host->getHostname().empty());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(query->inClass("foo"));
}
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(2, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(2U, cache_->size());
// Check reselect host entry.
ConstHostPtr host = HostMgr::instance().get6Any(13, impl_.id_type6_,
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(13, host->getIPv6SubnetID());
+ EXPECT_EQ(13U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_TRUE(host->getHostname().empty());
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
// Check class host entry.
host = HostMgr::instance().get6Any(SUBNET_ID_GLOBAL,
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(query->inClass("foo"));
}
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
// Check merged host entry.
ConstHostPtr host = HostMgr::instance().get6Any(SUBNET_ID_GLOBAL,
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(query->inClass("foo"));
}
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(2, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(2U, cache_->size());
// Check reselect host entry.
ConstHostPtr host = HostMgr::instance().get4Any(13, impl_.id_type4_,
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(13, host->getIPv4SubnetID());
+ EXPECT_EQ(13U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
// Check class host entry.
host = HostMgr::instance().get4Any(14, impl_.id_type4_, &id[0], id.size());
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(14, host->getIPv4SubnetID());
+ EXPECT_EQ(14U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.1", host->getIPv4Reservation().toText());
EXPECT_FALSE(host->hasIPv6Reservation());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(query->inClass("foo"));
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(2, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(2U, cache_->size());
// Check reselect host entry.
ConstHostPtr host = HostMgr::instance().get4Any(SUBNET_ID_GLOBAL,
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
// Check class host entry.
host = HostMgr::instance().get4Any(14, impl_.id_type4_, &id[0], id.size());
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(14, host->getIPv4SubnetID());
+ EXPECT_EQ(14U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.1", host->getIPv4Reservation().toText());
EXPECT_FALSE(host->hasIPv6Reservation());
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(query->inClass("foo"));
}
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(2, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(2U, cache_->size());
// Check reselect host entry.
ConstHostPtr host = HostMgr::instance().get4Any(13, impl_.id_type4_,
ASSERT_EQ(id.size(), hid.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type4_, host->getIdentifierType());
- EXPECT_EQ(13, host->getIPv4SubnetID());
+ EXPECT_EQ(13U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
// Check class host entry.
host = HostMgr::instance().get4Any(SUBNET_ID_GLOBAL,
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(query->inClass("foo"));
}
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
// Check merged host entry.
ConstHostPtr host = HostMgr::instance().get4Any(SUBNET_ID_GLOBAL,
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
EXPECT_TRUE(query->inClass("foo"));
}
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(2, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(2U, cache_->size());
// Check reselect host entry.
ConstHostPtr host = HostMgr::instance().get6Any(13, impl_.id_type6_,
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(13, host->getIPv6SubnetID());
+ EXPECT_EQ(13U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_TRUE(host->getHostname().empty());
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
// Check class host entry.
host = HostMgr::instance().get6Any(14, impl_.id_type6_, &id[0], id.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(14, host->getIPv6SubnetID());
+ EXPECT_EQ(14U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_TRUE(host->hasIPv6Reservation());
IPv6ResrvRange resrvs = host->getIPv6Reservations();
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
// There should be no global host entry.
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(2, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(2U, cache_->size());
// Check reselect host entry.
ConstHostPtr host = HostMgr::instance().get6Any(SUBNET_ID_GLOBAL,
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
// Check class host entry.
host = HostMgr::instance().get6Any(14, impl_.id_type6_, &id[0], id.size());
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(14, host->getIPv6SubnetID());
+ EXPECT_EQ(14U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_TRUE(host->hasIPv6Reservation());
IPv6ResrvRange resrvs = host->getIPv6Reservations();
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(2, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(2U, cache_->size());
// Check reselect host entry.
ConstHostPtr host = HostMgr::instance().get6Any(13, impl_.id_type6_,
EXPECT_EQ(0, memcmp(&id[0], &hid[0], id.size()));
EXPECT_EQ(impl_.id_type6_, host->getIdentifierType());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv4SubnetID());
- EXPECT_EQ(13, host->getIPv6SubnetID());
+ EXPECT_EQ(13U, host->getIPv6SubnetID());
EXPECT_TRUE(host->getIPv4Reservation().isV4Zero());
EXPECT_FALSE(host->hasIPv6Reservation());
EXPECT_TRUE(host->getHostname().empty());
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
// Check class host entry.
host = HostMgr::instance().get6Any(SUBNET_ID_GLOBAL,
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
ASSERT_TRUE(pkt);
EXPECT_EQ(pkt, query);
EXPECT_FALSE(drop);
- EXPECT_EQ(14, env.subnet_id_);
- EXPECT_EQ(1, cache_->size());
+ EXPECT_EQ(14U, env.subnet_id_);
+ EXPECT_EQ(1U, cache_->size());
// Check merged host entry.
ConstHostPtr host = HostMgr::instance().get6Any(SUBNET_ID_GLOBAL,
ConstElementPtr reselected = ctx->get("subnet-id");
ASSERT_TRUE(reselected);
ASSERT_EQ(Element::integer, reselected->getType());
- EXPECT_EQ(14, SubnetID(reselected->intValue()));
+ EXPECT_EQ(14U, SubnetID(reselected->intValue()));
ConstElementPtr saved_attrs = ctx->get("radius");
ASSERT_TRUE(saved_attrs);
ASSERT_EQ(Element::list, saved_attrs->getType());
- ASSERT_EQ(1, saved_attrs->size());
+ ASSERT_EQ(1U, saved_attrs->size());
EXPECT_TRUE(*saved_attrs == *received->toElement());
}
// Start the core thread pool with 4 threads.
// Pause the thread pool and resume only after work items have
// been added to it to increase the chance of finding race conditions.
- EXPECT_EQ(4, impl_.thread_pool_size_);
+ EXPECT_EQ(4U, impl_.thread_pool_size_);
// Can't use ASSERT here.
EXPECT_TRUE(impl_.udp_client_);
if (impl_.udp_client_) {
- EXPECT_EQ(4, impl_.udp_client_->getThreadPoolSize());
+ EXPECT_EQ(4U, impl_.udp_client_->getThreadPoolSize());
}
EXPECT_NO_THROW_LOG(thread_pool_.start(impl_.thread_pool_size_));
EXPECT_NO_THROW_LOG(thread_pool_.pause());
ASSERT_TRUE(handler);
EXPECT_EQ(EVENT_CREATE, handler->env_.event_);
- EXPECT_EQ(4, handler->env_.subnet_id_);
+ EXPECT_EQ(4U, handler->env_.subnet_id_);
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_START, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with canonical hardware address.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr calling_station_id = attrs->get(PW_CALLING_STATION_ID);
ASSERT_TRUE(calling_station_id);
EXPECT_EQ("Calling-Station-Id='20-e5-2a-b8-15-14'",
calling_station_id->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with not duid client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with not pop0 client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with not printable client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with duid client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='05:06:07:08:09'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with printable duid client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='Foobar'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with pop0 client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with printable pop0 client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='Foobar'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works without client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(4, attrs->size());
+ ASSERT_LE(4U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='20:e5:2a:b8:15:14'", user_name->toText());
ConstAttributePtr calling_station_id = attrs->get(PW_CALLING_STATION_ID);
EXPECT_FALSE(calling_station_id);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with RENEW event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_ALIVE, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with EXPIRE event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_STOP, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with RELEASE event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_STOP, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with DECLINE event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_STOP, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with ADD event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_START, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with UPDATE event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_ALIVE, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4 lease works with DELete event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_STOP, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv4/ClientId can get the Class from host cache.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
ASSERT_TRUE(handler);
EXPECT_EQ(EVENT_CREATE, handler->env_.event_);
- EXPECT_EQ(4, handler->env_.subnet_id_);
+ EXPECT_EQ(4U, handler->env_.subnet_id_);
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_START, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 prefix lease works.
ASSERT_TRUE(handler);
EXPECT_EQ(EVENT_CREATE, handler->env_.event_);
- EXPECT_EQ(4, handler->env_.subnet_id_);
+ EXPECT_EQ(4U, handler->env_.subnet_id_);
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_START, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 lease works with canonical hardware address.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr calling_station_id = attrs->get(PW_CALLING_STATION_ID);
ASSERT_TRUE(calling_station_id);
EXPECT_EQ("Calling-Station-Id='20-e5-2a-b8-15-14'",
calling_station_id->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 lease works with not pop0 duid.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 lease works with pop0 duid.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 lease works with printable duid.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='Foobar'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 lease works with printable pop0 duid.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='Foobar'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 lease works with RENEW event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_ALIVE, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 lease works with EXPIRE event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_STOP, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 lease works with RELEASE event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_STOP, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 lease works with DECLINE event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_STOP, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 lease works with ADD event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_START, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 lease works with UPDATE event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_ALIVE, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6 lease works with DELete event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_STOP, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct on IPv6/DUID can get the Class from host cache.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
// EXPECT_EQ(xxx, handler->env_.session_id_);
EXPECT_EQ(EVENT_ADD, handler->env_.event_);
- EXPECT_EQ(4, handler->env_.subnet_id_);
+ EXPECT_EQ(4U, handler->env_.subnet_id_);
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_START, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct4 requires address.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr calling_station_id = attrs->get(PW_CALLING_STATION_ID);
ASSERT_TRUE(calling_station_id);
EXPECT_EQ("Calling-Station-Id='20-e5-2a-b8-15-14'",
calling_station_id->toText());
ConstAttributePtr framed_ip_address = attrs->get(PW_FRAMED_IP_ADDRESS);
EXPECT_EQ("Framed-IP-Address=192.0.2.1", framed_ip_address->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct4 works with no pop0 client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct4 works with not printable client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct4 works with pop0 client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct4 works with printable client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='Foobar'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct4 works with printable pop0 client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='Foobar'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct4 works without force-create.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_ALIVE, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct4 works without client-id.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(4, attrs->size());
+ ASSERT_LE(4U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='20:e5:2a:b8:15:14'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct4 works without client-id and with canonical.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(4, attrs->size());
+ ASSERT_LE(4U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='20-e5-2a-b8-15-14'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct4 works with UPDATE event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_ALIVE, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct4 works with DELete event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_STOP, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct4 on ClientId can get the Class from host cache.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
ASSERT_TRUE(handler);
EXPECT_EQ(EVENT_ADD, handler->env_.event_);
- EXPECT_EQ(4, handler->env_.subnet_id_);
+ EXPECT_EQ(4U, handler->env_.subnet_id_);
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_START, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 works with a prefix.
ASSERT_TRUE(handler);
EXPECT_EQ(EVENT_ADD, handler->env_.event_);
- EXPECT_EQ(4, handler->env_.subnet_id_);
+ EXPECT_EQ(4U, handler->env_.subnet_id_);
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_START, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 requires address.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr framed_ip_address = attrs->get(PW_FRAMED_IPV6_ADDRESS);
ASSERT_TRUE(framed_ip_address);
EXPECT_EQ("Framed-IPv6-Address=2001:db8::1235",
framed_ip_address->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 works with prefix.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr delegated_prefix = attrs->get(PW_DELEGATED_IPV6_PREFIX);
ASSERT_TRUE(delegated_prefix);
EXPECT_EQ("Delegated-IPv6-Prefix=2001:db8::/64",
delegated_prefix->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 works with canonical.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr calling_station_id = attrs->get(PW_CALLING_STATION_ID);
ASSERT_TRUE(calling_station_id);
EXPECT_EQ("Calling-Station-Id='20-e5-2a-b8-15-14'",
ConstAttributePtr framed_ip_address = attrs->get(PW_FRAMED_IPV6_ADDRESS);
EXPECT_EQ("Framed-IPv6-Address=2001:db8::1235",
framed_ip_address->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 works with no pop0 duid.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 works with not printable duid.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 works with pop0 duid.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='01:02:03:04'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 works with printable duid.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='Foobar'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 works with printable pop0 duid.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr user_name = attrs->get(PW_USER_NAME);
ASSERT_TRUE(user_name);
EXPECT_EQ("User-Name='Foobar'", user_name->toText());
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 works without force-create.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_ALIVE, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 works with UPDATE event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_ALIVE, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 works with DELete event.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(5, attrs->size());
+ ASSERT_LE(5U, attrs->size());
ConstAttributePtr status_type = attrs->get(PW_ACCT_STATUS_TYPE);
ASSERT_TRUE(status_type);
uint32_t lvalue = 111;
EXPECT_NO_THROW(lvalue = status_type->toInt());
EXPECT_EQ(PW_STATUS_STOP, lvalue);
- EXPECT_EQ(0, attrs->count(PW_CLASS));
+ EXPECT_EQ(0U, attrs->count(PW_CLASS));
}
/// Verify that buildAcct6 on DUID can get the Class from host cache.
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
AttributesPtr attrs = handler->env_.send_attrs_;
ASSERT_TRUE(attrs);
- ASSERT_LE(6, attrs->size());
+ ASSERT_LE(6U, attrs->size());
ConstAttributePtr cclass = attrs->get(PW_CLASS);
ASSERT_TRUE(cclass);
EXPECT_EQ("Class='foobar'", cclass->toText());
handle.setArgument("arguments", arguments);
handle.setArgument("response", response);
- EXPECT_EQ(0, service_->pollOne());
+ EXPECT_EQ(0U, service_->pollOne());
int ret(-1);
EXPECT_NO_THROW_LOG(ret = command_processed(handle));
handle.setArgument("arguments", arguments);
handle.setArgument("response", response);
- EXPECT_EQ(0, service_->pollOne());
+ EXPECT_EQ(0U, service_->pollOne());
int ret(-1);
EXPECT_NO_THROW_LOG(ret = command_processed(handle));
handle.setArgument("arguments", arguments);
handle.setArgument("response", response);
- EXPECT_EQ(0, service_->pollOne());
+ EXPECT_EQ(0U, service_->pollOne());
int ret(-1);
EXPECT_NO_THROW_LOG(ret = command_processed(handle));
handle.setArgument("arguments", arguments);
handle.setArgument("response", response);
- EXPECT_EQ(0, service_->pollOne());
+ EXPECT_EQ(0U, service_->pollOne());
int ret(-1);
EXPECT_NO_THROW_LOG(ret = command_processed(handle));
handle.setArgument("arguments", ConstElementPtr());
handle.setArgument("response", ConstElementPtr());
- EXPECT_EQ(0, service_->pollOne());
+ EXPECT_EQ(0U, service_->pollOne());
int ret(-1);
EXPECT_NO_THROW_LOG(ret = command_processed(handle));
waitForServerToFinish();
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_START, status_types_[0]);
}
TEST_F(AccountingTest, lease4Renew) {
waitForServerToFinish();
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_ALIVE, status_types_[0]);
}
TEST_F(AccountingTest, lease4Release) {
waitForServerToFinish();
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_STOP, status_types_[0]);
}
TEST_F(AccountingTest, lease4Decline) {
waitForServerToFinish();
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_STOP, status_types_[0]);
}
TEST_F(AccountingTest, lease4Expire) {
waitForServerToFinish();
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_STOP, status_types_[0]);
}
TEST_F(AccountingTest, lease6SelectFake) {
waitForServerToFinish();
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_START, status_types_[0]);
}
TEST_F(AccountingTest, lease6Renew) {
waitForServerToFinish();
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_ALIVE, status_types_[0]);
}
TEST_F(AccountingTest, lease6Release) {
waitForServerToFinish();
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_STOP, status_types_[0]);
}
TEST_F(AccountingTest, lease6Decline) {
waitForServerToFinish();
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_STOP, status_types_[0]);
}
TEST_F(AccountingTest, lease6Expire) {
waitForServerToFinish();
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_STOP, status_types_[0]);
}
TEST_F(AccountingTest, commandProcessed) {
// The mocked accounting request should have been sent, effectively
// setting the status type.
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_ALIVE, status_types_[0]);
}
TEST_F(AccountingTest, commandProcessedNoOrigin) {
// The mocked accounting request should have been sent, effectively
// setting the status type.
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_ALIVE, status_types_[0]);
}
TEST_F(AccountingTest, commandProcessedNullArguments) {
waitForServerToFinish();
// No accounting request should have been called. There should be no status type.
- ASSERT_EQ(0, status_types_.size());
+ ASSERT_EQ(0U, status_types_.size());
}
TEST_F(AccountingTest, noPeerUpdates) {
impl_.acct_->peer_updates_ = false;
waitForServerToFinish();
// No accounting request should have been called. There should be no status type.
- ASSERT_EQ(0, status_types_.size());
+ ASSERT_EQ(0U, status_types_.size());
}
TEST_F(AccountingTest, noPeerUpdatesNoOrigin) {
impl_.acct_->peer_updates_ = false;
// The mocked accounting request should have been sent, effectively
// setting the status type.
- ASSERT_EQ(1, status_types_.size());
+ ASSERT_EQ(1U, status_types_.size());
EXPECT_EQ(PW_STATUS_ALIVE, status_types_[0]);
}
waitForServerToFinish();
// No accounting request should have been called. There should be no status type.
- ASSERT_EQ(0, status_types_.size());
+ ASSERT_EQ(0U, status_types_.size());
}
TEST_F(MTAccountingTest, noPeerUpdates) {
impl_.acct_->peer_updates_ = false;
waitForServerToFinish();
// No accounting request should have been called. There should be no status type.
- ASSERT_EQ(0, status_types_.size());
+ ASSERT_EQ(0U, status_types_.size());
}
TEST_F(MTAccountingTest, noPeerUpdatesNoOrigin) {
impl_.acct_->peer_updates_ = false;
AttributeTest() : host_mgr_(isc::dhcp::HostMgr::instance()) {
uint32_t vendor = 0;
AttrDefs::instance().readDictionary(TEST_DICTIONARY, vendor);
- EXPECT_EQ(0, vendor);
+ EXPECT_EQ(0U, vendor);
}
/// @brief Destructor.
// Using User-Name (1) string attribute.
AttrDefPtr def = AttrDefs::instance().getByType(PW_USER_NAME);
ASSERT_TRUE(def);
- EXPECT_EQ(1, def->type_);
+ EXPECT_EQ(1U, def->type_);
EXPECT_EQ(PW_TYPE_STRING, def->value_type_);
AttributePtr attr;
ASSERT_NO_THROW(attr = Attribute::fromString(PW_USER_NAME, "foobar"));
ASSERT_TRUE(attr);
- EXPECT_EQ(1, attr->getType());
+ EXPECT_EQ(1U, attr->getType());
EXPECT_EQ(PW_TYPE_STRING, attr->getValueType());
string to_string;
EXPECT_NO_THROW_LOG(to_string = attr->toString());
ASSERT_NO_THROW(attr = Attribute::fromString(PW_USER_NAME, "\x01\x02\x03"));
ASSERT_TRUE(attr);
- EXPECT_EQ(1, attr->getType());
+ EXPECT_EQ(1U, attr->getType());
EXPECT_EQ(PW_TYPE_STRING, attr->getValueType());
string to_string;
EXPECT_NO_THROW_LOG(to_string = attr->toString());
// Using NAS-Port-Type (61) integer attribute.
AttrDefPtr def = AttrDefs::instance().getByType(PW_NAS_PORT_TYPE);
ASSERT_TRUE(def);
- EXPECT_EQ(61, def->type_);
+ EXPECT_EQ(61U, def->type_);
EXPECT_EQ(PW_TYPE_INTEGER, def->value_type_);
AttributePtr attr;
ASSERT_NO_THROW(attr = Attribute::fromInt(61, 15));
ASSERT_TRUE(attr);
- EXPECT_EQ(61, attr->getType());
+ EXPECT_EQ(61U, attr->getType());
EXPECT_EQ(PW_TYPE_INTEGER, attr->getValueType());
uint32_t to_int;
EXPECT_NO_THROW_LOG(to_int = attr->toInt());
- EXPECT_EQ(15, to_int);
+ EXPECT_EQ(15U, to_int);
EXPECT_EQ("NAS-Port-Type=Ethernet", attr->toText());
vector<uint8_t> binary = { 61, 6, 0, 0, 0, 15 };
EXPECT_EQ(binary, attr->toBytes());
// Using Framed-IP-Address (8) IP address attribute.
AttrDefPtr def = AttrDefs::instance().getByType(PW_FRAMED_IP_ADDRESS);
ASSERT_TRUE(def);
- EXPECT_EQ(8, def->type_);
+ EXPECT_EQ(8U, def->type_);
EXPECT_EQ(PW_TYPE_IPADDR, def->value_type_);
AttributePtr attr;
ASSERT_NO_THROW(attr = Attribute::fromIpAddr(8, IOAddress("192.0.2.1")));
ASSERT_TRUE(attr);
- EXPECT_EQ(8, attr->getType());
+ EXPECT_EQ(8U, attr->getType());
EXPECT_EQ(PW_TYPE_IPADDR, attr->getValueType());
IOAddress addr("0.0.0.0");
EXPECT_NO_THROW_LOG(addr = attr->toIpAddr());
// Using Framed-IPv6-Address (168) IPv6 address attribute.
AttrDefPtr def = AttrDefs::instance().getByType(PW_FRAMED_IPV6_ADDRESS);
ASSERT_TRUE(def);
- EXPECT_EQ(168, def->type_);
+ EXPECT_EQ(168U, def->type_);
EXPECT_EQ(PW_TYPE_IPV6ADDR, def->value_type_);
AttributePtr attr;
ASSERT_NO_THROW(attr = Attribute::fromIpv6Addr(168,
IOAddress("2001:db8::1235")));
ASSERT_TRUE(attr);
- EXPECT_EQ(168, attr->getType());
+ EXPECT_EQ(168U, attr->getType());
EXPECT_EQ(PW_TYPE_IPV6ADDR, attr->getValueType());
IOAddress addr("::");
EXPECT_NO_THROW_LOG(addr = attr->toIpv6Addr());
// Using Delegated-IPv6-Prefix (123) IPv6 prefix attribute.
AttrDefPtr def = AttrDefs::instance().getByType(PW_DELEGATED_IPV6_PREFIX);
ASSERT_TRUE(def);
- EXPECT_EQ(123, def->type_);
+ EXPECT_EQ(123U, def->type_);
EXPECT_EQ(PW_TYPE_IPV6PREFIX, def->value_type_);
AttributePtr attr;
ASSERT_NO_THROW(attr = Attribute::fromIpv6Prefix(123, 128,
IOAddress("2001:db8::1235")));
ASSERT_TRUE(attr);
- EXPECT_EQ(123, attr->getType());
+ EXPECT_EQ(123U, attr->getType());
EXPECT_EQ(PW_TYPE_IPV6PREFIX, attr->getValueType());
IOAddress addr("::");
EXPECT_NO_THROW_LOG(addr = attr->toIpv6Prefix());
EXPECT_EQ("2001:db8::1235", addr.toText());
uint8_t len = 0;
EXPECT_NO_THROW_LOG(len = attr->toIpv6PrefixLen());
- EXPECT_EQ(128, len);
+ EXPECT_EQ(128U, len);
EXPECT_EQ("Delegated-IPv6-Prefix=2001:db8::1235/128", attr->toText());
vector<uint8_t> binary = { 123, 20, 0, 128,
0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
// Using Vector-Specific (26) *only* vsa attribute.
AttrDefPtr def = AttrDefs::instance().getByType(PW_VENDOR_SPECIFIC);
ASSERT_TRUE(def);
- EXPECT_EQ(26, def->type_);
+ EXPECT_EQ(26U, def->type_);
EXPECT_EQ(PW_TYPE_VSA, def->value_type_);
AttributePtr attr;
1234, "foobar"));
ASSERT_TRUE(attr);
- EXPECT_EQ(26, attr->getType());
+ EXPECT_EQ(26U, attr->getType());
EXPECT_EQ(PW_TYPE_VSA, attr->getValueType());
uint32_t vendor = 0;
ASSERT_NO_THROW(vendor = attr->toVendorId());
- EXPECT_EQ(1234, vendor);
+ EXPECT_EQ(1234U, vendor);
EXPECT_EQ("Vendor-Specific=[1234]0x666F6F626172", attr->toText());
vector<uint8_t> binary = { 26, 12, 0, 0, 0x04, 0xd2,
0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72 };
ASSERT_TRUE(attr);
EXPECT_EQ(PW_VENDOR_SPECIFIC, attr->getType());
EXPECT_EQ(PW_TYPE_VSA, attr->getValueType());
- EXPECT_EQ(3561, attr->toVendorId());
- EXPECT_EQ(12, attr->getValueLen());
+ EXPECT_EQ(3561U, attr->toVendorId());
+ EXPECT_EQ(12U, attr->getValueLen());
vector<uint8_t> vsa_data = { 1, 8, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72 };
EXPECT_EQ(vsa_data, attr->toVsaData());
}
ASSERT_TRUE(attr);
EXPECT_EQ(PW_VENDOR_SPECIFIC, attr->getType());
EXPECT_EQ(PW_TYPE_VSA, attr->getValueType());
- EXPECT_EQ(3561, attr->toVendorId());
- EXPECT_EQ(9, attr->getValueLen());
+ EXPECT_EQ(3561U, attr->toVendorId());
+ EXPECT_EQ(9U, attr->getValueLen());
vector<uint8_t> vsa_data = { 144, 5, 2, 0, 0 };
EXPECT_EQ(vsa_data, attr->toVsaData());
}
TEST_F(AttributeTest, attributesBasic) {
Attributes attrs;
EXPECT_TRUE(attrs.empty());
- EXPECT_EQ(0, attrs.size());
+ EXPECT_EQ(0U, attrs.size());
// Add a string attribute.
ASSERT_NO_THROW(attrs.add(Attribute::fromString(1, "foobar")));
EXPECT_FALSE(attrs.empty());
- EXPECT_EQ(1, attrs.size());
+ EXPECT_EQ(1U, attrs.size());
// Add an integer attribute.
ASSERT_NO_THROW(attrs.add(Attribute::fromInt(6, 2)));
EXPECT_FALSE(attrs.empty());
- EXPECT_EQ(2, attrs.size());
+ EXPECT_EQ(2U, attrs.size());
// Clear.
attrs.clear();
EXPECT_TRUE(attrs.empty());
- EXPECT_EQ(0, attrs.size());
+ EXPECT_EQ(0U, attrs.size());
}
// Verifies attributes can be added and deleted.
TEST_F(AttributeTest, attributesAddDel) {
Attributes attrs;
EXPECT_TRUE(attrs.empty());
- EXPECT_EQ(0, attrs.size());
+ EXPECT_EQ(0U, attrs.size());
// Add 3 User-Name and a Service-Type.
ASSERT_NO_THROW(attrs.add(Attribute::fromString(PW_USER_NAME, "foobar")));
ASSERT_NO_THROW(attrs.add(Attribute::fromString(PW_USER_NAME, "bar")));
// Verify counts.
- EXPECT_EQ(4, attrs.size());
- EXPECT_EQ(3, attrs.count(PW_USER_NAME));
- EXPECT_EQ(1, attrs.count(PW_SERVICE_TYPE));
- EXPECT_EQ(0, attrs.count(PW_FRAMED_IP_ADDRESS));
+ EXPECT_EQ(4U, attrs.size());
+ EXPECT_EQ(3U, attrs.count(PW_USER_NAME));
+ EXPECT_EQ(1U, attrs.count(PW_SERVICE_TYPE));
+ EXPECT_EQ(0U, attrs.count(PW_FRAMED_IP_ADDRESS));
// Gets.
ConstAttributePtr attr;
ASSERT_TRUE(attr);
EXPECT_EQ(PW_SERVICE_TYPE, attr->getType());
EXPECT_EQ(PW_TYPE_INTEGER, attr->getValueType());
- EXPECT_EQ(20, attr->toInt());
+ EXPECT_EQ(20U, attr->toInt());
attr.reset();
ASSERT_NO_THROW(attr = attrs.get(PW_FRAMED_IP_ADDRESS));
EXPECT_FALSE(attr);
EXPECT_TRUE(attrs.del(PW_SERVICE_TYPE));
EXPECT_TRUE(attrs.del(PW_USER_NAME));
EXPECT_FALSE(attrs.del(PW_SERVICE_TYPE));
- EXPECT_EQ(1, attrs.count(PW_USER_NAME));
+ EXPECT_EQ(1U, attrs.count(PW_USER_NAME));
EXPECT_TRUE(attrs.del(PW_USER_NAME));
EXPECT_FALSE(attrs.del(PW_USER_NAME));
EXPECT_TRUE(attrs.empty());
- EXPECT_EQ(0, attrs.size());
+ EXPECT_EQ(0U, attrs.size());
}
// Verifies add front.
TEST_F(AttributeTest, attributesAddFront) {
Attributes attrs;
EXPECT_TRUE(attrs.empty());
- EXPECT_EQ(0, attrs.size());
+ EXPECT_EQ(0U, attrs.size());
// Add 2 User-Name and a Service-Type at the front.
ASSERT_NO_THROW(attrs.add(Attribute::fromString(PW_USER_NAME, "foobar")));
ASSERT_NO_THROW(attrs.add(Attribute::fromInt(PW_SERVICE_TYPE, 20), false));
// Get front.
- ASSERT_EQ(3, attrs.size());
+ ASSERT_EQ(3U, attrs.size());
ConstAttributePtr attr = *(attrs.begin());
ASSERT_TRUE(attr);
EXPECT_EQ(PW_SERVICE_TYPE, attr->getType());
ASSERT_NO_THROW(attrs.add(Attribute::fromString(PW_USER_NAME, "foobar")));
ASSERT_NO_THROW(attrs.add(Attribute::fromString(PW_USER_NAME, "foo")));
ASSERT_NO_THROW(attrs.add(Attribute::fromInt(PW_SERVICE_TYPE, 20)));
- ASSERT_EQ(3, attrs.size());
+ ASSERT_EQ(3U, attrs.size());
attr = *(attrs.begin());
ASSERT_TRUE(attr);
EXPECT_EQ(PW_USER_NAME, attr->getType());
Attributes attrs1;
attrs1.add(Attribute::fromInt(PW_NAS_PORT, 123));
attrs1.add(Attribute::fromString(PW_USER_NAME, "me"));
- EXPECT_EQ(2, attrs.size());
- EXPECT_EQ(2, attrs1.size());
+ EXPECT_EQ(2U, attrs.size());
+ EXPECT_EQ(2U, attrs1.size());
ASSERT_NO_THROW(attrs.append(attrs1));
- EXPECT_EQ(4, attrs.size());
- EXPECT_EQ(2, attrs1.size());
- EXPECT_EQ(2, attrs.count(PW_USER_NAME));
+ EXPECT_EQ(4U, attrs.size());
+ EXPECT_EQ(2U, attrs1.size());
+ EXPECT_EQ(2U, attrs.count(PW_USER_NAME));
}
// Verifies parse and unparse.
vector<uint8_t> binary = { 1, 2, 3 };
ASSERT_NO_THROW(attrs.add(Attribute::fromBinary(PW_USER_NAME, binary)));
ASSERT_NO_THROW(attrs.add(Attribute::fromInt(PW_SERVICE_TYPE, 2)));
- EXPECT_EQ(3, attrs.size());
+ EXPECT_EQ(3U, attrs.size());
// toElement.
string expected = "[ { \"type\": 1, \"name\": \"User-Name\", \"data\": ";
EXPECT_NO_THROW(hosts =
back_->getAll(Host::IDENT_FLEX, &id[0], id.size()));
EXPECT_TRUE(hosts.empty());
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify that reservation-get-all* returns an empty collection.
addr = IOAddress("2001:db8::1235");
EXPECT_NO_THROW(hosts = back_->getAll4(addr));
EXPECT_TRUE(hosts.empty());
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify that get4 by subnet and address return null host.
addr = IOAddress("2001:db8::1235");
EXPECT_NO_THROW(host = back_->get4(1, addr));
EXPECT_FALSE(host);
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify that get6 by prefix and length return null host.
addr = IOAddress("192.0.2.1");
EXPECT_NO_THROW(host = back_->get6(addr, 24));
EXPECT_FALSE(host);
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify that get6 by subnet and address return null host.
addr = IOAddress("192.0.2.1");
EXPECT_NO_THROW(host = back_->get6(1, addr));
EXPECT_FALSE(host);
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify that add does nothing.
Host::IDENT_DUID, true);
ASSERT_TRUE(host);
EXPECT_NO_THROW(back_->add(host));
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify that del always return false.
EXPECT_FALSE(result);
EXPECT_NO_THROW(result = back_->del(1, addr));
EXPECT_FALSE(result);
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify that del4 always return false.
EXPECT_NO_THROW(result =
back_->del4(1, Host::IDENT_FLEX, &id[0], id.size()));
EXPECT_FALSE(result);
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify that del6 always return false.
EXPECT_NO_THROW(result =
back_->del6(1, Host::IDENT_FLEX, &id[0], id.size()));
EXPECT_FALSE(result);
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify the backend type.
EXPECT_NO_THROW(host =
back_->get4(1, Host::IDENT_HWADDR, &id[0], id.size()));
EXPECT_FALSE(host);
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify get6 by subnet and id with a different type than the radius one.
EXPECT_NO_THROW(host =
back_->get6(1, Host::IDENT_HWADDR, &id[0], id.size()));
EXPECT_FALSE(host);
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify get4 by subnet and id called from the hook.
EXPECT_NO_THROW(host =
back_->get4(1, Host::IDENT_DUID, &id[0], id.size()));
EXPECT_FALSE(host);
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify get6 by subnet and id called from the hook.
EXPECT_NO_THROW(host =
back_->get6(1, Host::IDENT_DUID, &id[0], id.size()));
EXPECT_FALSE(host);
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify get4 by subnet and id called in an unexpected way, i.e.,
EXPECT_NO_THROW(host =
back_->get4(1, Host::IDENT_DUID, &id[0], id.size()));
EXPECT_FALSE(host);
- EXPECT_EQ(2, back_->getUnexpected4());
- EXPECT_EQ(0, back_->getUnexpected6());
+ EXPECT_EQ(2U, back_->getUnexpected4());
+ EXPECT_EQ(0U, back_->getUnexpected6());
}
/// Verify get6 by subnet and id called in an unexpected way, i.e.,
EXPECT_NO_THROW(host =
back_->get6(1, Host::IDENT_DUID, &id[0], id.size()));
EXPECT_FALSE(host);
- EXPECT_EQ(0, back_->getUnexpected4());
- EXPECT_EQ(2, back_->getUnexpected6());
+ EXPECT_EQ(0U, back_->getUnexpected4());
+ EXPECT_EQ(2U, back_->getUnexpected6());
}
/// Verify that the Radius backend does not support using non-unique
EXPECT_TRUE(impl_.canonical_mac_address_);
EXPECT_TRUE(impl_.clientid_pop0_);
EXPECT_TRUE(impl_.clientid_printable_);
- EXPECT_EQ(10, impl_.deadtime_);
+ EXPECT_EQ(10U, impl_.deadtime_);
EXPECT_EQ("/dev/null", impl_.dictionary_);
EXPECT_FALSE(impl_.extract_duid_);
EXPECT_EQ(Host::IDENT_HWADDR, impl_.id_type4_);
EXPECT_EQ(Host::IDENT_FLEX, impl_.id_type6_);
- EXPECT_EQ(5, impl_.retries_);
+ EXPECT_EQ(5U, impl_.retries_);
EXPECT_TRUE(impl_.reselect_subnet_address_);
EXPECT_TRUE(impl_.reselect_subnet_pool_);
EXPECT_EQ("/tmp/foobar", impl_.session_history_filename_);
- EXPECT_EQ(8, impl_.thread_pool_size_);
- EXPECT_EQ(12, impl_.timeout_);
+ EXPECT_EQ(8U, impl_.thread_pool_size_);
+ EXPECT_EQ(12U, impl_.timeout_);
EXPECT_FALSE(impl_.use_message_authenticator_);
EXPECT_TRUE(impl_.remap_.empty());
}
ports->add(entry);
config->set("nas-ports", ports);
EXPECT_NO_THROW(impl_.init(config));
- EXPECT_EQ(1, impl_.remap_.size());
- EXPECT_EQ(10, impl_.remap_[SUBNET_ID_DEFAULT]);
+ EXPECT_EQ(1U, impl_.remap_.size());
+ EXPECT_EQ(10U, impl_.remap_[SUBNET_ID_DEFAULT]);
// Subnet-id.
impl_.reset();
ports->add(entry);
config->set("nas-ports", ports);
EXPECT_NO_THROW(impl_.init(config));
- EXPECT_EQ(1, impl_.remap_.size());
- EXPECT_EQ(10, impl_.remap_[1]);
+ EXPECT_EQ(1U, impl_.remap_.size());
+ EXPECT_EQ(10U, impl_.remap_[1]);
// Subnet-prefix - IPv4.
impl_.reset();
ports->add(entry);
config->set("nas-ports", ports);
EXPECT_NO_THROW(impl_.init(config));
- EXPECT_EQ(1, impl_.remap_.size());
- EXPECT_EQ(10, impl_.remap_[1]);
+ EXPECT_EQ(1U, impl_.remap_.size());
+ EXPECT_EQ(10U, impl_.remap_[1]);
// Subnet-prefix - IPv6.
impl_.reset();
ports->add(entry);
config->set("nas-ports", ports);
EXPECT_NO_THROW(impl_.init(config));
- EXPECT_EQ(1, impl_.remap_.size());
- EXPECT_EQ(10, impl_.remap_[1]);
+ EXPECT_EQ(1U, impl_.remap_.size());
+ EXPECT_EQ(10U, impl_.remap_[1]);
// Shared-network - IPv4.
impl_.reset();
ports->add(entry);
config->set("nas-ports", ports);
EXPECT_NO_THROW(impl_.init(config));
- EXPECT_EQ(2, impl_.remap_.size());
- EXPECT_EQ(10, impl_.remap_[1]);
- EXPECT_EQ(10, impl_.remap_[2]);
+ EXPECT_EQ(2U, impl_.remap_.size());
+ EXPECT_EQ(10U, impl_.remap_[1]);
+ EXPECT_EQ(10U, impl_.remap_[2]);
// Shared-network - IPv6.
impl_.reset();
ports->add(entry);
config->set("nas-ports", ports);
EXPECT_NO_THROW(impl_.init(config));
- EXPECT_EQ(2, impl_.remap_.size());
- EXPECT_EQ(10, impl_.remap_[1]);
- EXPECT_EQ(10, impl_.remap_[2]);
+ EXPECT_EQ(2U, impl_.remap_.size());
+ EXPECT_EQ(10U, impl_.remap_[1]);
+ EXPECT_EQ(10U, impl_.remap_[2]);
// Error cases.
CfgMgr::instance().clear();
// Check state.
Servers srvs = impl_.acct_->servers_;
- ASSERT_EQ(2, srvs.size());
+ ASSERT_EQ(2U, srvs.size());
ServerPtr srv = srvs[0];
ASSERT_TRUE(srv);
EXPECT_EQ("127.0.0.1", srv->getPeerAddress().toText());
- EXPECT_EQ(16460, srv->getPeerPort());
+ EXPECT_EQ(16460U, srv->getPeerPort());
// Add auth too.
ElementPtr auth = Element::createMap();
// Check state.
srvs = impl_.auth_->servers_;
- ASSERT_EQ(2, srvs.size());
+ ASSERT_EQ(2U, srvs.size());
srv = srvs[0];
ASSERT_TRUE(srv);
EXPECT_EQ("127.0.0.1", srv->getPeerAddress().toText());
- EXPECT_EQ(16450, srv->getPeerPort());
+ EXPECT_EQ(16450U, srv->getPeerPort());
}
// Verify syntax of tls service.
config->set("tls", tls);
tls->set("idle-timer-interval", Element::create(60));
EXPECT_NO_THROW(impl_.init(config));
- EXPECT_EQ(60, impl_.tls_->idle_timer_interval_);
- EXPECT_EQ(0, impl_.auth_->idle_timer_interval_);
- EXPECT_EQ(0, impl_.acct_->idle_timer_interval_);
+ EXPECT_EQ(60U, impl_.tls_->idle_timer_interval_);
+ EXPECT_EQ(0U, impl_.auth_->idle_timer_interval_);
+ EXPECT_EQ(0U, impl_.acct_->idle_timer_interval_);
// Servers for tls require TLS.
ElementPtr servers = Element::createList();
// Get the option to look at into.
EXPECT_FALSE(srv->attributes_.empty());
- EXPECT_EQ(1, srv->attributes_.size());
+ EXPECT_EQ(1U, srv->attributes_.size());
EXPECT_TRUE(srv->attributes_.getDef(1));
EXPECT_FALSE(srv->attributes_.getExpr(1));
EXPECT_EQ("", srv->attributes_.getTest(1));
attr->set("type", Element::create(1));
EXPECT_NO_THROW(parser.parse(srv, attr));
EXPECT_FALSE(srv->attributes_.empty());
- EXPECT_EQ(1, srv->attributes_.size());
+ EXPECT_EQ(1U, srv->attributes_.size());
EXPECT_TRUE(srv->attributes_.getDef(1, 3561));
EXPECT_FALSE(srv->attributes_.getExpr(1, 3561));
EXPECT_EQ("", srv->attributes_.getTest(1, 3561));
srv->attributes_.clear();
attr->set("raw", Element::create("660102626172"));
EXPECT_NO_THROW(parser.parse(srv, attr));
- EXPECT_EQ(1, srv->attributes_.getAll().size());
+ EXPECT_EQ(1U, srv->attributes_.getAll().size());
EXPECT_FALSE(srv->attributes_.getExpr(1));
EXPECT_EQ("", srv->attributes_.getTest(1));
const ConstAttributePtr& firstr = srv->attributes_.get(1);
attr->set("type", Element::create(1));
EXPECT_NO_THROW(parser.parse(srv, attr));
EXPECT_FALSE(srv->attributes_.empty());
- EXPECT_EQ(1, srv->attributes_.size());
+ EXPECT_EQ(1U, srv->attributes_.size());
EXPECT_TRUE(srv->attributes_.getDef(1, 3561));
EXPECT_FALSE(srv->attributes_.getExpr(1, 3561));
EXPECT_EQ("", srv->attributes_.getTest(1, 3561));
// Try the 'foobar' expression.
attr->set("expr", Element::create("'foobar'"));
EXPECT_NO_THROW(parser.parse(srv, attr));
- EXPECT_EQ(1, srv->attributes_.size());
+ EXPECT_EQ(1U, srv->attributes_.size());
EXPECT_TRUE(srv->attributes_.getAll().empty());
ExpressionPtr expr = srv->attributes_.getExpr(1);
ASSERT_TRUE(expr);
- ASSERT_EQ(1, expr->size());
+ ASSERT_EQ(1U, expr->size());
TokenPtr token = (*expr)[0];
boost::shared_ptr<TokenString> tokstr =
boost::dynamic_pointer_cast<TokenString>(token);
attr->set("type", Element::create(1));
attr->set("expr", Element::create("'foobar'"));
EXPECT_NO_THROW(parser.parse(srv, attr));
- EXPECT_EQ(1, srv->attributes_.size());
+ EXPECT_EQ(1U, srv->attributes_.size());
EXPECT_TRUE(srv->attributes_.getDef(1, 3561));
EXPECT_FALSE(srv->attributes_.get(1, 3561));
EXPECT_TRUE(srv->attributes_.getAll().empty());
expr = srv->attributes_.getExpr(1, 3561);
ASSERT_TRUE(expr);
- ASSERT_EQ(1, expr->size());
+ ASSERT_EQ(1U, expr->size());
token = (*expr)[0];
tokstr = boost::dynamic_pointer_cast<TokenString>(token);
EXPECT_TRUE(tokstr);
Pkt4Ptr query(new Pkt4(DHCPDISCOVER, 12345));
Attributes evaluated;
EXPECT_NO_THROW_LOG(evaluated = srv->attributes_.getEvalAll(*query));
- EXPECT_EQ(1, evaluated.size());
+ EXPECT_EQ(1U, evaluated.size());
expected = "[ { "
" \"name\": \"Vendor-Specific\", "
" \"type\": 26, "
})");
EXPECT_NO_THROW_LOG(impl_.init(config));
ASSERT_TRUE(impl_.auth_);
- EXPECT_EQ(10, impl_.auth_->max_pending_requests_);
+ EXPECT_EQ(10U, impl_.auth_->max_pending_requests_);
EXPECT_NO_THROW_LOG(impl_.reset());
config = Element::createMap();
EXPECT_NO_THROW_LOG(impl_.init(config));
ASSERT_TRUE(impl_.auth_);
- EXPECT_EQ(0, impl_.auth_->max_pending_requests_);
+ EXPECT_EQ(0U, impl_.auth_->max_pending_requests_);
EXPECT_NO_THROW_LOG(impl_.reset());
config = Element::fromJSON(R"({
})");
EXPECT_NO_THROW_LOG(impl_.init(config));
ASSERT_TRUE(impl_.auth_);
- EXPECT_EQ(10, impl_.auth_->idle_timer_interval_);
+ EXPECT_EQ(10U, impl_.auth_->idle_timer_interval_);
EXPECT_NO_THROW_LOG(impl_.reset());
config = Element::createMap();
EXPECT_NO_THROW_LOG(impl_.init(config));
ASSERT_TRUE(impl_.auth_);
- EXPECT_EQ(0, impl_.auth_->idle_timer_interval_);
+ EXPECT_EQ(0U, impl_.auth_->idle_timer_interval_);
EXPECT_NO_THROW_LOG(impl_.reset());
}
uint32_t vendor = 0;
ASSERT_NO_THROW_LOG(AttrDefs::instance().readDictionary(TEST_DICTIONARY,
vendor));
- EXPECT_EQ(0, vendor);
+ EXPECT_EQ(0U, vendor);
}
// Verifies parseLine internal routine.
EXPECT_NO_THROW_LOG(parseLines(positive, 0, 3561));
auto aci = AttrDefs::instance().getByName("Agent-Circuit-Id", 3561);
ASSERT_TRUE(aci);
- EXPECT_EQ(1, aci->type_);
+ EXPECT_EQ(1U, aci->type_);
EXPECT_EQ(PW_TYPE_STRING, aci->value_type_);
EXPECT_EQ("Agent-Circuit-Id", aci->name_);
- EXPECT_EQ(3561, aci->vendor_);
+ EXPECT_EQ(3561U, aci->vendor_);
// Positive using an integer.
list<string> positive_n = {
EXPECT_NO_THROW_LOG(parseLines(positive_n, 0, 3561));
auto adru = AttrDefs::instance().getByType(129, 3561);
ASSERT_TRUE(adru);
- EXPECT_EQ(129, adru->type_);
+ EXPECT_EQ(129U, adru->type_);
EXPECT_EQ(PW_TYPE_INTEGER, adru->value_type_);
EXPECT_EQ("Actual-Data-Rate-Upstream", adru->name_);
- EXPECT_EQ(3561, adru->vendor_);
+ EXPECT_EQ(3561U, adru->vendor_);
// End using a name.
list<string> end_name = {
EXPECT_THROW_MSG(AttrDefs::instance().readDictionary("/does-not-exist",
vendor),
BadValue, expected);
- EXPECT_EQ(0, vendor);
+ EXPECT_EQ(0U, vendor);
list<string> bad_include = {
"$INCLUDE /does-not-exist"
};
uint32_t vendor = 0;
ASSERT_NO_THROW_LOG(AttrDefs::instance().readDictionary(TEST_DICTIONARY,
vendor));
- EXPECT_EQ(0, vendor);
+ EXPECT_EQ(0U, vendor);
EXPECT_NO_THROW_LOG(AttrDefs::instance().
checkStandardDefs(RadiusConfigParser::USED_STANDARD_ATTR_DEFS));
}
checkStandardDefs(RadiusConfigParser::USED_STANDARD_ATTR_DEFS));
auto isc = AttrDefs::instance().getByName(PW_VENDOR_SPECIFIC, "ISC");
ASSERT_TRUE(isc);
- EXPECT_EQ(2495, isc->value_);
+ EXPECT_EQ(2495U, isc->value_);
// max depth is 5.
EXPECT_THROW_MSG(parseLines(include, 0, 0, 4), BadValue,
SCOPED_TRACE(file_name);
EXPECT_NO_THROW_LOG(defs.readDictionary(file_name, vendor));
}
- EXPECT_EQ(0, vendor);
+ EXPECT_EQ(0U, vendor);
}
// Verifies attribute definitions.
// getByType.
ASSERT_NO_THROW(def = AttrDefs::instance().getByType(1));
ASSERT_TRUE(def);
- EXPECT_EQ(1, def->type_);
+ EXPECT_EQ(1U, def->type_);
EXPECT_EQ("User-Name", def->name_);
EXPECT_EQ(PW_TYPE_STRING, def->value_type_);
- EXPECT_EQ(0, def->vendor_);
+ EXPECT_EQ(0U, def->vendor_);
def.reset();
// Type 0 is reserved.
// getByName.
ASSERT_NO_THROW(def = AttrDefs::instance().getByName("User-Name"));
ASSERT_TRUE(def);
- EXPECT_EQ(1, def->type_);
+ EXPECT_EQ(1U, def->type_);
EXPECT_EQ("User-Name", def->name_);
EXPECT_EQ(PW_TYPE_STRING, def->value_type_);
- EXPECT_EQ(0, def->vendor_);
+ EXPECT_EQ(0U, def->vendor_);
def.reset();
ASSERT_NO_THROW(def = AttrDefs::instance().getByName("Does-not-exist"));
ASSERT_NO_THROW(AttrDefs::instance().add(def1));
ASSERT_NO_THROW(def = AttrDefs::instance().getByType(252));
ASSERT_TRUE(def);
- EXPECT_EQ(252, def->type_);
+ EXPECT_EQ(252U, def->type_);
EXPECT_EQ("Foo-Bar", def->name_);
EXPECT_EQ(PW_TYPE_IPADDR, def->value_type_);
- EXPECT_EQ(0, def->vendor_);
+ EXPECT_EQ(0U, def->vendor_);
def.reset();
ASSERT_NO_THROW(def = AttrDefs::instance().getByName("Foo-Bar"));
ASSERT_TRUE(def);
- EXPECT_EQ(252, def->type_);
+ EXPECT_EQ(252U, def->type_);
EXPECT_EQ("Foo-Bar", def->name_);
EXPECT_EQ(PW_TYPE_IPADDR, def->value_type_);
- EXPECT_EQ(0, def->vendor_);
+ EXPECT_EQ(0U, def->vendor_);
def.reset();
// add (alias).
ASSERT_NO_THROW(AttrDefs::instance().add(def2));
AttrDefPtr got = AttrDefs::instance().getByName("Error-Message");
ASSERT_TRUE(got);
- EXPECT_EQ(18, got->type_);
+ EXPECT_EQ(18U, got->type_);
EXPECT_EQ(PW_TYPE_STRING, got->value_type_);
- EXPECT_EQ(0, got->vendor_);
+ EXPECT_EQ(0U, got->vendor_);
def.reset();
// add (vendor).
ASSERT_NO_THROW(AttrDefs::instance().add(defv));
ASSERT_NO_THROW(def = AttrDefs::instance().getByType(1, 3561));
ASSERT_TRUE(def);
- EXPECT_EQ(1, def->type_);
+ EXPECT_EQ(1U, def->type_);
EXPECT_EQ("Agent-Circuit-Id", def->name_);
EXPECT_EQ(PW_TYPE_STRING, def->value_type_);
- EXPECT_EQ(3561, def->vendor_);
+ EXPECT_EQ(3561U, def->vendor_);
def.reset();
ASSERT_NO_THROW(def =
AttrDefs::instance().getByName("Agent-Circuit-Id", 3561));
ASSERT_TRUE(def);
- EXPECT_EQ(1, def->type_);
+ EXPECT_EQ(1U, def->type_);
EXPECT_EQ("Agent-Circuit-Id", def->name_);
EXPECT_EQ(PW_TYPE_STRING, def->value_type_);
- EXPECT_EQ(3561, def->vendor_);
+ EXPECT_EQ(3561U, def->vendor_);
def.reset();
ASSERT_NO_THROW(name = AttrDefs::instance().getName(1, 3561));
EXPECT_EQ("Agent-Circuit-Id", name);
// add (change type).
ASSERT_NO_THROW(def = AttrDefs::instance().getByName("User-Password"));
ASSERT_TRUE(def);
- EXPECT_EQ(2, def->type_);
+ EXPECT_EQ(2U, def->type_);
EXPECT_EQ(PW_TYPE_STRING, def->value_type_);
- EXPECT_EQ(0, def->vendor_);
+ EXPECT_EQ(0U, def->vendor_);
AttrDefPtr def3(new AttrDef(17, "User-Password", PW_TYPE_STRING));
string expected = "Illegal attribute redefinition of ";
expected += "'User-Password' type 2 value type string by 17 string";
ASSERT_NO_THROW(def =
AttrDefs::instance().getByName("Agent-Circuit-Id", 3561));
ASSERT_TRUE(def);
- EXPECT_EQ(1, def->type_);
+ EXPECT_EQ(1U, def->type_);
EXPECT_EQ(PW_TYPE_STRING, def->value_type_);
- EXPECT_EQ(3561, def->vendor_);
+ EXPECT_EQ(3561U, def->vendor_);
AttrDefPtr def3v(new AttrDef(2, "Agent-Circuit-Id", PW_TYPE_STRING, 3561));
expected = "Illegal attribute redefinition of 'Agent-Circuit-Id' ";
expected += "vendor 3561 type 1 value type string by 2 string";
ASSERT_FALSE(exchange_->identifier_.empty());
ASSERT_FALSE(exchange_->sync_);
ASSERT_FALSE(exchange_->server_);
- ASSERT_EQ(0, exchange_->idx_);
+ ASSERT_EQ(0U, exchange_->idx_);
ASSERT_FALSE(exchange_->started_);
ASSERT_FALSE(exchange_->terminated_);
ASSERT_EQ(ERROR_RC, exchange_->rc_);
ASSERT_FALSE(exchange_->ep_);
ASSERT_FALSE(exchange_->timer_);
ASSERT_FALSE(exchange_->server_);
- ASSERT_EQ(0, exchange_->idx_);
+ ASSERT_EQ(0U, exchange_->idx_);
ASSERT_FALSE(exchange_->sent_);
ASSERT_FALSE(exchange_->received_);
ASSERT_TRUE(exchange_->buffer_.empty());
- ASSERT_EQ(0, exchange_->size_);
- ASSERT_EQ(0, exchange_->retries_);
+ ASSERT_EQ(0U, exchange_->size_);
+ ASSERT_EQ(0U, exchange_->retries_);
ASSERT_TRUE(exchange_->postponed_.empty());
ASSERT_FALSE(called_);
// Check initial state.
EXPECT_FALSE(exchange_->server_);
- EXPECT_EQ(0, exchange_->idx_);
+ EXPECT_EQ(0U, exchange_->idx_);
// Call open.
ASSERT_NO_THROW_LOG(exchange_->open());
// Check new state.
EXPECT_TRUE(exchange_->server_);
EXPECT_EQ(servers_[0], exchange_->server_);
- EXPECT_EQ(0, exchange_->idx_);
+ EXPECT_EQ(0U, exchange_->idx_);
EXPECT_TRUE(exchange_->sent_);
ASSERT_TRUE(exchange_->ep_);
EXPECT_TRUE(exchange_->timer_);
ASSERT_NO_THROW_LOG(exchange_->open());
// Check new state.
- EXPECT_EQ(1, exchange_->idx_);
- ASSERT_EQ(1, exchange_->postponed_.size());
- EXPECT_EQ(0, exchange_->postponed_.front());
+ EXPECT_EQ(1U, exchange_->idx_);
+ ASSERT_EQ(1U, exchange_->postponed_.size());
+ EXPECT_EQ(0U, exchange_->postponed_.front());
}
// Verify open in second pass with no postponed servers.
ASSERT_NO_THROW_LOG(exchange_->open());
// Check new state.
- EXPECT_EQ(1, exchange_->idx_);
+ EXPECT_EQ(1U, exchange_->idx_);
EXPECT_FALSE(exchange_->terminated_);
EXPECT_FALSE(called_);
// Check new state.
EXPECT_TRUE(exchange_->server_);
EXPECT_EQ(servers_[0], exchange_->server_);
- EXPECT_EQ(1, exchange_->idx_);
+ EXPECT_EQ(1U, exchange_->idx_);
EXPECT_TRUE(exchange_->sent_);
EXPECT_TRUE(exchange_->timer_);
ASSERT_TRUE(exchange_->ep_);
msg += "too too too too too too too too too too too too ";
msg += "too too too too too too too too too too too too long!!!";
// Hard limit is 253 so be close but lower...
- EXPECT_EQ(252, msg.size());
+ EXPECT_EQ(252U, msg.size());
AttributePtr attr = Attribute::fromString(PW_REPLY_MESSAGE, msg);
ASSERT_TRUE(attr);
for (size_t i = 0; i < 16; ++i) {
// Check new state.
EXPECT_TRUE(exchange_->server_);
EXPECT_EQ(servers_[0], exchange_->server_);
- EXPECT_EQ(0, exchange_->idx_);
+ EXPECT_EQ(0U, exchange_->idx_);
EXPECT_TRUE(exchange_->sent_);
EXPECT_FALSE(exchange_->ep_);
EXPECT_FALSE(exchange_->timer_);
EXPECT_FALSE(exchange_->socket_);
- EXPECT_EQ(0, exchange_->retries_);
+ EXPECT_EQ(0U, exchange_->retries_);
EXPECT_EQ(ERROR_RC, exchange_->rc_);
}
ASSERT_NO_THROW_LOG(exchange_->open());
// Check next state.
- EXPECT_EQ(0, exchange_->retries_);
+ EXPECT_EQ(0U, exchange_->retries_);
EXPECT_FALSE(exchange_->server_);
EXPECT_FALSE(exchange_->ep_);
- EXPECT_EQ(1, exchange_->idx_);
+ EXPECT_EQ(1U, exchange_->idx_);
// Poll the I/O service.
ASSERT_NO_THROW_LOG(io_service_->poll());
ASSERT_NO_THROW_LOG(exchange_->open());
// Check new state.
- EXPECT_EQ(2, exchange_->idx_);
+ EXPECT_EQ(2U, exchange_->idx_);
EXPECT_EQ(servers_.size(), exchange_->idx_);
EXPECT_FALSE(exchange_->terminated_);
EXPECT_FALSE(called_);
// Add servers to the postponed list.
exchange_->postponed_.push_back(0);
exchange_->postponed_.push_back(1);
- ASSERT_EQ(2, exchange_->postponed_.size());
+ ASSERT_EQ(2U, exchange_->postponed_.size());
// Set the exchange on last retry.
exchange_->server_ = servers_[0];
ASSERT_NO_THROW_LOG(exchange_->open());
// Check next state.
- EXPECT_EQ(0, exchange_->retries_);
+ EXPECT_EQ(0U, exchange_->retries_);
EXPECT_FALSE(exchange_->server_);
EXPECT_FALSE(exchange_->ep_);
- EXPECT_EQ(2, exchange_->idx_);
+ EXPECT_EQ(2U, exchange_->idx_);
// Poll the I/O service.
ASSERT_NO_THROW_LOG(io_service_->poll());
// Set the exchange on last retry of last server.
exchange_->server_ = servers_[0];
exchange_->retries_ = maxretries_;
- ASSERT_EQ(1, exchange_->postponed_.size());
+ ASSERT_EQ(1U, exchange_->postponed_.size());
// Call open.
ASSERT_NO_THROW_LOG(exchange_->open());
// Check new state.
- EXPECT_EQ(2, exchange_->idx_);
+ EXPECT_EQ(2U, exchange_->idx_);
EXPECT_EQ(servers_.size(), exchange_->idx_);
EXPECT_FALSE(exchange_->terminated_);
EXPECT_FALSE(called_);
ASSERT_NO_THROW_LOG(exchange_->open());
// Check new state.
- EXPECT_EQ(1, exchange_->retries_);
+ EXPECT_EQ(1U, exchange_->retries_);
EXPECT_TRUE(exchange_->sent_);
EXPECT_TRUE(exchange_->timer_);
ASSERT_TRUE(exchange_->ep_);
ASSERT_NO_THROW_LOG(exchange_->open());
// Check new state.
- EXPECT_EQ(1, exchange_->retries_);
+ EXPECT_EQ(1U, exchange_->retries_);
EXPECT_FALSE(exchange_->sent_);
EXPECT_FALSE(exchange_->timer_);
EXPECT_FALSE(exchange_->socket_);
ASSERT_TRUE(attrs);
attrs->add(Attribute::fromString(PW_USER_NAME, "me"));
attrs->add(Attribute::fromInt(PW_NAS_PORT, 1));
- ASSERT_EQ(2, attrs->size());
+ ASSERT_EQ(2U, attrs->size());
MessagePtr message;
ASSERT_NO_THROW(message.reset(new Message(code, 1234, auth,
EXPECT_EQ(PW_ACCESS_REQUEST, message->getCode());
EXPECT_EQ("Access-Request", msgCodeToText(message->getCode()));
message->setCode(123);
- EXPECT_EQ(123, message->getCode());
+ EXPECT_EQ(123U, message->getCode());
EXPECT_EQ("Message-Code-123", msgCodeToText(message->getCode()));
// Identifier.
EXPECT_EQ(id, message->getIdentifier());
// Length.
- EXPECT_EQ(1234, message->getLength());
+ EXPECT_EQ(1234U, message->getLength());
message->setLength(2345);
- EXPECT_EQ(2345, message->getLength());
+ EXPECT_EQ(2345U, message->getLength());
// Authenticator.
vector<uint8_t> got_auth = message->getAuth();
got_auth = message->getAuth();
ASSERT_EQ(AUTH_VECTOR_LEN, got_auth.size());
for (size_t i = 0; i < AUTH_VECTOR_LEN; ++i) {
- EXPECT_EQ(0, got_auth[i]);
+ EXPECT_EQ(0U, got_auth[i]);
}
got_auth = Message::ZERO_AUTH();
ASSERT_EQ(AUTH_VECTOR_LEN, got_auth.size());
for (size_t i = 0; i < AUTH_VECTOR_LEN; ++i) {
- EXPECT_EQ(0, got_auth[i]);
+ EXPECT_EQ(0U, got_auth[i]);
}
bool got_zero = true;
for (size_t round = 0; round < 5; ++round) {
// Check buffer.
uint16_t length = request->getLength();
ASSERT_EQ(length, buffer.size());
- ASSERT_EQ(38, length);
+ ASSERT_EQ(38U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
// NAS-IP-Address (127.0.0.1).
0x04, 0x06, 0x7f, 0x00, 0x00, 0x01
};
- ASSERT_EQ(38, expected.size());
+ ASSERT_EQ(38U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 38) << "\n"
<< str::dumpAsHex(&expected[0], 38);
// Check buffer.
uint16_t length = request->getLength();
ASSERT_EQ(length, buffer.size());
- ASSERT_EQ(26, length);
+ ASSERT_EQ(26U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
// User-Name ("user").
0x01, 0x06, 0x75, 0x73, 0x65, 0x72
};
- ASSERT_EQ(26, expected.size());
+ ASSERT_EQ(26U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 26) << "\n"
<< str::dumpAsHex(&expected[0], 26);
// Check buffer.
uint16_t length = request->getLength();
ASSERT_EQ(length, buffer.size());
- ASSERT_EQ(44, length);
+ ASSERT_EQ(44U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
// NAS-IP-Address (127.0.0.1).
0x04, 0x06, 0x7f, 0x00, 0x00, 0x01
};
- ASSERT_EQ(44, expected.size());
+ ASSERT_EQ(44U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 44) << "\n"
<< str::dumpAsHex(&expected[0], 44);
// Check buffer.
uint16_t length = request->getLength();
ASSERT_EQ(length, buffer.size());
- ASSERT_EQ(20, length);
+ ASSERT_EQ(20U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0x88, 0xc4, 0x21, 0xc3, 0x25, 0xf3, 0xdc, 0x57,
0x14, 0x01, 0x4c, 0xef, 0x78, 0x03, 0x64, 0xbe
};
- ASSERT_EQ(20, expected.size());
+ ASSERT_EQ(20U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 20) << "\n"
<< str::dumpAsHex(&expected[0], 20);
// Check buffer.
uint16_t length = request->getLength();
ASSERT_EQ(length, buffer.size());
- ASSERT_EQ(56, length);
+ ASSERT_EQ(56U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
// NAS-IP-Address (127.0.0.1).
0x04, 0x06, 0x7f, 0x00, 0x00, 0x01
};
- ASSERT_EQ(56, expected.size());
+ ASSERT_EQ(56U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 56) << "\n"
<< str::dumpAsHex(&expected[0], 56);
// Check buffer.
uint16_t length = request->getLength();
ASSERT_EQ(length, buffer.size());
- ASSERT_EQ(72, length);
+ ASSERT_EQ(72U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
// NAS-IP-Address (127.0.0.1).
0x04, 0x06, 0x7f, 0x00, 0x00, 0x01
};
- ASSERT_EQ(72, expected.size());
+ ASSERT_EQ(72U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 72) << "\n"
<< str::dumpAsHex(&expected[0], 72);
msg += "too too too too too too too too too too too too ";
msg += "too too too too too too too too too too too too long!";
// Hard limit is 253 so be close but lower...
- EXPECT_EQ(250, msg.size());
+ EXPECT_EQ(250U, msg.size());
AttributePtr rm_attr = Attribute::fromString(PW_REPLY_MESSAGE, msg);
for (size_t i = 0; i < 17; ++i) {
attrs->add(rm_attr);
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(20, length);
+ ASSERT_EQ(20U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0x8a, 0x54, 0xf4, 0x68, 0x6f, 0xb3, 0x94, 0xc5,
0x28, 0x66, 0xe3, 0x02, 0x18, 0x5d, 0x06, 0x23
};
- ASSERT_EQ(20, expected.size());
+ ASSERT_EQ(20U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 20) << "\n"
<< str::dumpAsHex(&expected[0], 20);
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(38, length);
+ ASSERT_EQ(38U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0x5a, 0x66, 0x5e, 0x2e, 0x1e, 0x84, 0x11, 0xf3,
0xe2, 0x43, 0x82, 0x20, 0x97, 0xc8, 0x4f, 0xa3
};
- ASSERT_EQ(38, expected.size());
+ ASSERT_EQ(38U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 38) << "\n"
<< str::dumpAsHex(&expected[0], 38);
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(38, length);
+ ASSERT_EQ(38U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0xe8, 0xd6, 0xea, 0xbd, 0xa9, 0x10, 0x87, 0x5c,
0xd9, 0x1f, 0xda, 0xde, 0x26, 0x36, 0x78, 0x58
};
- ASSERT_EQ(38, expected.size());
+ ASSERT_EQ(38U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 38) << "\n"
<< str::dumpAsHex(&expected[0], 38);
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(44, length);
+ ASSERT_EQ(44U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0x85, 0x2d, 0x6f, 0xec, 0x61, 0xe7, 0xed, 0x74,
0xb8, 0xe3, 0x2d, 0xac, 0x2f, 0x2a, 0x5f, 0xb2
};
- ASSERT_EQ(44, expected.size());
+ ASSERT_EQ(44U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 44) << "\n"
<< str::dumpAsHex(&expected[0], 44);
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(20, length);
+ ASSERT_EQ(20U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0xef, 0x0d, 0x55, 0x2a, 0x4b, 0xf2, 0xd6, 0x93,
0xec, 0x2b, 0x6f, 0xe8, 0xb5, 0x41, 0x1d, 0x66
};
- ASSERT_EQ(20, expected.size());
+ ASSERT_EQ(20U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 20) << "\n"
<< str::dumpAsHex(&expected[0], 20);
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(38, length);
+ ASSERT_EQ(38U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0x57, 0x56, 0x6a, 0x4a, 0x4a, 0x4c, 0x69, 0x0f,
0x8e, 0x18, 0xb7, 0x3a, 0xe7, 0xa7, 0xf6, 0x5f
};
- ASSERT_EQ(38, expected.size());
+ ASSERT_EQ(38U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 38) << "\n"
<< str::dumpAsHex(&expected[0], 38);
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(20, length);
+ ASSERT_EQ(20U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0x0f, 0x6f, 0x92, 0x14, 0x5f, 0x10, 0x7e, 0x2f,
0x50, 0x4e, 0x86, 0x0a, 0x48, 0x60, 0x66, 0x9c
};
- ASSERT_EQ(20, expected.size());
+ ASSERT_EQ(20U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 20) << "\n"
<< str::dumpAsHex(&expected[0], 20);
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(52, length);
+ ASSERT_EQ(52U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0x20, 0x32, 0x20, 0x64, 0x61, 0x79, 0x73, 0x2c,
0x20, 0x31, 0x38, 0x3a, 0x34, 0x30
};
- ASSERT_EQ(52, expected.size());
+ ASSERT_EQ(52U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 52) << "\n"
<< str::dumpAsHex(&expected[0], 52);
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(38, length);
+ ASSERT_EQ(38U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0x8b, 0x9d, 0x0d, 0x3e, 0xc4, 0xf2, 0xc4, 0x4e,
0x65, 0xcc, 0xe1, 0x8a, 0x2b, 0x63, 0x97, 0x4b
};
- ASSERT_EQ(38, expected.size());
+ ASSERT_EQ(38U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 38) << "\n"
<< str::dumpAsHex(&expected[0], 38);
// Verify the message is signed.
auto got_attrs = request->getAttributes();
ASSERT_TRUE(got_attrs);
- EXPECT_EQ(1, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
+ EXPECT_EQ(1U, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
}
// Verify signed Access-Request.
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(74, length);
+ ASSERT_EQ(74U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
// NAS-IP-Address (127.0.0.1).
0x04, 0x06, 0x7f, 0x00, 0x00, 0x01
};
- ASSERT_EQ(74, expected.size());
+ ASSERT_EQ(74U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 74) << "\n"
<< str::dumpAsHex(&expected[0], 74);
// Verify the message is signed.
auto got_attrs = request->getAttributes();
ASSERT_TRUE(got_attrs);
- EXPECT_EQ(1, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
+ EXPECT_EQ(1U, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
// And correctly decoded.
auto got_attr = got_attrs->get(PW_USER_NAME);
EXPECT_EQ("secret password", got_attr->toString());
got_attr = got_attrs->get(PW_NAS_PORT);
ASSERT_TRUE(got_attr);
- EXPECT_EQ(1, got_attr->toInt());
+ EXPECT_EQ(1U, got_attr->toInt());
got_attr = got_attrs->get(PW_NAS_IP_ADDRESS);
ASSERT_TRUE(got_attr);
EXPECT_EQ("127.0.0.1", got_attr->toIpAddr().toText());
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(38, length);
+ ASSERT_EQ(38U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0x60, 0xda, 0x7f, 0x9f, 0x0a, 0x11, 0xfe, 0x56,
0xfc, 0x46, 0xcf, 0xef, 0x9c, 0x9c, 0x33, 0x60
};
- ASSERT_EQ(38, expected.size());
+ ASSERT_EQ(38U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 38) << "\n"
<< str::dumpAsHex(&expected[0], 38);
// Verify the message is signed.
auto got_attrs = request->getAttributes();
ASSERT_TRUE(got_attrs);
- EXPECT_EQ(1, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
+ EXPECT_EQ(1U, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
}
// Verify signed Accounting-Request.
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(62, length);
+ ASSERT_EQ(62U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
// NAS-IP-Address (127.0.0.1).
0x04, 0x06, 0x7f, 0x00, 0x00, 0x01
};
- ASSERT_EQ(62, expected.size());
+ ASSERT_EQ(62U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 62) << "\n"
<< str::dumpAsHex(&expected[0], 62);
// Verify the message is signed.
auto got_attrs = request->getAttributes();
ASSERT_TRUE(got_attrs);
- EXPECT_EQ(1, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
+ EXPECT_EQ(1U, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
// And correctly decoded.
auto got_attr = got_attrs->get(PW_USER_NAME);
EXPECT_EQ("user", got_attr->toString());
got_attr = got_attrs->get(PW_NAS_PORT);
ASSERT_TRUE(got_attr);
- EXPECT_EQ(1, got_attr->toInt());
+ EXPECT_EQ(1U, got_attr->toInt());
got_attr = got_attrs->get(PW_ACCT_DELAY_TIME);
ASSERT_TRUE(got_attr);
- EXPECT_EQ(0, got_attr->toInt());
+ EXPECT_EQ(0U, got_attr->toInt());
got_attr = got_attrs->get(PW_NAS_IP_ADDRESS);
ASSERT_TRUE(got_attr);
EXPECT_EQ("127.0.0.1", got_attr->toIpAddr().toText());
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(38, length);
+ ASSERT_EQ(38U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0x15, 0xa5, 0x8a, 0x0b, 0xaa, 0x3b, 0x5f, 0x6d,
0xa0, 0xbd, 0xfc, 0xa6, 0xde, 0x60, 0xf9, 0x0f
};
- ASSERT_EQ(38, expected.size());
+ ASSERT_EQ(38U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 38) << "\n"
<< str::dumpAsHex(&expected[0], 38);
// Verify the message is signed.
auto got_attrs = request->getAttributes();
ASSERT_TRUE(got_attrs);
- EXPECT_EQ(1, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
+ EXPECT_EQ(1U, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
// Create message (response).
vector<uint8_t> dumped = {
// Verify the response is signed.
got_attrs = response->getAttributes();
ASSERT_TRUE(got_attrs);
- EXPECT_EQ(1, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
+ EXPECT_EQ(1U, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
}
// Verify signed Accounting-Response response to signed Status-Server.
// Check buffer.
uint16_t length = request->getLength();
- ASSERT_EQ(38, length);
+ ASSERT_EQ(38U, length);
vector<uint8_t> got_buffer = request->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0xab, 0x13, 0x50, 0x87, 0x20, 0xbd, 0xf6, 0xe1,
0xf1, 0x89, 0x02, 0x81, 0xf7, 0xeb, 0xac, 0x1d
};
- ASSERT_EQ(38, expected.size());
+ ASSERT_EQ(38U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 38) << "\n"
<< str::dumpAsHex(&expected[0], 38);
// Verify the request is signed.
auto got_attrs = request->getAttributes();
ASSERT_TRUE(got_attrs);
- EXPECT_EQ(1, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
+ EXPECT_EQ(1U, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
// Create message (response).
vector<uint8_t> dumped = {
// Verify the response is signed.
got_attrs = response->getAttributes();
ASSERT_TRUE(got_attrs);
- EXPECT_EQ(1, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
+ EXPECT_EQ(1U, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
}
// Verify signed Access-Reject (only used message not yet tested).
// Check buffer.
uint16_t length = reject->getLength();
- ASSERT_EQ(38, length);
+ ASSERT_EQ(38U, length);
vector<uint8_t> got_buffer = reject->getBuffer();
ASSERT_EQ(buffer.size(), got_buffer.size());
EXPECT_TRUE(memcmp(&buffer[0], &got_buffer[0], buffer.size()) == 0);
0x13, 0x40, 0x2f, 0xae, 0x82, 0x71, 0x59, 0x80,
0xff, 0xfc, 0xb7, 0x9a, 0xf8, 0xbf, 0x97, 0x89
};
- ASSERT_EQ(38, expected.size());
+ ASSERT_EQ(38U, expected.size());
EXPECT_TRUE(memcmp(&expected[0], &buffer[0], buffer.size()) == 0)
<< str::dumpAsHex(&buffer[0], 38) << "\n"
<< str::dumpAsHex(&expected[0], 38);
// Verify the message is signed.
auto got_attrs = reject->getAttributes();
ASSERT_TRUE(got_attrs);
- EXPECT_EQ(1, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
+ EXPECT_EQ(1U, got_attrs->count(PW_MESSAGE_AUTHENTICATOR));
}
} // end of anonymous namespace
/// Verify subnet ID to NAS port remap.
TEST_F(RequestTest, getNASPort) {
// No remap.
- EXPECT_EQ(44, getNASPort(44));
+ EXPECT_EQ(44U, getNASPort(44));
// Default.
impl_.remap_[SUBNET_ID_DEFAULT] = 2;
- EXPECT_EQ(2, getNASPort(44));
+ EXPECT_EQ(2U, getNASPort(44));
// Specific/matching remap entry.
impl_.remap_[44] = 3;
- EXPECT_EQ(3, getNASPort(44));
+ EXPECT_EQ(3U, getNASPort(44));
}
/// Verify what happens when there is no listening authentication server at all.
// Check received request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
EXPECT_EQ(PW_ACCESS_REQUEST, receive_buffer_[0]);
uint16_t length = (receive_buffer_[2] << 8) | receive_buffer_[3];
ASSERT_LE(length, size);
- EXPECT_GE(4096, length);
+ EXPECT_GE(4096U, length);
// Check attributes.
- EXPECT_EQ(38, size);
+ EXPECT_EQ(38U, size);
uint8_t expected[] = {
0x01, // User-Name
0x06, // length
// Check received request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
EXPECT_EQ(PW_ACCOUNTING_REQUEST, receive_buffer_[0]);
uint16_t length = (receive_buffer_[2] << 8) | receive_buffer_[3];
ASSERT_LE(length, size);
- EXPECT_GE(4096, length);
+ EXPECT_GE(4096U, length);
// Check attributes.
- EXPECT_EQ(44, size);
+ EXPECT_EQ(44U, size);
uint8_t expected[] = {
0x01, // User-Name
0x06, // length
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(26, size);
+ ASSERT_LE(26U, size);
// Build the response.
size = AUTH_HDR_LEN + 2 + 4; // header + User-Name attribute.
// Check result.
EXPECT_EQ(OK_RC, result_);
ASSERT_TRUE(received_attributes_);
- ASSERT_EQ(1, received_attributes_->size());
- ASSERT_EQ(1, received_attributes_->count(1));
+ ASSERT_EQ(1U, received_attributes_->size());
+ ASSERT_EQ(1U, received_attributes_->count(1));
const ConstAttributePtr& attr = received_attributes_->get(1);
ASSERT_TRUE(attr);
EXPECT_EQ("User-Name='user'", attr->toText());
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(26, size);
+ ASSERT_LE(26U, size);
// Build the response.
size = AUTH_HDR_LEN + 2 + 4; // header + User-Name attribute.
// Check result.
EXPECT_EQ(BADRESP_RC, result_);
ASSERT_TRUE(received_attributes_);
- ASSERT_EQ(1, received_attributes_->size());
- ASSERT_EQ(1, received_attributes_->count(1));
+ ASSERT_EQ(1U, received_attributes_->size());
+ ASSERT_EQ(1U, received_attributes_->count(1));
const ConstAttributePtr& attr = received_attributes_->get(1);
ASSERT_TRUE(attr);
EXPECT_EQ("User-Name='user'", attr->toText());
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(26, size);
+ ASSERT_LE(26U, size);
// Build the response.
size = AUTH_HDR_LEN + 2 + 4; // header + User-Name attribute.
EXPECT_TRUE(finished_);
EXPECT_TRUE(sent_);
EXPECT_FALSE(timeout_);
- EXPECT_EQ(10, sent_size);
+ EXPECT_EQ(10U, sent_size);
// Done.
stop();
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
EXPECT_TRUE(finished_);
EXPECT_TRUE(sent_);
EXPECT_FALSE(timeout_);
- EXPECT_EQ(10, sent_size);
+ EXPECT_EQ(10U, sent_size);
// Done.
stop();
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(26, size);
+ ASSERT_LE(26U, size);
// Build the response.
size = AUTH_HDR_LEN + 2 + 4; // header + User-Name attribute.
// Check result.
EXPECT_EQ(REJECT_RC, result_);
ASSERT_TRUE(received_attributes_);
- ASSERT_EQ(1, received_attributes_->size());
- ASSERT_EQ(1, received_attributes_->count(1));
+ ASSERT_EQ(1U, received_attributes_->size());
+ ASSERT_EQ(1U, received_attributes_->count(1));
const ConstAttributePtr& attr = received_attributes_->get(1);
ASSERT_TRUE(attr);
EXPECT_EQ("User-Name='user'", attr->toText());
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(26, size);
+ ASSERT_LE(26U, size);
// Build the response.
size = AUTH_HDR_LEN + 2 + 4; // header + User-Name attribute.
// Check result.
EXPECT_EQ(OK_RC, result_);
ASSERT_TRUE(received_attributes_);
- ASSERT_EQ(1, received_attributes_->size());
- ASSERT_EQ(1, received_attributes_->count(1));
+ ASSERT_EQ(1U, received_attributes_->size());
+ ASSERT_EQ(1U, received_attributes_->count(1));
const ConstAttributePtr& attr = received_attributes_->get(1);
ASSERT_TRUE(attr);
EXPECT_EQ("User-Name='user'", attr->toText());
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
"foo", 10, 0)));
ASSERT_TRUE(server);
EXPECT_EQ(addr4, server->getPeerAddress());
- EXPECT_EQ(1234, server->getPeerPort());
+ EXPECT_EQ(1234U, server->getPeerPort());
EXPECT_NO_THROW(server->setPeerPort(2345));
- EXPECT_EQ(2345, server->getPeerPort());
+ EXPECT_EQ(2345U, server->getPeerPort());
EXPECT_EQ(addr4, server->getLocalAddress());
EXPECT_FALSE(server->getTlsContext());
expected = "address family mismatch: peer ";
EXPECT_THROW_MSG(server->setSecret(""), BadValue, "empty secret");
EXPECT_NO_THROW(server->setSecret("bar"));
EXPECT_EQ("bar", server->getSecret());
- EXPECT_EQ(10, server->getTimeout());
+ EXPECT_EQ(10U, server->getTimeout());
// Zero timeout is rounded to 1.
EXPECT_NO_THROW(server->setTimeout(0));
- EXPECT_EQ(1, server->getTimeout());
+ EXPECT_EQ(1U, server->getTimeout());
if (numeric_limits<unsigned>::max() > numeric_limits<long>::max() / 1000) {
auto div1000 = numeric_limits<long>::max() / 1000;
unsigned large = static_cast<unsigned>(div1000 + 1);
EXPECT_THROW_MSG(server->setTimeout(large), OutOfRange, ss.str());
cerr << ss.str() << "\n";
}
- EXPECT_EQ(0, server->getDeadtime());
+ EXPECT_EQ(0U, server->getDeadtime());
EXPECT_NO_THROW(server->setDeadtime(60));
- EXPECT_EQ(60, server->getDeadtime());
+ EXPECT_EQ(60U, server->getDeadtime());
steady_clock::time_point now = steady_clock::now();
EXPECT_TRUE(server->getDeadtimeEnd() <= now);
steady_clock::time_point later = now + seconds(10);
// Check received request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
EXPECT_EQ(PW_STATUS_SERVER, receive_buffer_[0]);
uint16_t length = (receive_buffer_[2] << 8) | receive_buffer_[3];
ASSERT_LE(length, size);
- EXPECT_GE(4096, length);
+ EXPECT_GE(4096U, length);
}
/// Verify what happens when no response is sent.
// Check received request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
EXPECT_EQ(PW_STATUS_SERVER, receive_buffer_[0]);
uint16_t length = (receive_buffer_[2] << 8) | receive_buffer_[3];
ASSERT_LE(length, size);
- EXPECT_GE(4096, length);
+ EXPECT_GE(4096U, length);
}
/// Verify what happens with Access-Accept response.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN + 2 + 4; // header + Error-Cause attribute.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header.
EXPECT_TRUE(finished_);
EXPECT_TRUE(sent_);
EXPECT_FALSE(timeout_);
- EXPECT_EQ(10, sent_size);
+ EXPECT_EQ(10U, sent_size);
// Done.
stop();
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
EXPECT_TRUE(finished_);
EXPECT_TRUE(sent_);
EXPECT_FALSE(timeout_);
- EXPECT_EQ(10, sent_size);
+ EXPECT_EQ(10U, sent_size);
// Done.
stop();
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
// Check received request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
EXPECT_EQ(PW_STATUS_SERVER, receive_buffer_[0]);
uint16_t length = (receive_buffer_[2] << 8) | receive_buffer_[3];
EXPECT_EQ(length, size);
- EXPECT_GE(4096, length);
+ EXPECT_GE(4096U, length);
// Check attributes.
- EXPECT_EQ(44, size);
+ EXPECT_EQ(44U, size);
EXPECT_EQ(PW_MESSAGE_AUTHENTICATOR, receive_buffer_[AUTH_HDR_LEN]);
EXPECT_EQ(AUTH_VECTOR_LEN + 2, receive_buffer_[AUTH_HDR_LEN + 1]);
uint8_t expected[] = {
// Check received request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
EXPECT_EQ(PW_STATUS_SERVER, receive_buffer_[0]);
uint16_t length = (receive_buffer_[2] << 8) | receive_buffer_[3];
EXPECT_EQ(length, size);
- EXPECT_GE(4096, length);
+ EXPECT_GE(4096U, length);
// Check attributes.
- EXPECT_EQ(44, size);
+ EXPECT_EQ(44U, size);
EXPECT_EQ(PW_MESSAGE_AUTHENTICATOR, receive_buffer_[AUTH_HDR_LEN]);
EXPECT_EQ(AUTH_VECTOR_LEN + 2, receive_buffer_[AUTH_HDR_LEN + 1]);
uint8_t expected[] = {
// Check received request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
EXPECT_EQ(PW_STATUS_SERVER, receive_buffer_[0]);
uint16_t length = (receive_buffer_[2] << 8) | receive_buffer_[3];
EXPECT_EQ(length, size);
- EXPECT_GE(4096, length);
+ EXPECT_GE(4096U, length);
// Check attributes.
- EXPECT_EQ(44, size);
+ EXPECT_EQ(44U, size);
EXPECT_EQ(PW_MESSAGE_AUTHENTICATOR, receive_buffer_[AUTH_HDR_LEN]);
EXPECT_EQ(AUTH_VECTOR_LEN + 2, receive_buffer_[AUTH_HDR_LEN + 1]);
uint8_t expected[] = {
// Check received request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
EXPECT_EQ(PW_STATUS_SERVER, receive_buffer_[0]);
uint16_t length = (receive_buffer_[2] << 8) | receive_buffer_[3];
EXPECT_EQ(length, size);
- EXPECT_GE(4096, length);
+ EXPECT_GE(4096U, length);
// Check attributes.
- EXPECT_EQ(44, size);
+ EXPECT_EQ(44U, size);
EXPECT_EQ(PW_MESSAGE_AUTHENTICATOR, receive_buffer_[AUTH_HDR_LEN]);
EXPECT_EQ(AUTH_VECTOR_LEN + 2, receive_buffer_[AUTH_HDR_LEN + 1]);
uint8_t expected[] = {
msg += "too too too too too too too too too too too too ";
msg += "too too too too too too too too too too too too long!!!";
// Hard limit is 253 so be close but lower...
- EXPECT_EQ(252, msg.size());
+ EXPECT_EQ(252U, msg.size());
AttributePtr attr = Attribute::fromString(PW_REPLY_MESSAGE, msg);
ASSERT_TRUE(attr);
for (size_t i = 0; i < 16; ++i) {
// Check received request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
EXPECT_EQ(PW_ACCOUNTING_REQUEST, receive_buffer_[0]);
uint16_t length = (receive_buffer_[2] << 8) | receive_buffer_[3];
ASSERT_LE(length, size);
- EXPECT_GE(4096, length);
+ EXPECT_GE(4096U, length);
// Check attributes.
- EXPECT_EQ(56, size);
+ EXPECT_EQ(56U, size);
uint8_t expected[] = {
0x01, // User-Name
0x06, // length
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(26, size);
+ ASSERT_LE(26U, size);
// Build the response.
size = AUTH_HDR_LEN + 2 + 4; // header + User-Name attribute.
// Check result.
EXPECT_EQ(OK_RC, result_);
ASSERT_TRUE(received_attributes_);
- ASSERT_EQ(1, received_attributes_->size());
- ASSERT_EQ(1, received_attributes_->count(1));
+ ASSERT_EQ(1U, received_attributes_->size());
+ ASSERT_EQ(1U, received_attributes_->count(1));
const ConstAttributePtr& attr = received_attributes_->get(1);
ASSERT_TRUE(attr);
EXPECT_EQ("User-Name='user'", attr->toText());
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(26, size);
+ ASSERT_LE(26U, size);
// Build the response.
size = AUTH_HDR_LEN + 2 + 4; // header + User-Name attribute.
// Check result.
EXPECT_EQ(BADRESP_RC, result_);
ASSERT_TRUE(received_attributes_);
- ASSERT_EQ(1, received_attributes_->size());
- ASSERT_EQ(1, received_attributes_->count(1));
+ ASSERT_EQ(1U, received_attributes_->size());
+ ASSERT_EQ(1U, received_attributes_->count(1));
const ConstAttributePtr& attr = received_attributes_->get(1);
ASSERT_TRUE(attr);
EXPECT_EQ("User-Name='user'", attr->toText());
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(26, size);
+ ASSERT_LE(26U, size);
// Build the response.
size = AUTH_HDR_LEN + 2 + 4; // header + User-Name attribute.
// Check result.
EXPECT_EQ(REJECT_RC, result_);
ASSERT_TRUE(received_attributes_);
- ASSERT_EQ(1, received_attributes_->size());
- ASSERT_EQ(1, received_attributes_->count(1));
+ ASSERT_EQ(1U, received_attributes_->size());
+ ASSERT_EQ(1U, received_attributes_->count(1));
const ConstAttributePtr& attr = received_attributes_->get(1);
ASSERT_TRUE(attr);
EXPECT_EQ("User-Name='user'", attr->toText());
// Check received request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
EXPECT_EQ(PW_STATUS_SERVER, receive_buffer_[0]);
uint16_t length = (receive_buffer_[2] << 8) | receive_buffer_[3];
ASSERT_LE(length, size);
- EXPECT_GE(4096, length);
+ EXPECT_GE(4096U, length);
}
/// Verify what happens with Access-Accept response.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN + 2 + 4; // header + Error-Cause attribute.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header.
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header (no attributes).
// Sanity checks on the request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
// Build the response.
size = AUTH_HDR_LEN; // header.
// Check received request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
EXPECT_EQ(PW_STATUS_SERVER, receive_buffer_[0]);
uint16_t length = (receive_buffer_[2] << 8) | receive_buffer_[3];
EXPECT_EQ(length, size);
- EXPECT_GE(4096, length);
+ EXPECT_GE(4096U, length);
// Check attributes.
- ASSERT_EQ(44, size);
+ ASSERT_EQ(44U, size);
EXPECT_EQ(PW_MESSAGE_AUTHENTICATOR, receive_buffer_[AUTH_HDR_LEN]);
EXPECT_EQ(AUTH_VECTOR_LEN + 2, receive_buffer_[AUTH_HDR_LEN + 1]);
uint8_t expected[] = {
// Check received request.
receive_buffer_.resize(size);
- ASSERT_LE(20, size);
+ ASSERT_LE(20U, size);
EXPECT_EQ(PW_STATUS_SERVER, receive_buffer_[0]);
uint16_t length = (receive_buffer_[2] << 8) | receive_buffer_[3];
EXPECT_EQ(length, size);
- EXPECT_GE(4096, length);
+ EXPECT_GE(4096U, length);
// Check attributes.
- ASSERT_EQ(44, size);
+ ASSERT_EQ(44U, size);
EXPECT_EQ(PW_MESSAGE_AUTHENTICATOR, receive_buffer_[AUTH_HDR_LEN]);
EXPECT_EQ(AUTH_VECTOR_LEN + 2, receive_buffer_[AUTH_HDR_LEN + 1]);
uint8_t expected[] = {
// Standard case.
cid.reset(new ClientId(vec));
vector<uint8_t> ret = pop0(cid);
- ASSERT_EQ(2, ret.size());
- EXPECT_EQ(0x01, ret[0]);
- EXPECT_EQ(0x02, ret[1]);
+ ASSERT_EQ(2U, ret.size());
+ EXPECT_EQ(0x01U, ret[0]);
+ EXPECT_EQ(0x02U, ret[1]);
// One element: pop0 does nothing.
// (vec, 1) throws because MIN_CLIENT_ID_LEN is 2.
vector<uint8_t>& content = const_cast<vector<uint8_t>&>(cid->getClientId());
content.resize(1);
ret = pop0(cid);
- ASSERT_EQ(1, ret.size());
- EXPECT_EQ(0x00, ret[0]);
+ ASSERT_EQ(1U, ret.size());
+ EXPECT_EQ(0x00U, ret[0]);
// Empty: pop0 does nothing.
cid.reset(new ClientId(&vec[0], 2));
vector<uint8_t> vec1 = { 0x01, 0x02, 0x03 };
cid.reset(new ClientId(vec1));
ret = pop0(cid);
- ASSERT_EQ(3, ret.size());
- EXPECT_EQ(0x01, ret[0]);
- EXPECT_EQ(0x02, ret[1]);
- EXPECT_EQ(0x03, ret[2]);
+ ASSERT_EQ(3U, ret.size());
+ EXPECT_EQ(0x01U, ret[0]);
+ EXPECT_EQ(0x02U, ret[1]);
+ EXPECT_EQ(0x03U, ret[2]);
}
// Verifies the DHCPv6 pop0 util.
// Standard case.
duid.reset(new DUID(vec));
vector<uint8_t> ret = pop0(duid);
- ASSERT_EQ(2, ret.size());
- EXPECT_EQ(0x02, ret[0]);
- EXPECT_EQ(0x03, ret[1]);
+ ASSERT_EQ(2U, ret.size());
+ EXPECT_EQ(0x02U, ret[0]);
+ EXPECT_EQ(0x03U, ret[1]);
// Not zero: pop0 does nothing.
vector<uint8_t> vec1 = { 0x00, 0x01, 0x02, 0x03 };
duid.reset(new DUID(vec1));
ret = pop0(duid);
- ASSERT_EQ(4, ret.size());
- EXPECT_EQ(0x00, ret[0]);
- EXPECT_EQ(0x01, ret[1]);
- EXPECT_EQ(0x02, ret[2]);
- EXPECT_EQ(0x03, ret[3]);
+ ASSERT_EQ(4U, ret.size());
+ EXPECT_EQ(0x00U, ret[0]);
+ EXPECT_EQ(0x01U, ret[1]);
+ EXPECT_EQ(0x02U, ret[2]);
+ EXPECT_EQ(0x03U, ret[3]);
vector<uint8_t> vec2 = { 0x01, 0x00, 0x02, 0x03 };
duid.reset(new DUID(vec2));
ret = pop0(duid);
- ASSERT_EQ(4, ret.size());
- EXPECT_EQ(0x01, ret[0]);
- EXPECT_EQ(0x00, ret[1]);
- EXPECT_EQ(0x02, ret[2]);
- EXPECT_EQ(0x03, ret[3]);
+ ASSERT_EQ(4U, ret.size());
+ EXPECT_EQ(0x01U, ret[0]);
+ EXPECT_EQ(0x00U, ret[1]);
+ EXPECT_EQ(0x02U, ret[2]);
+ EXPECT_EQ(0x03U, ret[3]);
}
// Verifies the toPrintable util.
bool extracted = false;
vector<uint8_t> ret = extractDuid(cid, extracted);
EXPECT_TRUE(extracted);
- ASSERT_EQ(3, ret.size());
- EXPECT_EQ(0x41, ret[0]);
- EXPECT_EQ(0x42, ret[1]);
- EXPECT_EQ(0x43, ret[2]);
+ ASSERT_EQ(3U, ret.size());
+ EXPECT_EQ(0x41U, ret[0]);
+ EXPECT_EQ(0x42U, ret[1]);
+ EXPECT_EQ(0x43U, ret[2]);
// Short case.
cid.reset(new ClientId(&vec[0], 5));
extracted = false;
ret = extractDuid(cid, extracted);
EXPECT_FALSE(extracted);
- EXPECT_EQ(5, ret.size());
+ EXPECT_EQ(5U, ret.size());
EXPECT_EQ(vec[0], ret[0]);
// Not duid case.
ProcessEnvVars vars;
bool flag = false;
RunScriptImpl::extractBoolean(vars, flag, "FALSE_PREFIX", "_FALSE_SUFFIX");
- ASSERT_EQ(1, vars.size());
+ ASSERT_EQ(1U, vars.size());
string expected = "FALSE_PREFIX_FALSE_SUFFIX=false\n";
EXPECT_EQ(expected, join(vars));
flag = true;
RunScriptImpl::extractBoolean(vars, flag, "TRUE_PREFIX", "_TRUE_SUFFIX");
- ASSERT_EQ(2, vars.size());
+ ASSERT_EQ(2U, vars.size());
expected = "FALSE_PREFIX_FALSE_SUFFIX=false\n"
"TRUE_PREFIX_TRUE_SUFFIX=true\n";
EXPECT_EQ(expected, join(vars));
ProcessEnvVars vars;
uint64_t value = 0;
RunScriptImpl::extractInteger(vars, value, "ZERO_PREFIX", "_ZERO_SUFFIX");
- ASSERT_EQ(1, vars.size());
+ ASSERT_EQ(1U, vars.size());
string expected = "ZERO_PREFIX_ZERO_SUFFIX=0\n";
EXPECT_EQ(expected, join(vars));
value = 1;
RunScriptImpl::extractInteger(vars, value, "ONE_PREFIX", "_ONE_SUFFIX");
- ASSERT_EQ(2, vars.size());
+ ASSERT_EQ(2U, vars.size());
expected = "ZERO_PREFIX_ZERO_SUFFIX=0\n"
"ONE_PREFIX_ONE_SUFFIX=1\n";
EXPECT_EQ(expected, join(vars));
value = 1000;
RunScriptImpl::extractInteger(vars, value, "THOUSAND_PREFIX", "_THOUSAND_SUFFIX");
- ASSERT_EQ(3, vars.size());
+ ASSERT_EQ(3U, vars.size());
expected = "ZERO_PREFIX_ZERO_SUFFIX=0\n"
"ONE_PREFIX_ONE_SUFFIX=1\n"
"THOUSAND_PREFIX_THOUSAND_SUFFIX=1000\n";
ProcessEnvVars vars;
string value = "";
RunScriptImpl::extractString(vars, value, "EMPTY_PREFIX", "_EMPTY_SUFFIX");
- ASSERT_EQ(1, vars.size());
+ ASSERT_EQ(1U, vars.size());
string expected = "EMPTY_PREFIX_EMPTY_SUFFIX=\n";
EXPECT_EQ(expected, join(vars));
value = "SOMETHING";
RunScriptImpl::extractString(vars, value, "NON_EMPTY_PREFIX", "_NON_EMPTY_SUFFIX");
- ASSERT_EQ(2, vars.size());
+ ASSERT_EQ(2U, vars.size());
expected = "EMPTY_PREFIX_EMPTY_SUFFIX=\n"
"NON_EMPTY_PREFIX_NON_EMPTY_SUFFIX=SOMETHING\n";
EXPECT_EQ(expected, join(vars));
ProcessEnvVars vars;
HWAddrPtr hwaddr;
RunScriptImpl::extractHWAddr(vars, hwaddr, "HWADDR_PREFIX", "_HWADDR_SUFFIX");
- ASSERT_EQ(2, vars.size());
+ ASSERT_EQ(2U, vars.size());
string expected = "HWADDR_PREFIX_HWADDR_SUFFIX=\n"
"HWADDR_PREFIX_TYPE_HWADDR_SUFFIX=\n";
EXPECT_EQ(expected, join(vars));
vars.clear();
hwaddr = generateHWAddr();
RunScriptImpl::extractHWAddr(vars, hwaddr, "HWADDR_PREFIX", "_HWADDR_SUFFIX");
- ASSERT_EQ(2, vars.size());
+ ASSERT_EQ(2U, vars.size());
expected = "HWADDR_PREFIX_HWADDR_SUFFIX=00:01:02:03\n"
"HWADDR_PREFIX_TYPE_HWADDR_SUFFIX=1\n";
EXPECT_EQ(expected, join(vars));
ProcessEnvVars vars;
DuidPtr duid;
RunScriptImpl::extractDUID(vars, duid, "DUID_PREFIX", "_DUID_SUFFIX");
- ASSERT_EQ(1, vars.size());
+ ASSERT_EQ(1U, vars.size());
string expected = "DUID_PREFIX_DUID_SUFFIX=\n";
EXPECT_EQ(expected, join(vars));
vars.clear();
duid = generateDUID();
RunScriptImpl::extractDUID(vars, duid, "DUID_PREFIX", "_DUID_SUFFIX");
- ASSERT_EQ(1, vars.size());
+ ASSERT_EQ(1U, vars.size());
expected = "DUID_PREFIX_DUID_SUFFIX=00:01:02:03:04:05:06\n";
EXPECT_EQ(expected, join(vars));
}
ProcessEnvVars vars;
OptionPtr option;
RunScriptImpl::extractOption(vars, option, "OPTION_PREFIX", "_OPTION_SUFFIX");
- ASSERT_EQ(0, vars.size());
+ ASSERT_EQ(0U, vars.size());
OptionBuffer buffer = { 0xca, 0xfe, 0xba, 0xbe };
option = generateOption(Option::V4, DHO_USER_CLASS, buffer);
RunScriptImpl::extractOption(vars, option, "OPTION_PREFIX", "_OPTION_SUFFIX");
- ASSERT_EQ(1, vars.size());
+ ASSERT_EQ(1U, vars.size());
string expected = "OPTION_PREFIX_OPTION_77_OPTION_SUFFIX=0xCAFEBABE\n";
EXPECT_EQ(expected, join(vars));
}
ProcessEnvVars vars;
OptionPtr option;
RunScriptImpl::extractOption(vars, option, "OPTION_SUBOPTION_PREFIX", "_OPTION_SUBOPTION_SUFFIX");
- ASSERT_EQ(0, vars.size());
+ ASSERT_EQ(0U, vars.size());
OptionBuffer data;
option = generateOption(Option::V4, DHO_DHCP_AGENT_OPTIONS, data);
uint8_t subscriber_id[] = { 0x1a, 0x2b, 0x3c, 0x4d, 0x5e, 0x6f };
subscriber_id + sizeof(subscriber_id))));
option->addOption(subscriber_id_opt);
RunScriptImpl::extractSubOption(vars, option, RAI_OPTION_SUBSCRIBER_ID, "OPTION_SUBOPTION_PREFIX", "_OPTION_SUBOPTION_SUFFIX");
- ASSERT_EQ(1, vars.size());
+ ASSERT_EQ(1U, vars.size());
string expected = "OPTION_SUBOPTION_PREFIX_OPTION_82_SUB_OPTION_6_OPTION_SUBOPTION_SUFFIX=0x1A2B3C4D5E6F\n";
EXPECT_EQ(expected, join(vars));
}
ProcessEnvVars vars;
Option6IAPtr optionia;
RunScriptImpl::extractOptionIA(vars, optionia, "OPTIONIA_PREFIX", "_OPTIONIA_SUFFIX");
- ASSERT_EQ(4, vars.size());
+ ASSERT_EQ(4U, vars.size());
string expected = "OPTIONIA_PREFIX_IAID_OPTIONIA_SUFFIX=\n"
"OPTIONIA_PREFIX_IA_TYPE_OPTIONIA_SUFFIX=\n"
"OPTIONIA_PREFIX_IA_T1_OPTIONIA_SUFFIX=\n"
vars.clear();
optionia = generateOptionIA();
RunScriptImpl::extractOptionIA(vars, optionia, "OPTIONIA_PREFIX", "_OPTIONIA_SUFFIX");
- ASSERT_EQ(4, vars.size());
+ ASSERT_EQ(4U, vars.size());
expected = "OPTIONIA_PREFIX_IAID_OPTIONIA_SUFFIX=2711790500\n"
"OPTIONIA_PREFIX_IA_TYPE_OPTIONIA_SUFFIX=3\n"
"OPTIONIA_PREFIX_IA_T1_OPTIONIA_SUFFIX=2164392708\n"
ProcessEnvVars vars;
Subnet4Ptr subnet4;
RunScriptImpl::extractSubnet4(vars, subnet4, "SUBNET4_PREFIX", "_SUBNET4_SUFFIX");
- ASSERT_EQ(4, vars.size());
+ ASSERT_EQ(4U, vars.size());
string expected = "SUBNET4_PREFIX_ID_SUBNET4_SUFFIX=\n"
"SUBNET4_PREFIX_NAME_SUBNET4_SUFFIX=\n"
"SUBNET4_PREFIX_PREFIX_SUBNET4_SUFFIX=\n"
vars.clear();
subnet4 = generateSubnet4();
RunScriptImpl::extractSubnet4(vars, subnet4, "SUBNET4_PREFIX", "_SUBNET4_SUFFIX");
- ASSERT_EQ(4, vars.size());
+ ASSERT_EQ(4U, vars.size());
expected = "SUBNET4_PREFIX_ID_SUBNET4_SUFFIX=6\n"
"SUBNET4_PREFIX_NAME_SUBNET4_SUFFIX=182.168.0.1/2\n"
"SUBNET4_PREFIX_PREFIX_SUBNET4_SUFFIX=182.168.0.1\n"
ProcessEnvVars vars;
Subnet6Ptr subnet6;
RunScriptImpl::extractSubnet6(vars, subnet6, "SUBNET6_PREFIX", "_SUBNET6_SUFFIX");
- ASSERT_EQ(4, vars.size());
+ ASSERT_EQ(4U, vars.size());
string expected = "SUBNET6_PREFIX_ID_SUBNET6_SUFFIX=\n"
"SUBNET6_PREFIX_NAME_SUBNET6_SUFFIX=\n"
"SUBNET6_PREFIX_PREFIX_SUBNET6_SUFFIX=\n"
vars.clear();
subnet6 = generateSubnet6();
RunScriptImpl::extractSubnet6(vars, subnet6, "SUBNET6_PREFIX", "_SUBNET6_SUFFIX");
- ASSERT_EQ(4, vars.size());
+ ASSERT_EQ(4U, vars.size());
expected = "SUBNET6_PREFIX_ID_SUBNET6_SUFFIX=7\n"
"SUBNET6_PREFIX_NAME_SUBNET6_SUFFIX=2003:db8::1/2\n"
"SUBNET6_PREFIX_PREFIX_SUBNET6_SUFFIX=2003:db8::1\n"
ProcessEnvVars vars;
Lease4Ptr lease4;
RunScriptImpl::extractLease4(vars, lease4, "LEASE4_PREFIX", "_LEASE4_SUFFIX");
- ASSERT_EQ(9, vars.size());
+ ASSERT_EQ(9U, vars.size());
string expected = "LEASE4_PREFIX_ADDRESS_LEASE4_SUFFIX=\n"
"LEASE4_PREFIX_CLTT_LEASE4_SUFFIX=\n"
"LEASE4_PREFIX_HOSTNAME_LEASE4_SUFFIX=\n"
vars.clear();
lease4 = generateLease4();
RunScriptImpl::extractLease4(vars, lease4, "LEASE4_PREFIX", "_LEASE4_SUFFIX");
- ASSERT_EQ(9, vars.size());
+ ASSERT_EQ(9U, vars.size());
expected = "LEASE4_PREFIX_ADDRESS_LEASE4_SUFFIX=192.168.0.1\n"
"LEASE4_PREFIX_CLTT_LEASE4_SUFFIX=3\n"
"LEASE4_PREFIX_HOSTNAME_LEASE4_SUFFIX=test.hostname\n"
ProcessEnvVars vars;
Lease6Ptr lease6;
RunScriptImpl::extractLease6(vars, lease6, "LEASE6_PREFIX", "_LEASE6_SUFFIX");
- ASSERT_EQ(13, vars.size());
+ ASSERT_EQ(13U, vars.size());
string expected = "LEASE6_PREFIX_ADDRESS_LEASE6_SUFFIX=\n"
"LEASE6_PREFIX_CLTT_LEASE6_SUFFIX=\n"
"LEASE6_PREFIX_HOSTNAME_LEASE6_SUFFIX=\n"
vars.clear();
lease6 = generateLease6();
RunScriptImpl::extractLease6(vars, lease6, "LEASE6_PREFIX", "_LEASE6_SUFFIX");
- ASSERT_EQ(13, vars.size());
+ ASSERT_EQ(13U, vars.size());
expected = "LEASE6_PREFIX_ADDRESS_LEASE6_SUFFIX=2003:db8::1\n"
"LEASE6_PREFIX_CLTT_LEASE6_SUFFIX=7\n"
"LEASE6_PREFIX_HOSTNAME_LEASE6_SUFFIX=test.hostname\n"
ProcessEnvVars vars;
Lease4CollectionPtr leases4;
RunScriptImpl::extractLeases4(vars, leases4, "LEASES4_PREFIX", "_LEASES4_SUFFIX");
- ASSERT_EQ(1, vars.size());
+ ASSERT_EQ(1U, vars.size());
string expected = "LEASES4_PREFIX_SIZE_LEASES4_SUFFIX=0\n";
EXPECT_EQ(expected, join(vars));
vars.clear();
leases4->push_back(generateLease4());
leases4->push_back(generateLease4());
RunScriptImpl::extractLeases4(vars, leases4, "LEASES4_PREFIX", "_LEASES4_SUFFIX");
- ASSERT_EQ(19, vars.size());
+ ASSERT_EQ(19U, vars.size());
expected = "LEASES4_PREFIX_SIZE_LEASES4_SUFFIX=2\n"
"LEASES4_PREFIX_AT0_ADDRESS_LEASES4_SUFFIX=192.168.0.1\n"
"LEASES4_PREFIX_AT0_CLTT_LEASES4_SUFFIX=3\n"
ProcessEnvVars vars;
Lease6CollectionPtr leases6;
RunScriptImpl::extractLeases6(vars, leases6, "LEASES6_PREFIX", "_LEASES6_SUFFIX");
- ASSERT_EQ(1, vars.size());
+ ASSERT_EQ(1U, vars.size());
string expected = "LEASES6_PREFIX_SIZE_LEASES6_SUFFIX=0\n";
EXPECT_EQ(expected, join(vars));
vars.clear();
leases6->push_back(generateLease6());
leases6->push_back(generateLease6());
RunScriptImpl::extractLeases6(vars, leases6, "LEASES6_PREFIX", "_LEASES6_SUFFIX");
- ASSERT_EQ(27, vars.size());
+ ASSERT_EQ(27U, vars.size());
expected = "LEASES6_PREFIX_SIZE_LEASES6_SUFFIX=2\n"
"LEASES6_PREFIX_AT0_ADDRESS_LEASES6_SUFFIX=2003:db8::1\n"
"LEASES6_PREFIX_AT0_CLTT_LEASES6_SUFFIX=7\n"
ProcessEnvVars vars;
Pkt4Ptr pkt4;
RunScriptImpl::extractPkt4(vars, pkt4, "PKT4_PREFIX", "_PKT4_SUFFIX");
- ASSERT_EQ(22, vars.size());
+ ASSERT_EQ(22U, vars.size());
string expected = "PKT4_PREFIX_TYPE_PKT4_SUFFIX=\n"
"PKT4_PREFIX_TXID_PKT4_SUFFIX=\n"
"PKT4_PREFIX_LOCAL_ADDR_PKT4_SUFFIX=\n"
vars.clear();
pkt4 = generatePkt4();
RunScriptImpl::extractPkt4(vars, pkt4, "PKT4_PREFIX", "_PKT4_SUFFIX");
- ASSERT_EQ(25, vars.size());
+ ASSERT_EQ(25U, vars.size());
expected = "PKT4_PREFIX_TYPE_PKT4_SUFFIX=UNKNOWN\n"
"PKT4_PREFIX_TXID_PKT4_SUFFIX=0\n"
"PKT4_PREFIX_LOCAL_ADDR_PKT4_SUFFIX=0.0.0.0\n"
ProcessEnvVars vars;
Pkt6Ptr pkt6;
RunScriptImpl::extractPkt6(vars, pkt6, "PKT6_PREFIX", "_PKT6_SUFFIX");
- ASSERT_EQ(12, vars.size());
+ ASSERT_EQ(12U, vars.size());
string expected = "PKT6_PREFIX_TYPE_PKT6_SUFFIX=\n"
"PKT6_PREFIX_TXID_PKT6_SUFFIX=\n"
"PKT6_PREFIX_LOCAL_ADDR_PKT6_SUFFIX=\n"
vars.clear();
pkt6 = generatePkt6();
RunScriptImpl::extractPkt6(vars, pkt6, "PKT6_PREFIX", "_PKT6_SUFFIX");
- ASSERT_EQ(15, vars.size());
+ ASSERT_EQ(15U, vars.size());
expected = "PKT6_PREFIX_TYPE_PKT6_SUFFIX=UNKNOWN\n"
"PKT6_PREFIX_TXID_PKT6_SUFFIX=0\n"
"PKT6_PREFIX_LOCAL_ADDR_PKT6_SUFFIX=ff02::1:2\n"
// Updated configuration should contain two subnets.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4();
- ASSERT_EQ(2, cfg->getAll()->size());
+ ASSERT_EQ(2U, cfg->getAll()->size());
// Make sure that the subnets are correct.
ConstSubnet4Ptr subnet = cfg->getBySubnetId(SubnetID(101));
// Make sure we inherited the server's globals
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(1111, subnet->getT1().get());
+ EXPECT_EQ(1111U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(2222, subnet->getT2().get());
+ EXPECT_EQ(2222U, subnet->getT2().get());
// The subnet we have added initially should still be there.
subnet = cfg->getBySubnetId(SubnetID(5));
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
// Make sure that the statistics have been updated for the new subnet.
auto total_addresses = stats::StatsMgr::instance().getObservation("subnet[101].total-addresses");
// Updated configuration should contain one subnet.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4();
- ASSERT_EQ(1, cfg->getAll()->size());
+ ASSERT_EQ(1U, cfg->getAll()->size());
// Make sure that the subnet is correct.
ConstSubnet4Ptr subnet = cfg->getBySubnetId(SubnetID(101));
// Updated configuration should contain two subnets.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4();
- ASSERT_EQ(2, cfg->getAll()->size());
+ ASSERT_EQ(2U, cfg->getAll()->size());
// Make sure that the subnets are correct.
auto subnet_it = cfg->getAll()->begin();
// The other subnet we have added initially should still be there.
Subnet4Ptr subnet = *subnet_it;;
ASSERT_TRUE(subnet);
- EXPECT_EQ(5, subnet->getID());
+ EXPECT_EQ(5U, subnet->getID());
EXPECT_EQ("10.0.0.0/8", subnet->toText());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
// Verify the updated subnet.
subnet = *++subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(101, subnet->getID());
+ EXPECT_EQ(101U, subnet->getID());
EXPECT_EQ("192.0.2.0/24", subnet->toText());
// Make sure we inherited the server's globals
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(1111, subnet->getT1().get());
+ EXPECT_EQ(1111U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(2222, subnet->getT2().get());
+ EXPECT_EQ(2222U, subnet->getT2().get());
// Make sure that the statistics have been updated for the new subnet.
total_addresses = stats::StatsMgr::instance().getObservation("subnet[101].total-addresses");
// Updated configuration should contain one subnet.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4();
- ASSERT_EQ(1, cfg->getAll()->size());
+ ASSERT_EQ(1U, cfg->getAll()->size());
// Make sure that the subnet is correct.
auto subnet_it = cfg->getAll()->begin();
Subnet4Ptr subnet = *subnet_it;;
ASSERT_TRUE(subnet);
- EXPECT_EQ(101, subnet->getID());
+ EXPECT_EQ(101U, subnet->getID());
EXPECT_EQ("192.0.2.0/24", subnet->toText());
EXPECT_EQ("flq", subnet->getAllocatorType().get());
// Updated configuration should contain two subnets.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4();
- ASSERT_EQ(2, cfg->getAll()->size());
+ ASSERT_EQ(2U, cfg->getAll()->size());
EXPECT_FALSE(cfg->getBySubnetId(SubnetID(10)));
// Make sure that the reservations are gone after the subnet was
// Updated configuration should contain two subnets.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4();
- ASSERT_EQ(2, cfg->getAll()->size());
+ ASSERT_EQ(2U, cfg->getAll()->size());
// Make sure that the subnets are correct.
auto subnet_it = cfg->getAll()->begin();
// The other subnet we have added initially should still be there.
Subnet4Ptr subnet = *subnet_it;;
ASSERT_TRUE(subnet);
- EXPECT_EQ(5, subnet->getID());
+ EXPECT_EQ(5U, subnet->getID());
EXPECT_EQ("10.0.0.0/8", subnet->toText());
- EXPECT_EQ(0, subnet->getPools(Lease::TYPE_V4).size());
+ EXPECT_EQ(0U, subnet->getPools(Lease::TYPE_V4).size());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
// Verify the updated subnet.
subnet = *++subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(101, subnet->getID());
+ EXPECT_EQ(101U, subnet->getID());
EXPECT_EQ("192.0.2.0/24", subnet->toText());
- EXPECT_EQ(i + 1, subnet->getPools(Lease::TYPE_V4).size());
+ EXPECT_EQ(i + 1U, subnet->getPools(Lease::TYPE_V4).size());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
// Make sure that the statistics have been updated for the subnet.
total_addresses = stats::StatsMgr::instance().getObservation("subnet[101].total-addresses");
// Updated configuration should contain two subnets.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4();
- ASSERT_EQ(2, cfg->getAll()->size());
+ ASSERT_EQ(2U, cfg->getAll()->size());
// Make sure that the subnets are correct.
auto subnet_it = cfg->getAll()->begin();
// The other subnet we have added initially should still be there.
Subnet4Ptr subnet = *subnet_it;;
ASSERT_TRUE(subnet);
- EXPECT_EQ(5, subnet->getID());
+ EXPECT_EQ(5U, subnet->getID());
EXPECT_EQ("10.0.0.0/8", subnet->toText());
- EXPECT_EQ(0, subnet->getPools(Lease::TYPE_V4).size());
+ EXPECT_EQ(0U, subnet->getPools(Lease::TYPE_V4).size());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
// Verify the updated subnet.
subnet = *++subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(101, subnet->getID());
+ EXPECT_EQ(101U, subnet->getID());
EXPECT_EQ("192.0.2.0/24", subnet->toText());
- EXPECT_EQ(16 - (i + 1), subnet->getPools(Lease::TYPE_V4).size());
+ EXPECT_EQ(16U - (i + 1), subnet->getPools(Lease::TYPE_V4).size());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
}
// The pools should have been removed, so the statistics is 0.
// Updated configuration should contain two subnets.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4();
- ASSERT_EQ(2, cfg->getAll()->size());
+ ASSERT_EQ(2U, cfg->getAll()->size());
// Make sure that the subnets are correct.
auto subnet_it = cfg->getAll()->begin();
// The other subnet we have added initially should still be there.
Subnet4Ptr subnet = *subnet_it;;
ASSERT_TRUE(subnet);
- EXPECT_EQ(5, subnet->getID());
+ EXPECT_EQ(5U, subnet->getID());
EXPECT_EQ("10.0.0.0/8", subnet->toText());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
// Verify the updated subnet.
subnet = *++subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(101, subnet->getID());
+ EXPECT_EQ(101U, subnet->getID());
EXPECT_EQ("192.0.2.0/24", subnet->toText());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
for (auto const& again : test.rerun_scenario_) {
handler(test_steps[again]);
}
// Now make sure the network is there and the two subnets are associated
// with that network.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSharedNetworks4();
- ASSERT_EQ(1, cfg->getAll()->size());
+ ASSERT_EQ(1U, cfg->getAll()->size());
auto net = cfg->getByName("floor1");
ASSERT_TRUE(net);
EXPECT_FALSE(net->getT1().unspecified());
- EXPECT_EQ(1011, net->getT1().get());
+ EXPECT_EQ(1011U, net->getT1().get());
EXPECT_FALSE(net->getT2().unspecified());
- EXPECT_EQ(2222, net->getT2().get());
+ EXPECT_EQ(2222U, net->getT2().get());
auto subnets = net->getAllSubnets();
- EXPECT_EQ(2, subnets->size());
+ EXPECT_EQ(2U, subnets->size());
ConstSubnet4Ptr subnet1 = net->getSubnet(100);
ConstSubnet4Ptr subnet2 = net->getSubnet(101);
ASSERT_TRUE(subnet1);
// Make sure subnet1 inherited the server and network globals
EXPECT_FALSE(subnet1->getT1().unspecified());
- EXPECT_EQ(1011, subnet1->getT1().get());
+ EXPECT_EQ(1011U, subnet1->getT1().get());
EXPECT_FALSE(subnet1->getT2().unspecified());
- EXPECT_EQ(2222, subnet1->getT2().get());
+ EXPECT_EQ(2222U, subnet1->getT2().get());
// Make sure subnet2 one kept its own
EXPECT_FALSE(subnet2->getT1().unspecified());
- EXPECT_EQ(1001, subnet2->getT1().get());
+ EXPECT_EQ(1001U, subnet2->getT1().get());
EXPECT_FALSE(subnet2->getT2().unspecified());
- EXPECT_EQ(2002, subnet2->getT2().get());
+ EXPECT_EQ(2002U, subnet2->getT2().get());
// Also make sure the subnets from this network are added to the generic pool
// of subnets.
auto cfg_subnets = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4();
- EXPECT_EQ(2, cfg_subnets->getAll()->size());
+ EXPECT_EQ(2U, cfg_subnets->getAll()->size());
subnet1 = cfg_subnets->getBySubnetId(100);
subnet2 = cfg_subnets->getBySubnetId(101);
ASSERT_TRUE(subnet1);
// Now make sure the network is there and the two subnets are associated
// with that network.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSharedNetworks4();
- ASSERT_EQ(1, cfg->getAll()->size());
+ ASSERT_EQ(1U, cfg->getAll()->size());
auto net = cfg->getByName("floor1");
ASSERT_TRUE(net);
auto subnets = net->getAllSubnets();
- EXPECT_EQ(2, subnets->size());
+ EXPECT_EQ(2U, subnets->size());
ConstSubnet4Ptr subnet1 = net->getSubnet(100);
ConstSubnet4Ptr subnet2 = net->getSubnet(101);
ASSERT_TRUE(subnet1);
// Also make sure the subnets from this network are added to the generic pool
// of subnets.
auto cfg_subnets = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4();
- EXPECT_EQ(2, cfg_subnets->getAll()->size());
+ EXPECT_EQ(2U, cfg_subnets->getAll()->size());
subnet1 = cfg_subnets->getBySubnetId(100);
subnet2 = cfg_subnets->getBySubnetId(101);
ASSERT_TRUE(subnet1);
// Now check that the subnet was added to the network.
auto networks = CfgMgr::instance().getCurrentCfg()->getCfgSharedNetworks4();
- ASSERT_EQ(1, networks->getAll()->size());
+ ASSERT_EQ(1U, networks->getAll()->size());
auto net = networks->getByName("floor1");
ASSERT_TRUE(net);
auto networks = CfgMgr::instance().getCurrentCfg()->getCfgSharedNetworks4();
auto subnets = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4();
- ASSERT_EQ(1, networks->getAll()->size());
+ ASSERT_EQ(1U, networks->getAll()->size());
auto net = networks->getByName("floor1");
ASSERT_TRUE(net);
// Updated configuration should contain two subnets.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets6();
- ASSERT_EQ(2, cfg->getAll()->size());
+ ASSERT_EQ(2U, cfg->getAll()->size());
// Make sure that the subnets are correct.
ConstSubnet6Ptr subnet = cfg->getBySubnetId(SubnetID(101));
// Make sure we inherited the server's globals
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(1111, subnet->getT1().get());
+ EXPECT_EQ(1111U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(2222, subnet->getT2().get());
+ EXPECT_EQ(2222U, subnet->getT2().get());
// The subnet we have added initially should still be there.
subnet = cfg->getBySubnetId(SubnetID(5));
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
// Make sure that the statistics have been updated for the new subnet.
auto total_nas = stats::StatsMgr::instance().getObservation("subnet[101].total-nas");
// Updated configuration should contain one subnet.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets6();
- ASSERT_EQ(1, cfg->getAll()->size());
+ ASSERT_EQ(1U, cfg->getAll()->size());
// Make sure that the subnet is correct.
ConstSubnet6Ptr subnet = cfg->getBySubnetId(SubnetID(101));
// Updated configuration should contain two subnets.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets6();
- ASSERT_EQ(2, cfg->getAll()->size());
+ ASSERT_EQ(2U, cfg->getAll()->size());
// Make sure that the subnets are correct.
auto subnet_it = cfg->getAll()->begin();
// The other subnet we have added initially should still be there.
Subnet6Ptr subnet = *subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(5, subnet->getID());
+ EXPECT_EQ(5U, subnet->getID());
EXPECT_EQ("2001:db8:1::/64", subnet->toText());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
// Verify the updated subnet.
subnet = *++subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(101, subnet->getID());
+ EXPECT_EQ(101U, subnet->getID());
EXPECT_EQ("3000::/16", subnet->toText());
// Make sure we inherited the server's globals
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(1111, subnet->getT1().get());
+ EXPECT_EQ(1111U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(2222, subnet->getT2().get());
+ EXPECT_EQ(2222U, subnet->getT2().get());
// Make sure that the statistics have been updated for the new subnet.
total_nas = stats::StatsMgr::instance().getObservation("subnet[101].total-nas");
// Updated configuration should contain one subnet.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets6();
- ASSERT_EQ(1, cfg->getAll()->size());
+ ASSERT_EQ(1U, cfg->getAll()->size());
// Make sure that the subnet is correct.
auto subnet_it = cfg->getAll()->begin();
// The other subnet we have added initially should still be there.
Subnet6Ptr subnet = *subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(101, subnet->getID());
+ EXPECT_EQ(101U, subnet->getID());
EXPECT_EQ("3000::/16", subnet->toText());
EXPECT_EQ("flq", subnet->getPdAllocatorType().get());
// Updated configuration should contain two subnets.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets6();
- ASSERT_EQ(2, cfg->getAll()->size());
+ ASSERT_EQ(2U, cfg->getAll()->size());
EXPECT_FALSE(cfg->getBySubnetId(SubnetID(10)));
// Make sure that the reservations are gone after the subnet was
// Updated configuration should contain two subnets.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets6();
- ASSERT_EQ(2, cfg->getAll()->size());
+ ASSERT_EQ(2U, cfg->getAll()->size());
// Make sure that the subnets are correct.
auto subnet_it = cfg->getAll()->begin();
// The other subnet we have added initially should still be there.
Subnet6Ptr subnet = *subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(5, subnet->getID());
+ EXPECT_EQ(5U, subnet->getID());
EXPECT_EQ("2001:db8:1::/64", subnet->toText());
- EXPECT_EQ(0, subnet->getPools(Lease::TYPE_NA).size());
+ EXPECT_EQ(0U, subnet->getPools(Lease::TYPE_NA).size());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
// Verify the updated subnet.
subnet = *++subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(101, subnet->getID());
+ EXPECT_EQ(101U, subnet->getID());
EXPECT_EQ("3000::/16", subnet->toText());
- EXPECT_EQ(i + 1, subnet->getPools(Lease::TYPE_NA).size());
+ EXPECT_EQ(i + 1U, subnet->getPools(Lease::TYPE_NA).size());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
// Make sure that the statistics have been updated for the subnet.
total_nas = stats::StatsMgr::instance().getObservation("subnet[101].total-nas");
// Updated configuration should contain two subnets.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets6();
- ASSERT_EQ(2, cfg->getAll()->size());
+ ASSERT_EQ(2U, cfg->getAll()->size());
// Make sure that the subnets are correct.
auto subnet_it = cfg->getAll()->begin();
// The other subnet we have added initially should still be there.
Subnet6Ptr subnet = *subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(5, subnet->getID());
+ EXPECT_EQ(5U, subnet->getID());
EXPECT_EQ("2001:db8:1::/64", subnet->toText());
- EXPECT_EQ(0, subnet->getPools(Lease::TYPE_NA).size());
+ EXPECT_EQ(0U, subnet->getPools(Lease::TYPE_NA).size());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
// Verify the updated subnet.
subnet = *++subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(101, subnet->getID());
+ EXPECT_EQ(101U, subnet->getID());
EXPECT_EQ("3000::/16", subnet->toText());
- EXPECT_EQ(16 - (i + 1), subnet->getPools(Lease::TYPE_NA).size());
+ EXPECT_EQ(16U - (i + 1), subnet->getPools(Lease::TYPE_NA).size());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
}
// The pools should have been removed, so the statistics is 0.
// Updated configuration should contain two subnets.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets6();
- ASSERT_EQ(2, cfg->getAll()->size());
+ ASSERT_EQ(2U, cfg->getAll()->size());
// Make sure that the subnets are correct.
auto subnet_it = cfg->getAll()->begin();
// The other subnet we have added initially should still be there.
Subnet6Ptr subnet = *subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(5, subnet->getID());
+ EXPECT_EQ(5U, subnet->getID());
EXPECT_EQ("2001:db8:1::/64", subnet->toText());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
// Verify the updated subnet.
subnet = *++subnet_it;
ASSERT_TRUE(subnet);
- EXPECT_EQ(101, subnet->getID());
+ EXPECT_EQ(101U, subnet->getID());
EXPECT_EQ("3000::/16", subnet->toText());
// Make sure we didn't overwrite its timer values
EXPECT_FALSE(subnet->getT1().unspecified());
- EXPECT_EQ(30, subnet->getT1().get());
+ EXPECT_EQ(30U, subnet->getT1().get());
EXPECT_FALSE(subnet->getT2().unspecified());
- EXPECT_EQ(40, subnet->getT2().get());
+ EXPECT_EQ(40U, subnet->getT2().get());
for (auto const& again : test.rerun_scenario_) {
handler(test_steps[again]);
}
// Now make sure the network is there and the two subnets are associated
// with that network.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSharedNetworks6();
- ASSERT_EQ(1, cfg->getAll()->size());
+ ASSERT_EQ(1U, cfg->getAll()->size());
auto net = cfg->getByName("floor1");
ASSERT_TRUE(net);
EXPECT_FALSE(net->getT1().unspecified());
- EXPECT_EQ(1011, net->getT1().get());
+ EXPECT_EQ(1011U, net->getT1().get());
EXPECT_FALSE(net->getT2().unspecified());
- EXPECT_EQ(2222, net->getT2().get());
+ EXPECT_EQ(2222U, net->getT2().get());
auto subnets = net->getAllSubnets();
- EXPECT_EQ(2, subnets->size());
+ EXPECT_EQ(2U, subnets->size());
ConstSubnet6Ptr subnet1 = net->getSubnet(100);
ConstSubnet6Ptr subnet2 = net->getSubnet(101);
ASSERT_TRUE(subnet1);
// Make sure subnet1 inherited the server and network globals
EXPECT_FALSE(subnet1->getT1().unspecified());
- EXPECT_EQ(1011, subnet1->getT1().get());
+ EXPECT_EQ(1011U, subnet1->getT1().get());
EXPECT_FALSE(subnet1->getT2().unspecified());
- EXPECT_EQ(2222, subnet1->getT2().get());
+ EXPECT_EQ(2222U, subnet1->getT2().get());
// Make sure subnet2 one kept its own
EXPECT_FALSE(subnet2->getT1().unspecified());
- EXPECT_EQ(1001, subnet2->getT1().get());
+ EXPECT_EQ(1001U, subnet2->getT1().get());
EXPECT_FALSE(subnet2->getT2().unspecified());
- EXPECT_EQ(2002, subnet2->getT2().get());
+ EXPECT_EQ(2002U, subnet2->getT2().get());
// Also make sure the subnets from this network are added to the generic pool
// of subnets.
auto cfg_subnets = CfgMgr::instance().getCurrentCfg()->getCfgSubnets6();
- EXPECT_EQ(2, cfg_subnets->getAll()->size());
+ EXPECT_EQ(2U, cfg_subnets->getAll()->size());
subnet1 = cfg_subnets->getBySubnetId(100);
subnet2 = cfg_subnets->getBySubnetId(101);
ASSERT_TRUE(subnet1);
// Now make sure the network is there and the two subnets are associated
// with that network.
auto cfg = CfgMgr::instance().getCurrentCfg()->getCfgSharedNetworks6();
- ASSERT_EQ(1, cfg->getAll()->size());
+ ASSERT_EQ(1U, cfg->getAll()->size());
auto net = cfg->getByName("floor1");
ASSERT_TRUE(net);
auto subnets = net->getAllSubnets();
- EXPECT_EQ(2, subnets->size());
+ EXPECT_EQ(2U, subnets->size());
ConstSubnet6Ptr subnet1 = net->getSubnet(100);
ConstSubnet6Ptr subnet2 = net->getSubnet(101);
ASSERT_TRUE(subnet1);
// Also make sure the subnets from this network are added to the generic pool
// of subnets.
auto cfg_subnets = CfgMgr::instance().getCurrentCfg()->getCfgSubnets6();
- EXPECT_EQ(2, cfg_subnets->getAll()->size());
+ EXPECT_EQ(2U, cfg_subnets->getAll()->size());
subnet1 = cfg_subnets->getBySubnetId(100);
subnet2 = cfg_subnets->getBySubnetId(101);
ASSERT_TRUE(subnet1);
// Now check that the subnet was added to the network.
auto networks = CfgMgr::instance().getCurrentCfg()->getCfgSharedNetworks6();
- ASSERT_EQ(1, networks->getAll()->size());
+ ASSERT_EQ(1U, networks->getAll()->size());
auto net = networks->getByName("floor1");
ASSERT_TRUE(net);
auto networks = CfgMgr::instance().getCurrentCfg()->getCfgSharedNetworks6();
auto subnets = CfgMgr::instance().getCurrentCfg()->getCfgSubnets6();
- ASSERT_EQ(1, networks->getAll()->size());
+ ASSERT_EQ(1U, networks->getAll()->size());
auto net = networks->getByName("floor1");
ASSERT_TRUE(net);
isc::data::ConstElementPtr subnet_list = args->get(subnet_parameter);
ASSERT_TRUE(subnet_list);
ASSERT_EQ(isc::data::Element::list, subnet_list->getType());
- ASSERT_EQ(1, subnet_list->size());
+ ASSERT_EQ(1U, subnet_list->size());
// Subnet is stored within a list, even though this is a single element.
// In the future we may want to query for a collection of subnets.
projects / thirdparty / kea.git / commitdiff
