ASSERT_NO_THROW(util::str::decodeFormattedHexString(scenario.rai_data_, opt_data))
<< "scenario.rai_data_ is invalid, test is broken";
const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
- ASSERT_GT(opt_data.size(), 2);
+ ASSERT_GT(opt_data.size(), 2U);
ASSERT_EQ(DHO_DHCP_AGENT_OPTIONS, opt_data[0]);
- ASSERT_EQ(opt_data[1] + 2, opt_data.size());
+ ASSERT_EQ(opt_data[1] + 2U, opt_data.size());
std::vector<uint8_t> rai_data(opt_data.cbegin() + 2,
opt_data.cend());
OptionCustomPtr rai;
EXPECT_EQ(addr, lease->addr_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
}
// This test checks if a lease can't be reused in DHCPREQUEST (real allocation)
EXPECT_EQ(addr, lease->addr_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was updated in the database.
Lease4Ptr from_mgr = LeaseMgrFactory::instance().getLease4(addr);
EXPECT_EQ(addr, lease->addr_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
}
// This test checks if a lease can't be reused in DHCPREQUEST (real allocation)
EXPECT_EQ(addr, lease->addr_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was updated in the database.
Lease4Ptr from_mgr = LeaseMgrFactory::instance().getLease4(addr);
EXPECT_EQ(addr, lease->addr_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
}
// This test checks if a lease can't be reused in DHCPREQUEST (real allocation)
EXPECT_EQ(addr, lease->addr_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
EXPECT_EQ("bar", lease->hostname_);
// Check the lease was updated in the database.
uint32_t valid(1);
Lease4Ptr lease;
AllocEngine::getRemaining(lease, valid);
- EXPECT_EQ(0, valid);
+ EXPECT_EQ(0U, valid);
// Unexpected state.
valid = 1;
sizeof(clientid), 100, now, 1));
lease->state_ = Lease::STATE_DECLINED;
AllocEngine::getRemaining(lease, valid);
- EXPECT_EQ(0, valid);
+ EXPECT_EQ(0U, valid);
// Infinite lifetime.
lease->state_ = Lease::STATE_DEFAULT;
lease->cltt_ = lease->current_cltt_ = now + 100;
lease->valid_lft_ = lease->current_valid_lft_ = 50;
AllocEngine::getRemaining(lease, valid);
- EXPECT_EQ(0, valid);
+ EXPECT_EQ(0U, valid);
// Already expired.
valid = 1;
lease->cltt_ = lease->current_cltt_ = now - 100;
AllocEngine::getRemaining(lease, valid);
- EXPECT_EQ(0, valid);
+ EXPECT_EQ(0U, valid);
// Valid case.
now = time(0);
lease->cltt_ = lease->current_cltt_ = now - 10;
AllocEngine::getRemaining(lease, valid);
- EXPECT_NEAR(40, valid, 1);
+ EXPECT_NEAR(40U, valid, 1);
}
// This test checks that deleteRelease handles BOOTP leases.
break;
}
const vector<uint8_t>& addr = lease->addr_.toBytes();
- ASSERT_EQ(4, addr.size());
- EXPECT_EQ(10, addr[0]);
- EXPECT_EQ(0, addr[1]);
- EXPECT_EQ(1, addr[2]);
+ ASSERT_EQ(4U, addr.size());
+ EXPECT_EQ(10U, addr[0]);
+ EXPECT_EQ(0U, addr[1]);
+ EXPECT_EQ(1U, addr[2]);
EXPECT_FALSE(found[addr[3]]);
found[addr[3]] = true;
++cnt;
// Catch unbound loop.
- ASSERT_LT(cnt, 1000);
+ ASSERT_LT(cnt, 1000U);
}
- EXPECT_EQ(256, cnt);
+ EXPECT_EQ(256U, cnt);
EXPECT_EQ(found, vector<bool>(256, true));
}
break;
}
const vector<uint8_t>& addr = lease->addr_.toBytes();
- ASSERT_EQ(4, addr.size());
- EXPECT_EQ(192, addr[0]);
- EXPECT_EQ(0, addr[1]);
- EXPECT_EQ(2, addr[2]);
+ ASSERT_EQ(4U, addr.size());
+ EXPECT_EQ(192U, addr[0]);
+ EXPECT_EQ(0U, addr[1]);
+ EXPECT_EQ(2U, addr[2]);
EXPECT_FALSE(found[addr[3]]);
found[addr[3]] = true;
++cnt;
// Catch unbound loop.
- ASSERT_LT(cnt, 1000);
+ ASSERT_LT(cnt, 1000U);
}
- EXPECT_EQ(256, cnt);
+ EXPECT_EQ(256U, cnt);
EXPECT_EQ(found, vector<bool>(256, true));
}
break;
}
const vector<uint8_t>& addr = lease->addr_.toBytes();
- ASSERT_EQ(4, addr.size());
- EXPECT_EQ(10, addr[0]);
- EXPECT_EQ(0, addr[1]);
- EXPECT_EQ(1, addr[2]);
+ ASSERT_EQ(4U, addr.size());
+ EXPECT_EQ(10U, addr[0]);
+ EXPECT_EQ(0U, addr[1]);
+ EXPECT_EQ(1U, addr[2]);
EXPECT_FALSE(found[addr[3]]);
found[addr[3]] = true;
++cnt;
// Catch unbound loop.
- ASSERT_LT(cnt, 1000);
+ ASSERT_LT(cnt, 1000U);
}
- EXPECT_EQ(254, cnt);
+ EXPECT_EQ(254U, cnt);
vector<bool> expected(256, true);
expected[0] = false;
expected[255] = false;
break;
}
const vector<uint8_t>& addr = lease->addr_.toBytes();
- ASSERT_EQ(4, addr.size());
- EXPECT_EQ(192, addr[0]);
- EXPECT_EQ(0, addr[1]);
- EXPECT_EQ(2, addr[2]);
+ ASSERT_EQ(4U, addr.size());
+ EXPECT_EQ(192U, addr[0]);
+ EXPECT_EQ(0U, addr[1]);
+ EXPECT_EQ(2U, addr[2]);
EXPECT_FALSE(found[addr[3]]);
found[addr[3]] = true;
++cnt;
// Catch unbound loop.
- ASSERT_LT(cnt, 1000);
+ ASSERT_LT(cnt, 1000U);
}
- EXPECT_EQ(254, cnt);
+ EXPECT_EQ(254U, cnt);
vector<bool> expected(256, true);
expected[0] = false;
expected[255] = false;
break;
}
const vector<uint8_t>& addr = lease->addr_.toBytes();
- ASSERT_EQ(4, addr.size());
- EXPECT_EQ(192, addr[0]);
- EXPECT_EQ(0, addr[1]);
- EXPECT_EQ(2, addr[2]);
- ASSERT_GT(128, addr[3]);
+ ASSERT_EQ(4U, addr.size());
+ EXPECT_EQ(192U, addr[0]);
+ EXPECT_EQ(0U, addr[1]);
+ EXPECT_EQ(2U, addr[2]);
+ ASSERT_GT(128U, addr[3]);
EXPECT_FALSE(found[addr[3]]);
found[addr[3]] = true;
++cnt;
// Catch unbound loop.
- ASSERT_LT(cnt, 1000);
+ ASSERT_LT(cnt, 1000U);
}
- EXPECT_EQ(128, cnt);
+ EXPECT_EQ(128U, cnt);
EXPECT_EQ(found, vector<bool>(128, true));
}
break;
}
const vector<uint8_t>& addr = lease->addr_.toBytes();
- ASSERT_EQ(4, addr.size());
- EXPECT_EQ(192, addr[0]);
- EXPECT_EQ(0, addr[1]);
- EXPECT_EQ(2, addr[2]);
- ASSERT_LE(128, addr[3]);
+ ASSERT_EQ(4U, addr.size());
+ EXPECT_EQ(192U, addr[0]);
+ EXPECT_EQ(0U, addr[1]);
+ EXPECT_EQ(2U, addr[2]);
+ ASSERT_LE(128U, addr[3]);
EXPECT_FALSE(found[addr[3] - 128]);
found[addr[3] - 128] = true;
++cnt;
// Catch unbound loop.
- ASSERT_LT(cnt, 1000);
+ ASSERT_LT(cnt, 1000U);
}
- EXPECT_EQ(128, cnt);
+ EXPECT_EQ(128U, cnt);
EXPECT_EQ(found, vector<bool>(128, true));
}
// Lease was assigned 5 seconds ago, its valid lifetime is 300, its
// remaining lifetime is still larger than offer_lft.
ASSERT_FALSE(lease->expired());
- ASSERT_EQ(300, lease->valid_lft_);
+ ASSERT_EQ(300U, lease->valid_lft_);
ASSERT_TRUE(LeaseMgrFactory::instance().addLease(lease));
// CASE 1: Asking for any address
// Check that we got that single lease
ASSERT_TRUE(lease);
EXPECT_EQ(addr, lease->addr_);
- EXPECT_EQ(300, lease->valid_lft_);
+ EXPECT_EQ(300U, lease->valid_lft_);
// We are reusing the existing lease, the old instance should be
// returned. The returned instance should be the same as the original
ctx.currentIA().addHint(IOAddress("3000:1::"), 64);
ctx.currentIA().addHint(IOAddress("3001:2::"), 64, 100, 200);
- ASSERT_EQ(3, ctx.currentIA().hints_.size());
+ ASSERT_EQ(3U, ctx.currentIA().hints_.size());
EXPECT_EQ("2001:db8:1::1", ctx.currentIA().hints_[0].getAddress().toText());
EXPECT_EQ("3000:1::", ctx.currentIA().hints_[1].getAddress().toText());
EXPECT_EQ("3001:2::", ctx.currentIA().hints_[2].getAddress().toText());
- EXPECT_EQ(100, ctx.currentIA().hints_[2].getPreferred());
- EXPECT_EQ(200, ctx.currentIA().hints_[2].getValid());
+ EXPECT_EQ(100U, ctx.currentIA().hints_[2].getPreferred());
+ EXPECT_EQ(200U, ctx.currentIA().hints_[2].getValid());
}
// Test convenience method adding allocated prefixes and addresses to
ctx.addAllocatedResource(IOAddress("2001:db8:1::1"));
ctx.addAllocatedResource(IOAddress("3000:1::"), 64);
- ASSERT_EQ(2, ctx.allocated_resources_.size());
+ ASSERT_EQ(2U, ctx.allocated_resources_.size());
EXPECT_TRUE(ctx.isAllocated(IOAddress("2001:db8:1::1")));
EXPECT_TRUE(ctx.isAllocated(IOAddress("3000:1::"), 64));
}
EXPECT_EQ(addr, lease->addr_);
// Check lifetimes: defaults are expected.
- EXPECT_EQ(300, lease->preferred_lft_);
- EXPECT_EQ(400, lease->valid_lft_);
+ EXPECT_EQ(300U, lease->preferred_lft_);
+ EXPECT_EQ(400U, lease->valid_lft_);
}
// This test checks if an expired lease can be reused using specified lifetimes.
EXPECT_EQ(addr, lease->addr_);
// Check lifetimes: specified values are expected.
- EXPECT_EQ(299, lease->preferred_lft_);
- EXPECT_EQ(401, lease->valid_lft_);
+ EXPECT_EQ(299U, lease->preferred_lft_);
+ EXPECT_EQ(401U, lease->valid_lft_);
}
// This test checks if an expired lease can be reused using min lifetimes.
EXPECT_EQ(addr, lease->addr_);
// Check lifetimes: min values are expected.
- EXPECT_EQ(200, lease->preferred_lft_);
- EXPECT_EQ(300, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->preferred_lft_);
+ EXPECT_EQ(300U, lease->valid_lft_);
}
// This test checks if an expired lease can be reused using max lifetimes.
EXPECT_EQ(addr, lease->addr_);
// Check lifetimes: max values are expected.
- EXPECT_EQ(400, lease->preferred_lft_);
- EXPECT_EQ(500, lease->valid_lft_);
+ EXPECT_EQ(400U, lease->preferred_lft_);
+ EXPECT_EQ(500U, lease->valid_lft_);
}
// This test checks if an expired lease can be reused using class lifetimes.
EXPECT_EQ(addr, lease->addr_);
// Check lifetimes: specified values are expected.
- EXPECT_EQ(200, lease->preferred_lft_);
- EXPECT_EQ(700, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->preferred_lft_);
+ EXPECT_EQ(700U, lease->valid_lft_);
}
// This test checks an expired registered lease can't be reused in SOLICT.
// Client should receive a lease.
Lease6Collection renewed = renewTest(engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease_cltt)
Lease6Collection renewed = renewTest(engine, pool_, hints, IN_SUBNET, IN_POOL);
for (auto const& l : renewed) {
// Not registered.
- EXPECT_EQ(0, l->state_);
+ EXPECT_EQ(0U, l->state_);
// Another address.
EXPECT_NE(addr, l->addr_);
}
// Client should receive a lease.
Lease6Collection renewed = renewTest(engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease_cltt)
<< "Lease lifetime was not extended, but it should";
// Checks that default values are used for lifetimes.
- EXPECT_EQ(300, renewed[0]->preferred_lft_);
- EXPECT_EQ(400, renewed[0]->valid_lft_);
+ EXPECT_EQ(300U, renewed[0]->preferred_lft_);
+ EXPECT_EQ(400U, renewed[0]->valid_lft_);
}
// Checks that a renewed lease uses specified lifetimes.
// Client should receive a lease.
Lease6Collection renewed = renewTest(engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease_cltt)
<< "Lease lifetime was not extended, but it should";
// Checks that specified values are used for lifetimes.
- EXPECT_EQ(301, renewed[0]->preferred_lft_);
- EXPECT_EQ(399, renewed[0]->valid_lft_);
+ EXPECT_EQ(301U, renewed[0]->preferred_lft_);
+ EXPECT_EQ(399U, renewed[0]->valid_lft_);
}
// Checks that a renewed lease uses min lifetimes.
// Client should receive a lease.
Lease6Collection renewed = renewTest(engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease_cltt)
<< "Lease lifetime was not extended, but it should";
// Checks that min values are used for lifetimes.
- EXPECT_EQ(200, renewed[0]->preferred_lft_);
- EXPECT_EQ(300, renewed[0]->valid_lft_);
+ EXPECT_EQ(200U, renewed[0]->preferred_lft_);
+ EXPECT_EQ(300U, renewed[0]->valid_lft_);
}
// Checks that a renewed lease uses max lifetimes.
// Client should receive a lease.
Lease6Collection renewed = renewTest(engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease_cltt)
<< "Lease lifetime was not extended, but it should";
// Checks that max values are used for lifetimes.
- EXPECT_EQ(400, renewed[0]->preferred_lft_);
- EXPECT_EQ(500, renewed[0]->valid_lft_);
+ EXPECT_EQ(400U, renewed[0]->preferred_lft_);
+ EXPECT_EQ(500U, renewed[0]->valid_lft_);
}
// Verifies renewal uses class life times via getLifetimes() in invoked by
findReservation(engine, ctx);
Lease6Collection renewed = engine.renewLeases6(ctx);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease_cltt)
<< "Lease lifetime was not extended, but it should";
// Verify life times came from the class. Preferred should get adjusted.
- EXPECT_EQ(renewed[0]->preferred_lft_, 437);
- EXPECT_EQ(renewed[0]->valid_lft_, 700);
+ EXPECT_EQ(renewed[0]->preferred_lft_, 437U);
+ EXPECT_EQ(renewed[0]->valid_lft_, 700U);
}
// Checks if a released lease is renewed and that its state is set to default.
// Client should renew the lease.
Lease6Collection renewed = renewTest(engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease_cltt)
// Client should receive a lease.
Lease6Collection renewed = renewTest(engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease_cltt)
findReservation(engine, ctx);
Lease6Collection leases = engine.allocateLeases6(ctx);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_EQ("2001:db8:1::12", leases[0]->addr_.toText());
}
Lease6Collection leases;
leases = allocateTest(engine, pool_, IOAddress("::"), false, true);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
// Assigned count should be one.
EXPECT_TRUE(testStatistics("assigned-nas", 1, subnet_->getID()));
hints.push_back(AllocEngine::Resource(leases[0]->addr_, 128));
Lease6Collection renewed = renewTest(engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// Check that the lease was indeed renewed and hasn't changed
// (i.e. the same address, preferred and valid lifetimes)
Lease6Collection leases;
leases = allocateTest(engine, pool_, IOAddress("::"), false, true);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
ASSERT_EQ("2001:db8:1::1c", leases[0]->addr_.toText());
// Assigned count should be one.
hints.push_back(AllocEngine::Resource(leases[0]->addr_, 128));
Lease6Collection renewed = renewTest(engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
ASSERT_EQ("2001:db8:1::1c", leases[0]->addr_.toText());
// Assigned count should still be one.
Lease6Collection leases1;
findReservation(engine, ctx1);
EXPECT_NO_THROW(leases1 = engine.allocateLeases6(ctx1));
- ASSERT_EQ(1, leases1.size());
+ ASSERT_EQ(1U, leases1.size());
EXPECT_EQ("2001:db8:1::babe", leases1[0]->addr_.toText());
// Double check that repeating the same duid/type/iaid will end up with
Lease6Collection leases2;
findReservation(engine, ctx2);
EXPECT_NO_THROW(leases2 = engine.allocateLeases6(ctx2));
- EXPECT_EQ(1, leases2.size());
+ EXPECT_EQ(1U, leases2.size());
EXPECT_EQ("2001:db8:1::babe", leases2[0]->addr_.toText());
// Ok, now the tricky part. Request allocation for the same duid and type, but
Lease6Collection leases3;
findReservation(engine, ctx3);
EXPECT_NO_THROW(leases3 = engine.allocateLeases6(ctx3));
- ASSERT_EQ(1, leases3.size());
+ ASSERT_EQ(1U, leases3.size());
EXPECT_EQ("2001:db8:1::cafe", leases3[0]->addr_.toText());
}
Lease6Collection leases1;
findReservation(engine, ctx1);
EXPECT_NO_THROW(leases1 = engine.allocateLeases6(ctx1));
- ASSERT_EQ(1, leases1.size());
+ ASSERT_EQ(1U, leases1.size());
EXPECT_EQ("2001:db8:1::babe", leases1[0]->addr_.toText());
// Double check that repeating the same duid/type/iaid will end up with
Lease6Collection leases2;
findReservation(engine, ctx2);
EXPECT_NO_THROW(leases2 = engine.allocateLeases6(ctx2));
- EXPECT_EQ(1, leases2.size());
+ EXPECT_EQ(1U, leases2.size());
EXPECT_EQ("2001:db8:1::babe", leases2[0]->addr_.toText());
// Ok, now the tricky part. Request allocation for the same duid and type, but
Lease6Collection leases3;
findReservation(engine, ctx3);
EXPECT_NO_THROW(leases3 = engine.allocateLeases6(ctx3));
- ASSERT_EQ(1, leases3.size());
+ ASSERT_EQ(1U, leases3.size());
EXPECT_EQ("2001:db8:1::cafe", leases3[0]->addr_.toText());
}
Lease6Collection leases;
leases = allocateTest(engine, pool_, IOAddress("::"), false, true);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
ASSERT_NE("2001:db8:1::1c", leases[0]->addr_.toText());
// This is what the client will send in his renew message.
createHost6(true, IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::1c"), 128);
Lease6Collection renewed = renewTest(engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
ASSERT_EQ("2001:db8:1::1c", renewed[0]->addr_.toText());
}
Lease6Collection leases;
leases = allocateTest(engine, pool_, IOAddress("::"), false, true);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
// This is what the client will send in his renew message.
AllocEngine::HintContainer hints;
CfgMgr::instance().commit();
Lease6Collection renewed = renewTest(engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// Check that we no longer have the reserved address.
ASSERT_NE(leases[0]->addr_.toText(), renewed[0]->addr_.toText());
// We should have got exactly one lease.
Lease6Collection leases = allocateTest(engine, pool, IOAddress("::"),
false, true);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
}
// This test checks that the allocation engine can pick a pool which has smaller
// Even though the hint is from the first pool, the second pool is preferred.
Lease6Collection leases = allocateTest(engine, pool2, IOAddress("2001:db8:1:2::"),
false, true, 92);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
}
// This test checks that the allocation engine can pick a pool which has smaller
// We should have got exactly one lease.
Lease6Collection leases = allocateTest(engine, pool, IOAddress("2001:db8:1:3::"),
false, true, 92);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
}
// This test checks that the allocation engine can pick a pool which has exact
// Even though the hint is from the first pool, the second pool is preferred.
Lease6Collection leases = allocateTest(engine, pool2, IOAddress("2001:db8:1:2::"),
false, true, 80);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
}
// This test checks that the allocation engine can pick a pool which has exact
// We should have got exactly one lease.
Lease6Collection leases = allocateTest(engine, pool, IOAddress("2001:db8:1:3::"),
false, true, 80);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
}
// This test checks that the allocation engine can pick a pool which has greater
// the second pool is preferred.
Lease6Collection leases = allocateTest(engine, pool2, IOAddress("2001:db8:1:3::"),
false, true, 64);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
}
// This test checks that the allocation engine can pick a pool which has greater
// We should have got exactly one lease.
Lease6Collection leases = allocateTest(engine, pool, IOAddress("2001:db8:1:3::"),
false, true, 64);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
}
// This test checks that the allocation engine can delegate addresses
// We should have got exactly one lease.
Lease6Collection leases = allocateTest(engine, pool, IOAddress("::"),
false, true);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
}
// This test verifies that it is possible to override the number of allocation
// be successful.
AllocEngine engine2(6);
leases = allocateTest(engine2, pool_, IOAddress("::"), false, true);
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
}
// This test checks if an expired declined lease can be reused in SOLICIT (fake allocation)
EXPECT_EQ("2001:db8:1::1", lease2->addr_.toText());
// The previous lease should have been removed.
- ASSERT_EQ(1, ctx.currentIA().old_leases_.size());
+ ASSERT_EQ(1U, ctx.currentIA().old_leases_.size());
EXPECT_EQ("2001:db8:2::1", ctx.currentIA().old_leases_[0]->addr_.toText());
}
// Client should receive a lease.
Lease6Collection renewed = renewTest(*engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
Lease6Ptr renewed_lease = renewed[0];
EXPECT_EQ("2001:db8:1::10", renewed_lease->addr_.toText());
// Client should receive a lease.
Lease6Collection renewed = renewTest(*engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
ASSERT_GT(renewed[0]->cltt_, lease->cltt_)
// Client should receive a lease.
Lease6Collection renewed = renewTest(*engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease->cltt_)
// Client should receive a lease.
Lease6Collection renewed = renewTest(*engine, pool_, hints, IN_SUBNET, !IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease->cltt_)
// Client should receive a lease.
Lease6Collection renewed = renewTest(*engine, dummy_pool, hints, !IN_SUBNET, !IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease->cltt_)
// Client should receive a lease.
Lease6Collection renewed = renewTest(*engine, dummy_pool, hints, !IN_SUBNET, !IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease->cltt_)
// Client should receive a lease.
Lease6Collection renewed = renewTest(*engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease->cltt_)
// Client should receive a lease.
Lease6Collection renewed = renewTest(*engine, dummy_pool, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease->cltt_)
// Client should receive a lease.
Lease6Collection renewed = renewTest(*engine, dummy_pool, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease->cltt_)
// Client should receive a lease.
Lease6Collection renewed = renewTest(*engine, pool_, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease->cltt_)
// Client should receive a lease.
Lease6Collection renewed = renewTest(*engine, dummy_pool, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease->cltt_)
// Client should receive a lease.
Lease6Collection renewed = renewTest(*engine, dummy_pool, hints, IN_SUBNET, IN_POOL);
- ASSERT_EQ(1, renewed.size());
+ ASSERT_EQ(1U, renewed.size());
// And the lease lifetime should be extended.
EXPECT_GT(renewed[0]->cltt_, lease->cltt_)
EXPECT_NO_THROW(lease = expectOneLease(engine->allocateLeases6(ctx)));
ASSERT_TRUE(lease);
EXPECT_EQ(addr, lease->addr_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(128U, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was not updated in the database.
Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
EXPECT_NO_THROW(lease = expectOneLease(engine->allocateLeases6(ctx)));
ASSERT_TRUE(lease);
EXPECT_EQ(addr, lease->addr_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(128U, lease->prefixlen_);
// The lease was reused.
time_t age = lease->cltt_ - now;
EXPECT_GE(age, 100);
EXPECT_LE(age, 110);
- EXPECT_EQ(400 - age, lease->reuseable_valid_lft_);
- EXPECT_EQ(300 - age, lease->reuseable_preferred_lft_);
+ EXPECT_EQ(400U - age, lease->reuseable_valid_lft_);
+ EXPECT_EQ(300U - age, lease->reuseable_preferred_lft_);
// Check other lease parameters.
EXPECT_TRUE(*lease->duid_ == *duid_);
time_t age = lease->cltt_ - now;
EXPECT_GE(age, 100);
EXPECT_LE(age, 110);
- EXPECT_EQ(400 - age, lease->reuseable_valid_lft_);
- EXPECT_EQ(300 - age, lease->reuseable_preferred_lft_);
+ EXPECT_EQ(400U - age, lease->reuseable_valid_lft_);
+ EXPECT_EQ(300U - age, lease->reuseable_preferred_lft_);
// Check other lease parameters.
EXPECT_TRUE(*lease->duid_ == *duid_);
EXPECT_NO_THROW(lease = expectOneLease(engine->allocateLeases6(ctx)));
ASSERT_TRUE(lease);
EXPECT_EQ(addr, lease->addr_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(128U, lease->prefixlen_);
// The lease was reused.
time_t age = lease->cltt_ - now;
EXPECT_GE(age, 100);
EXPECT_LE(age, 110);
- EXPECT_EQ(400 - age, lease->reuseable_valid_lft_);
- EXPECT_EQ(300 - age, lease->reuseable_preferred_lft_);
+ EXPECT_EQ(400U - age, lease->reuseable_valid_lft_);
+ EXPECT_EQ(300U - age, lease->reuseable_preferred_lft_);
// Check other lease parameters.
EXPECT_TRUE(*lease->duid_ == *duid_);
time_t age = lease->cltt_ - now;
EXPECT_GE(age, 100);
EXPECT_LE(age, 110);
- EXPECT_EQ(400 - age, lease->reuseable_valid_lft_);
- EXPECT_EQ(300 - age, lease->reuseable_preferred_lft_);
+ EXPECT_EQ(400U - age, lease->reuseable_valid_lft_);
+ EXPECT_EQ(300U - age, lease->reuseable_preferred_lft_);
// Check other lease parameters.
EXPECT_TRUE(*lease->duid_ == *duid_);
EXPECT_NO_THROW(lease = expectOneLease(engine->allocateLeases6(ctx)));
ASSERT_TRUE(lease);
EXPECT_EQ(addr, lease->addr_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(128U, lease->prefixlen_);
// The lease was reused.
time_t age = lease->cltt_ - now;
EXPECT_GE(age, 100);
EXPECT_LE(age, 110);
- EXPECT_EQ(400 - age, lease->reuseable_valid_lft_);
- EXPECT_EQ(300 - age, lease->reuseable_preferred_lft_);
+ EXPECT_EQ(400U - age, lease->reuseable_valid_lft_);
+ EXPECT_EQ(300U - age, lease->reuseable_preferred_lft_);
// Check other lease parameters.
EXPECT_TRUE(*lease->duid_ == *duid_);
time_t age = lease->cltt_ - now;
EXPECT_GE(age, 100);
EXPECT_LE(age, 110);
- EXPECT_EQ(400 - age, lease->reuseable_valid_lft_);
- EXPECT_EQ(300 - age, lease->reuseable_preferred_lft_);
+ EXPECT_EQ(400U - age, lease->reuseable_valid_lft_);
+ EXPECT_EQ(300U - age, lease->reuseable_preferred_lft_);
// Check other lease parameters.
EXPECT_TRUE(*lease->duid_ == *duid_);
EXPECT_NO_THROW(lease = expectOneLease(engine->allocateLeases6(ctx)));
ASSERT_TRUE(lease);
EXPECT_EQ(addr, lease->addr_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(128U, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was updated in the database.
Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
EXPECT_EQ(prefixlen, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was updated in the database.
Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
EXPECT_NO_THROW(lease = expectOneLease(engine->allocateLeases6(ctx)));
ASSERT_TRUE(lease);
EXPECT_EQ(addr, lease->addr_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(128U, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was updated in the database.
Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
EXPECT_EQ(prefixlen, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was updated in the database.
Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
EXPECT_NO_THROW(lease = expectOneLease(engine->renewLeases6(ctx)));
ASSERT_TRUE(lease);
EXPECT_EQ(addr, lease->addr_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(128U, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was updated in the database.
Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
EXPECT_EQ(prefixlen, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was updated in the database.
Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
EXPECT_NO_THROW(lease = expectOneLease(engine->allocateLeases6(ctx)));
ASSERT_TRUE(lease);
EXPECT_EQ(addr, lease->addr_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(128U, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was updated in the database.
Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
EXPECT_EQ(prefixlen, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was updated in the database.
Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
EXPECT_NO_THROW(lease = expectOneLease(engine->allocateLeases6(ctx)));
ASSERT_TRUE(lease);
EXPECT_EQ(addr, lease->addr_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(128U, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was updated in the database.
Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
EXPECT_EQ(prefixlen, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
// Check the lease was updated in the database.
Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
EXPECT_NO_THROW(lease = expectOneLease(engine->allocateLeases6(ctx)));
ASSERT_TRUE(lease);
EXPECT_EQ(addr, lease->addr_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(128U, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
EXPECT_EQ("bar", lease->hostname_);
// Check the lease was updated in the database.
EXPECT_EQ(prefixlen, lease->prefixlen_);
// The lease was not reused.
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
EXPECT_EQ("bar", lease->hostname_);
// Check the lease was updated in the database.
uint32_t preferred(1);
Lease6Ptr lease;
AllocEngine::getRemaining(lease, preferred, valid);
- EXPECT_EQ(0, valid);
- EXPECT_EQ(0, preferred);
+ EXPECT_EQ(0U, valid);
+ EXPECT_EQ(0U, preferred);
// Unexpected state.
valid = 1;
iaid, 30, 50, 1));
lease->state_ = Lease::STATE_DECLINED;
AllocEngine::getRemaining(lease, preferred, valid);
- EXPECT_EQ(0, valid);
- EXPECT_EQ(0, preferred);
+ EXPECT_EQ(0U, valid);
+ EXPECT_EQ(0U, preferred);
// Time going backward.
valid = 1;
lease->cltt_ = lease->current_cltt_ = now + 100;
lease->valid_lft_ = lease->current_valid_lft_ = 50;
AllocEngine::getRemaining(lease, preferred, valid);
- EXPECT_EQ(0, valid);
- EXPECT_EQ(0, preferred);
+ EXPECT_EQ(0U, valid);
+ EXPECT_EQ(0U, preferred);
// Already expired.
valid = 1;
preferred = 1;
lease->cltt_ = lease->current_cltt_ = now - 100;
AllocEngine::getRemaining(lease, preferred, valid);
- EXPECT_EQ(0, valid);
- EXPECT_EQ(0, preferred);
+ EXPECT_EQ(0U, valid);
+ EXPECT_EQ(0U, preferred);
// Valid case.
now = time(0);
lease->cltt_ = lease->current_cltt_ = now - 10;
AllocEngine::getRemaining(lease, preferred, valid);
- EXPECT_NEAR(40, valid, 1);
- EXPECT_NEAR(20, preferred, 1);
+ EXPECT_NEAR(40U, valid, 1);
+ EXPECT_NEAR(20U, preferred, 1);
// No longer preferred.
now = time(0);
lease->cltt_ = lease->current_cltt_ = now - 40;
AllocEngine::getRemaining(lease, preferred, valid);
- EXPECT_NEAR(10, valid, 1);
- EXPECT_EQ(0, preferred);
+ EXPECT_NEAR(10U, valid, 1);
+ EXPECT_EQ(0U, preferred);
}
TEST_F(AllocEngine6Test, useReleasedReservedLease) {
// Client should receive a lease.
Lease6Ptr new_lease = simpleAlloc6Test(pool_, IOAddress("::"), false);
ASSERT_TRUE(new_lease);
- EXPECT_EQ(new_lease->valid_lft_, 400);
+ EXPECT_EQ(new_lease->valid_lft_, 400U);
}
TEST_F(AllocEngine6Test, useReclaimedReservedLease) {
// Client should receive a lease.
Lease6Ptr new_lease = simpleAlloc6Test(pool_, IOAddress("::"), false);
ASSERT_TRUE(new_lease);
- EXPECT_EQ(new_lease->valid_lft_, 400);
+ EXPECT_EQ(new_lease->valid_lft_, 400U);
}
} // namespace test
EXPECT_FALSE(lease);
// Check no retry was attempted
- EXPECT_EQ(1, callback_skip_);
+ EXPECT_EQ(1U, callback_skip_);
// Check if the callout handle state was reset after the callout.
checkCalloutHandleReset(ctx.query_);
EXPECT_FALSE(lease);
// Check that retry was attempted by doing dynamic allocation.
- EXPECT_EQ(2, callback_skip_);
+ EXPECT_EQ(2U, callback_skip_);
// Check if the callout handle state was reset after the callout.
checkCalloutHandleReset(ctx.query_);
EXPECT_FALSE(lease);
// Check that retry was attempted by doing dynamic allocation.
- EXPECT_EQ(2, callback_skip_);
+ EXPECT_EQ(2U, callback_skip_);
// Check if the callout handle state was reset after the callout.
checkCalloutHandleReset(ctx.query_);
EXPECT_FALSE(lease);
// Check no retry was attempted
- EXPECT_EQ(1, callback_skip_);
+ EXPECT_EQ(1U, callback_skip_);
// Check if the callout handle state was reset after the callout.
checkCalloutHandleReset(ctx.query_);
EXPECT_FALSE(lease);
// Check no retry was attempted
- EXPECT_EQ(1, callback_skip_);
+ EXPECT_EQ(1U, callback_skip_);
// Check if the callout handle state was reset after the callout.
checkCalloutHandleReset(ctx.query_);
EXPECT_FALSE(lease);
// Check no retry was attempted
- EXPECT_EQ(1, callback_skip_);
+ EXPECT_EQ(1U, callback_skip_);
// Check if the callout handle state was reset after the callout.
checkCalloutHandleReset(ctx.query_);
(getTimestamp("dhcp4_client_class") > lb_modification_time)) {
ASSERT_TRUE(found_class);
ASSERT_TRUE(found_class->getMatchExpr());
- EXPECT_GT(found_class->getMatchExpr()->size(), 0);
+ EXPECT_GT(found_class->getMatchExpr()->size(), 0U);
EXPECT_EQ("first-class", found_class->getName());
// Check for the standard class option, make sure it has been "created".
(getTimestamp("dhcp6_client_class") > lb_modification_time)) {
ASSERT_TRUE(found_class);
ASSERT_TRUE(found_class->getMatchExpr());
- EXPECT_GT(found_class->getMatchExpr()->size(), 0);
+ EXPECT_GT(found_class->getMatchExpr()->size(), 0U);
EXPECT_EQ("first-class", found_class->getName());
// Check for class option, make sure it has been "created".
// Check access strings
std::list<std::string> hal = cfg.getHostDbAccessStringList();
- ASSERT_EQ(3, hal.size());
+ ASSERT_EQ(3U, hal.size());
std::list<std::string>::const_iterator it = hal.cbegin();
ASSERT_NE(hal.cend(), it);
EXPECT_EQ("type=mysql", *it);
expected = "[ { \"type\": \"foo\" }, { \"type\": \"bar\" } ]";
runToElementTest<CfgHostDbAccess>(expected, CfgHostDbAccess(cfg1));
hal = cfg1.getHostDbAccessStringList();
- ASSERT_EQ(2, hal.size());
+ ASSERT_EQ(2U, hal.size());
EXPECT_EQ("type=foo", hal.front());
EXPECT_EQ("type=bar", hal.back());
}
<< "expected empty identifier, found: "
<< toString(cfg_duid.getIdentifier());
- EXPECT_EQ(0, cfg_duid.getHType());
- EXPECT_EQ(0, cfg_duid.getTime());
- EXPECT_EQ(0, cfg_duid.getEnterpriseId());
+ EXPECT_EQ(0U, cfg_duid.getHType());
+ EXPECT_EQ(0U, cfg_duid.getTime());
+ EXPECT_EQ(0U, cfg_duid.getEnterpriseId());
EXPECT_TRUE(cfg_duid.persist());
EXPECT_FALSE(cfg_duid.getContext());
// Check that values have been set correctly.
EXPECT_EQ(DUID::DUID_EN, cfg_duid.getType());
EXPECT_EQ("ABCDEF", toString(cfg_duid.getIdentifier()));
- EXPECT_EQ(100, cfg_duid.getHType());
- EXPECT_EQ(32100, cfg_duid.getTime());
- EXPECT_EQ(10, cfg_duid.getEnterpriseId());
+ EXPECT_EQ(100U, cfg_duid.getHType());
+ EXPECT_EQ(32100U, cfg_duid.getTime());
+ EXPECT_EQ(10U, cfg_duid.getEnterpriseId());
EXPECT_FALSE(cfg_duid.persist());
ASSERT_TRUE(cfg_duid.getContext());
EXPECT_EQ(user_context, cfg_duid.getContext()->str());
// Setting the value to 0 should pass.
ASSERT_NO_THROW(modifier(&cfg, 0));
- EXPECT_EQ(0, accessor(&cfg));
+ EXPECT_EQ(0U, accessor(&cfg));
}
/// @brief Tests that modifier and the accessor returning uint16_t value
// Make sure we had more than one call to the reclamation routine.
ASSERT_GT(stub_->reclaim_calls_count_, 1);
// Make sure it was called with appropriate arguments.
- EXPECT_EQ(1000, stub_->reclaim_params_.max_leases);
- EXPECT_EQ(1500, stub_->reclaim_params_.timeout);
+ EXPECT_EQ(1000U, stub_->reclaim_params_.max_leases);
+ EXPECT_EQ(1500U, stub_->reclaim_params_.timeout);
EXPECT_FALSE(stub_->reclaim_params_.remove_lease);
- EXPECT_EQ(13, stub_->reclaim_params_.max_unwarned_cycles);
+ EXPECT_EQ(13U, stub_->reclaim_params_.max_unwarned_cycles);
// Make sure we had more than one call to the routine which flushes
// expired reclaimed leases.
ASSERT_GT(stub_->delete_calls_count_, 1);
// Make sure that the argument was correct.
- EXPECT_EQ(1800, stub_->secs_param_);
+ EXPECT_EQ(1800U, stub_->secs_param_);
}
// This test verifies that if the value of "flush-reclaimed-timer-wait-time"
// Try to retrieve each added reservation using HW address and DUID. Do it
// in the reverse order to make sure that the order doesn't matter.
- for (int i = 24; i >= 0; --i) {
+ for (unsigned i = 24; i < 25; --i) {
// Get host identified by HW address.
HostCollection hosts = cfg.getAll(Host::IDENT_HWADDR,
&hwaddrs_[i]->hwaddr_[0],
hwaddrs_[i]->hwaddr_.size());
- ASSERT_EQ(1, hosts.size());
- EXPECT_EQ(i % 10 + 1, hosts[0]->getIPv4SubnetID());
+ ASSERT_EQ(1U, hosts.size());
+ EXPECT_EQ(i % 10 + 1U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ(addressesa_[i].toText(),
hosts[0]->getIPv4Reservation().toText());
hosts = cfg.getAll(Host::IDENT_DUID,
&duids_[i]->getDuid()[0],
duids_[i]->getDuid().size());
- ASSERT_EQ(1, hosts.size());
- EXPECT_EQ(i % 5 + 1, hosts[0]->getIPv4SubnetID());
+ ASSERT_EQ(1U, hosts.size());
+ EXPECT_EQ(i % 5 + 1U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ(addressesb_[i].toText(),
hosts[0]->getIPv4Reservation().toText());
}
// Make sure that the reservations do not exist for the hardware addresses
// and DUIDs from the range of 25 to 49.
- for (int i = 49; i >= 25; --i) {
+ for (unsigned i = 49; i >= 25; --i) {
EXPECT_TRUE(cfg.getAll(Host::IDENT_HWADDR, &hwaddrs_[i]->hwaddr_[0],
hwaddrs_[i]->hwaddr_.size()).empty());
EXPECT_TRUE(cfg.getAll(Host::IDENT_DUID, &duids_[i]->getDuid()[0],
HostCollection hosts = cfg.getAll(Host::IDENT_HWADDR,
&hwaddrs_[i]->hwaddr_[0],
hwaddrs_[i]->hwaddr_.size());
- ASSERT_EQ(2, hosts.size());
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
+ ASSERT_EQ(2U, hosts.size());
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ(addressesa_[i], hosts[0]->getIPv4Reservation().toText());
- EXPECT_EQ(2, hosts[1]->getIPv4SubnetID());
+ EXPECT_EQ(2U, hosts[1]->getIPv4SubnetID());
EXPECT_EQ(addressesb_[i], hosts[1]->getIPv4Reservation().toText());
// The HW address is non-null but there are no reservations
// Check that other subnets are empty.
HostCollection hosts = cfg.getAll4(SubnetID(100));
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
// Try to retrieve all added reservations.
hosts = cfg.getAll4(SubnetID(1));
- ASSERT_EQ(25, hosts.size());
+ ASSERT_EQ(25U, hosts.size());
for (unsigned i = 0; i < 25; ++i) {
- EXPECT_EQ(1, hosts[i]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[i]->getIPv4SubnetID());
EXPECT_EQ(addressesa_[i].toText(),
hosts[i]->getIPv4Reservation().toText());
}
// Check that other subnets are empty.
HostCollection hosts = cfg.getAll6(SubnetID(100));
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
// Try to retrieve all added reservations.
hosts = cfg.getAll6(SubnetID(1));
- ASSERT_EQ(25, hosts.size());
+ ASSERT_EQ(25U, hosts.size());
for (unsigned i = 0; i < 25; ++i) {
- EXPECT_EQ(1, hosts[i]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[i]->getIPv6SubnetID());
IPv6ResrvRange reservations =
hosts[i]->getIPv6Reservations(IPv6Resrv::TYPE_NA);
ASSERT_EQ(1, std::distance(reservations.first, reservations.second));
// Try to retrieve all added reservations with IP equals 2001:db8:1::1.
auto hosts = cfg.getAll6(IOAddress("2001:db8:1::1"));
- EXPECT_EQ(5, hosts.size());
+ EXPECT_EQ(5U, hosts.size());
for (unsigned i = 0; i < 5; ++i) {
- EXPECT_EQ(1 + 5 * i, hosts[i]->getIPv6SubnetID());
+ EXPECT_EQ(1U + 5 * i, hosts[i]->getIPv6SubnetID());
IPv6ResrvRange reservations =
hosts[i]->getIPv6Reservations(IPv6Resrv::TYPE_NA);
ASSERT_EQ(1, std::distance(reservations.first, reservations.second));
// Check that other subnets are empty.
HostCollection page = cfg.getPage4(SubnetID(100), idx, host_id, page_size);
- EXPECT_EQ(0, page.size());
+ EXPECT_EQ(0U, page.size());
// Try to retrieve all added reservations.
// Get first page.
page = cfg.getPage4(SubnetID(1), idx, host_id, page_size);
- EXPECT_EQ(10, page.size());
+ EXPECT_EQ(10U, page.size());
host_id = page[9]->getHostId();
// Get second and last pages.
page = cfg.getPage4(SubnetID(1), idx, host_id, page_size);
- EXPECT_EQ(10, page.size());
+ EXPECT_EQ(10U, page.size());
host_id = page[9]->getHostId();
page = cfg.getPage4(SubnetID(1), idx, host_id, page_size);
- EXPECT_EQ(5, page.size());
+ EXPECT_EQ(5U, page.size());
host_id = page[4]->getHostId();
// Verify we have everything.
page = cfg.getPage4(SubnetID(1), idx, host_id, page_size);
- EXPECT_EQ(0, page.size());
+ EXPECT_EQ(0U, page.size());
}
TEST_F(CfgHostsTest, getPage4) {
// Check that other subnets are empty.
HostCollection page = cfg.getPage6(SubnetID(100), idx, host_id, page_size);
- EXPECT_EQ(0, page.size());
+ EXPECT_EQ(0U, page.size());
// Try to retrieve all added reservations.
// Get first page.
page = cfg.getPage6(SubnetID(1), idx, host_id, page_size);
- EXPECT_EQ(10, page.size());
+ EXPECT_EQ(10U, page.size());
host_id = page[9]->getHostId();
// Get second and last pages.
page = cfg.getPage6(SubnetID(1), idx, host_id, page_size);
- EXPECT_EQ(10, page.size());
+ EXPECT_EQ(10U, page.size());
host_id = page[9]->getHostId();
page = cfg.getPage6(SubnetID(1), idx, host_id, page_size);
- EXPECT_EQ(5, page.size());
+ EXPECT_EQ(5U, page.size());
host_id = page[4]->getHostId();
// Verify we have everything.
page = cfg.getPage6(SubnetID(1), idx, host_id, page_size);
- EXPECT_EQ(0, page.size());
+ EXPECT_EQ(0U, page.size());
}
TEST_F(CfgHostsTest, getPage6) {
// Try to retrieve all added reservations.
// Get first page.
HostCollection page = cfg.getPage4(idx, host_id, page_size);
- EXPECT_EQ(10, page.size());
+ EXPECT_EQ(10U, page.size());
host_id = page[9]->getHostId();
// Get second and last pages.
page = cfg.getPage4(idx, host_id, page_size);
- EXPECT_EQ(10, page.size());
+ EXPECT_EQ(10U, page.size());
host_id = page[9]->getHostId();
page = cfg.getPage4(idx, host_id, page_size);
- EXPECT_EQ(5, page.size());
+ EXPECT_EQ(5U, page.size());
host_id = page[4]->getHostId();
// Verify we have everything.
page = cfg.getPage4(idx, host_id, page_size);
- EXPECT_EQ(0, page.size());
+ EXPECT_EQ(0U, page.size());
}
TEST_F(CfgHostsTest, getPage4All) {
// Try to retrieve all added reservations.
// Get first page.
HostCollection page = cfg.getPage6(idx, host_id, page_size);
- EXPECT_EQ(10, page.size());
+ EXPECT_EQ(10U, page.size());
host_id = page[9]->getHostId();
// Get second and last pages.
page = cfg.getPage6(idx, host_id, page_size);
- EXPECT_EQ(10, page.size());
+ EXPECT_EQ(10U, page.size());
host_id = page[9]->getHostId();
page = cfg.getPage6(idx, host_id, page_size);
- EXPECT_EQ(5, page.size());
+ EXPECT_EQ(5U, page.size());
host_id = page[4]->getHostId();
// Verify we have everything.
page = cfg.getPage6(idx, host_id, page_size);
- EXPECT_EQ(0, page.size());
+ EXPECT_EQ(0U, page.size());
}
TEST_F(CfgHostsTest, getPage6All) {
for (auto const& host : hosts) {
subnet_ids.insert(host->getIPv4SubnetID());
}
- ASSERT_EQ(25, subnet_ids.size());
- EXPECT_EQ(1, *subnet_ids.begin());
- EXPECT_EQ(25, *subnet_ids.rbegin());
+ ASSERT_EQ(25U, subnet_ids.size());
+ EXPECT_EQ(1U, *subnet_ids.begin());
+ EXPECT_EQ(25U, *subnet_ids.rbegin());
}
TEST_F(CfgHostsTest, getAll4ByAddress) {
HostCollection hosts_by_address = cfg.getAll4(address);
// Make sure the hosts and IP reservations were added.
ASSERT_EQ(host_count, hosts_by_subnet.size());
- ASSERT_EQ(1, hosts_by_address.size());
+ ASSERT_EQ(1U, hosts_by_address.size());
// Delete one host.
EXPECT_TRUE(cfg.del(subnet_id, address));
hosts_by_subnet = cfg.getAll4(subnet_id);
hosts_by_address = cfg.getAll4(address);
EXPECT_EQ(host_count-1, hosts_by_subnet.size());
- EXPECT_EQ(0, hosts_by_address.size());
+ EXPECT_EQ(0U, hosts_by_address.size());
}
TEST_F(CfgHostsTest, deleteForIPv4) {
auto hosts_by_subnet_and_address = cfg.getAll6(subnet_id, address);
auto hosts_by_subnet = cfg.getAll6(subnet_id);
// Make sure the hosts and IP reservations were added.
- ASSERT_EQ(1, hosts_by_subnet_and_address.size());
+ ASSERT_EQ(1U, hosts_by_subnet_and_address.size());
ASSERT_EQ(host_count, hosts_by_subnet.size());
// Delete one host.
// Check if the host is actually deleted.
hosts_by_subnet_and_address = cfg.getAll6(subnet_id, address);
hosts_by_subnet = cfg.getAll6(subnet_id);
- EXPECT_EQ(0, hosts_by_subnet_and_address.size());
- EXPECT_EQ(host_count-1, hosts_by_subnet.size());
+ EXPECT_EQ(0U, hosts_by_subnet_and_address.size());
+ EXPECT_EQ(host_count - 1, hosts_by_subnet.size());
}
TEST_F(CfgHostsTest, deleteForIPv6) {
host = cfg.get4(subnet_id, Host::IdentifierType::IDENT_DUID,
&duids_[host_id]->getDuid()[0],
duids_[host_id]->getDuid().size());
- EXPECT_EQ((host_count / 2)-1, hosts_by_subnet.size());
+ EXPECT_EQ((host_count / 2) - 1, hosts_by_subnet.size());
EXPECT_EQ(host_count / 2, hosts_by_address.size());
EXPECT_FALSE(host);
}
host = cfg.get6(subnet_id, Host::IdentifierType::IDENT_DUID,
&duids_[host_id]->getDuid()[0],
duids_[host_id]->getDuid().size());
- EXPECT_EQ((host_count / 2)-1, hosts_by_subnet.size());
+ EXPECT_EQ((host_count / 2) - 1, hosts_by_subnet.size());
EXPECT_EQ(host_count / 2, hosts_by_address.size());
EXPECT_FALSE(host);
}
subnet_ids.insert(host->getIPv4SubnetID());
}
// Make sure there are two unique subnets: 1 and 2.
- ASSERT_EQ(2, subnet_ids.size());
- EXPECT_EQ(1, *subnet_ids.begin());
- EXPECT_EQ(2, *subnet_ids.rbegin());
+ ASSERT_EQ(2U, subnet_ids.size());
+ EXPECT_EQ(1U, *subnet_ids.begin());
+ EXPECT_EQ(2U, *subnet_ids.rbegin());
// Delete all hosts for subnet id 2. There should be 12 of them.
- EXPECT_EQ(12, cfg.delAll4(SubnetID(2)));
+ EXPECT_EQ(12U, cfg.delAll4(SubnetID(2)));
// Gather the host counts again.
subnet_ids.clear();
}
// We should only have hosts for one subnet and it should be the subnet
// with ID of 1.
- ASSERT_EQ(1, subnet_ids.size());
- EXPECT_EQ(1, *subnet_ids.begin());
+ ASSERT_EQ(1U, subnet_ids.size());
+ EXPECT_EQ(1U, *subnet_ids.begin());
}
TEST_F(CfgHostsTest, deleteAll4) {
ConstElementPtr unparsed = list.get(SubnetID(1 + i));
ASSERT_TRUE(unparsed);
ASSERT_EQ(Element::list, unparsed->getType());
- EXPECT_EQ(2, unparsed->size());
- ASSERT_NE(0, unparsed->size());
+ EXPECT_EQ(2U, unparsed->size());
+ ASSERT_NE(0U, unparsed->size());
// Check by HW address entries
bool checked_hw = false;
&hwaddrs_[i]->hwaddr_[0],
hwaddrs_[i]->hwaddr_.size());
ASSERT_TRUE(host);
- EXPECT_EQ(1 + i % 2, host->getIPv6SubnetID());
+ EXPECT_EQ(1U + i % 2, host->getIPv6SubnetID());
IPv6ResrvRange reservations =
host->getIPv6Reservations(IPv6Resrv::TYPE_NA);
ASSERT_EQ(1, std::distance(reservations.first, reservations.second));
host = cfg.get6(SubnetID(1 + i % 2), Host::IDENT_DUID,
&duids_[i]->getDuid()[0], duids_[i]->getDuid().size());
ASSERT_TRUE(host);
- EXPECT_EQ(1 + i % 2, host->getIPv6SubnetID());
+ EXPECT_EQ(1U + i % 2, host->getIPv6SubnetID());
reservations = host->getIPv6Reservations(IPv6Resrv::TYPE_NA);
ASSERT_EQ(1, std::distance(reservations.first, reservations.second));
EXPECT_EQ(increase(IOAddress("2001:db8:2::1"), i),
}
// Delete all hosts for subnet id. There should be 13 of them.
- EXPECT_EQ(13, cfg.delAll6(SubnetID(1)));
+ EXPECT_EQ(13U, cfg.delAll6(SubnetID(1)));
for (unsigned i = 0; i < 25; ++i) {
// Calculate subnet id for the given i.
ConstElementPtr unparsed = list.get(SubnetID(1 + i));
ASSERT_TRUE(unparsed);
ASSERT_EQ(Element::list, unparsed->getType());
- EXPECT_EQ(2, unparsed->size());
- ASSERT_NE(0, unparsed->size());
+ EXPECT_EQ(2U, unparsed->size());
+ ASSERT_NE(0U, unparsed->size());
// Check by HW address entries
bool checked_hw = false;
ConstElementPtr resvs = host->get("ip-addresses");
ASSERT_TRUE(resvs);
ASSERT_EQ(Element::list, resvs->getType());
- EXPECT_EQ(1, resvs->size());
- ASSERT_GE(1, resvs->size());
+ EXPECT_EQ(1U, resvs->size());
+ ASSERT_GE(1U, resvs->size());
ConstElementPtr resv = resvs->get(0);
ASSERT_TRUE(resv);
ASSERT_EQ(Element::string, resv->getType());
ConstElementPtr resvs = host->get("ip-addresses");
ASSERT_TRUE(resvs);
ASSERT_EQ(Element::list, resvs->getType());
- EXPECT_EQ(1, resvs->size());
- ASSERT_GE(1, resvs->size());
+ EXPECT_EQ(1U, resvs->size());
+ ASSERT_GE(1U, resvs->size());
ConstElementPtr resv = resvs->get(0);
ASSERT_TRUE(resv);
ASSERT_EQ(Element::string, resv->getType());
increase(IOAddress("2001:db8:2::1"), i));
ASSERT_TRUE(host);
- EXPECT_EQ(1 + i % 2, host->getIPv6SubnetID());
+ EXPECT_EQ(1U + i % 2, host->getIPv6SubnetID());
IPv6ResrvRange reservations =
host->getIPv6Reservations(IPv6Resrv::TYPE_NA);
ASSERT_EQ(1, std::distance(reservations.first, reservations.second));
// Get both hosts.
ConstHostCollection returned;
ASSERT_NO_THROW(returned = cfg.getAll4(host1->getIPv4SubnetID(), IOAddress("192.0.2.1")));
- EXPECT_EQ(2, returned.size());
+ EXPECT_EQ(2U, returned.size());
// Make sure the address is the same but the identifiers are different.
EXPECT_NE(returned[0]->getIdentifierAsText(), returned[1]->getIdentifierAsText());
ConstHostCollection returned;
ASSERT_NO_THROW(returned = cfg.getAll6(host1->getIPv6SubnetID(), IOAddress("2001:db8::1")));
- EXPECT_EQ(2, returned.size());
+ EXPECT_EQ(2U, returned.size());
// Make sure the address is the same but the identifiers are different.
EXPECT_NE(returned[0]->getIdentifierAsText(), returned[1]->getIdentifierAsText());
ConstHostCollection returned;
ASSERT_NO_THROW(returned = cfg.getAll6(host1->getIPv6SubnetID(), IOAddress("3000::")));
- EXPECT_EQ(2, returned.size());
+ EXPECT_EQ(2U, returned.size());
// Make sure the prefix is the same but the identifiers are different.
EXPECT_NE(returned[0]->getIdentifierAsText(), returned[1]->getIdentifierAsText());
// There should be no hosts.
HostCollection hosts(cfg.getAll6(SubnetID(1)));
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
// Add a host.
EXPECT_NO_THROW(cfg.add(host));
// The host should be in the config.
hosts = cfg.getAll6(SubnetID(1));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
EXPECT_EQ("duid=010203040500 ipv6_subnet_id=1 hostname=foo.example.com "
"ipv4_reservation=(no) siaddr=(no) sname=(empty) file=(empty) "
"key=(empty) ipv6_reservations=(none)", hosts[0]->toText());
// The same host should be in the config.
hosts = cfg.getAll6(SubnetID(1));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
EXPECT_EQ("duid=010203040500 ipv6_subnet_id=1 hostname=foo.example.com "
"ipv4_reservation=(no) siaddr=(no) sname=(empty) file=(empty) "
"key=(empty) ipv6_reservations=(none)", hosts[0]->toText());
// The change should be reflected in the config.
hosts = cfg.getAll6(SubnetID(1));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
EXPECT_EQ("duid=010203040500 ipv6_subnet_id=1 hostname=bar.example.com "
"ipv4_reservation=(no) siaddr=(no) sname=(empty) file=(empty) "
"key=(empty) ipv6_reservations=(none)", hosts[0]->toText());
// The change should be reflected in the config.
hosts = cfg.getAll6(SubnetID(1));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
EXPECT_EQ("duid=010203040500 ipv6_subnet_id=1 hostname=(empty) "
"ipv4_reservation=(no) siaddr=(no) sname=(empty) file=(empty) "
"key=(empty) ipv6_reservations=(none)", hosts[0]->toText());
ASSERT_NO_THROW(CfgMultiThreading::extract(param, enabled, thread_count,
queue_size));
EXPECT_EQ(enabled, true);
- EXPECT_EQ(thread_count, 4);
- EXPECT_EQ(queue_size, 64);
+ EXPECT_EQ(thread_count, 4U);
+ EXPECT_EQ(queue_size, 64U);
content_json = "{}";
ASSERT_NO_THROW(param = Element::fromJSON(content_json))
ASSERT_NO_THROW(CfgMultiThreading::extract(param, enabled, thread_count,
queue_size));
EXPECT_EQ(enabled, true);
- EXPECT_EQ(thread_count, 0);
- EXPECT_EQ(queue_size, 0);
+ EXPECT_EQ(thread_count, 0U);
+ EXPECT_EQ(queue_size, 0U);
enabled = true;
thread_count = 4;
ASSERT_NO_THROW(CfgMultiThreading::extract(ConstElementPtr(), enabled,
thread_count, queue_size));
EXPECT_EQ(enabled, true);
- EXPECT_EQ(thread_count, 0);
- EXPECT_EQ(queue_size, 0);
+ EXPECT_EQ(thread_count, 0U);
+ EXPECT_EQ(queue_size, 0U);
}
/// @brief Verifies that applying multi threading settings works
TEST_F(CfgMultiThreadingTest, apply) {
EXPECT_FALSE(MultiThreadingMgr::instance().getMode());
- EXPECT_EQ(MultiThreadingMgr::instance().getThreadPoolSize(), 0);
- EXPECT_EQ(MultiThreadingMgr::instance().getPacketQueueSize(), 0);
- EXPECT_EQ(MultiThreadingMgr::instance().getThreadPool().getMaxQueueSize(), 0);
+ EXPECT_EQ(MultiThreadingMgr::instance().getThreadPoolSize(), 0U);
+ EXPECT_EQ(MultiThreadingMgr::instance().getPacketQueueSize(), 0U);
+ EXPECT_EQ(MultiThreadingMgr::instance().getThreadPool().getMaxQueueSize(), 0U);
std::string content_json =
"{"
" \"enable-multi-threading\": true,\n"
<< "invalid context_json, test is broken";
CfgMultiThreading::apply(param);
EXPECT_TRUE(MultiThreadingMgr::instance().getMode());
- EXPECT_EQ(MultiThreadingMgr::instance().getThreadPoolSize(), 4);
- EXPECT_EQ(MultiThreadingMgr::instance().getPacketQueueSize(), 64);
- EXPECT_EQ(MultiThreadingMgr::instance().getThreadPool().getMaxQueueSize(), 64);
+ EXPECT_EQ(MultiThreadingMgr::instance().getThreadPoolSize(), 4U);
+ EXPECT_EQ(MultiThreadingMgr::instance().getPacketQueueSize(), 64U);
+ EXPECT_EQ(MultiThreadingMgr::instance().getThreadPool().getMaxQueueSize(), 64U);
}
} // namespace
// Sanity check that all 10 option definitions are there.
OptionDefContainerPtr option_defs1 = cfg.getAll("isc");
ASSERT_TRUE(option_defs1);
- ASSERT_EQ(10, option_defs1->size());
+ ASSERT_EQ(10U, option_defs1->size());
// Iterate over all option definitions and check that they have
// valid codes. Also, their order should be the same as they
// Sanity check that all 10 option definitions are there.
OptionDefContainerPtr option_defs2 = cfg.getAll("abcde");
ASSERT_TRUE(option_defs2);
- ASSERT_EQ(10, option_defs2->size());
+ ASSERT_EQ(10U, option_defs2->size());
// Check that the option codes are valid.
code = 105;
// Check that we can delete option definitions by id.
uint64_t num_deleted = 0;
ASSERT_NO_THROW(num_deleted = cfg.del(123));
- EXPECT_EQ(10, num_deleted);
+ EXPECT_EQ(10U, num_deleted);
option_defs1 = cfg.getAll("isc");
ASSERT_TRUE(option_defs1);
- ASSERT_EQ(0, option_defs1->size());
+ ASSERT_EQ(0U, option_defs1->size());
option_defs2 = cfg.getAll("abcde");
ASSERT_TRUE(option_defs2);
- ASSERT_EQ(10, option_defs2->size());
+ ASSERT_EQ(10U, option_defs2->size());
// Second attempt to delete the same option definitions should
// result in 0 deletions.
ASSERT_NO_THROW(num_deleted = cfg.del(123));
- EXPECT_EQ(0, num_deleted);
+ EXPECT_EQ(0U, num_deleted);
// Delete all other option definitions.
ASSERT_NO_THROW(num_deleted = cfg.del(234));
- EXPECT_EQ(10, num_deleted);
+ EXPECT_EQ(10U, num_deleted);
option_defs2 = cfg.getAll("abcde");
ASSERT_TRUE(option_defs2);
- ASSERT_EQ(0, option_defs2->size());
+ ASSERT_EQ(0U, option_defs2->size());
}
// This test verifies that single option definition is correctly
// Get options from the Subnet and check if all 10 are there.
OptionContainerPtr options = cfg.getAll(DHCP6_OPTION_SPACE);
ASSERT_TRUE(options);
- ASSERT_EQ(10, options->size());
+ ASSERT_EQ(10U, options->size());
// Validate codes of options added to dhcp6 option space.
uint16_t expected_code = 100;
// Try another function variant.
options = cfg.getAllCombined("isc");
ASSERT_TRUE(options);
- ASSERT_EQ(7, options->size());
+ ASSERT_EQ(7U, options->size());
// Validate codes of options added to isc option space.
expected_code = 105;
for (uint16_t code = 100; code < 110; ++code) {
OptionDescriptor desc = cfg_dst.get(DHCP6_OPTION_SPACE, code);
ASSERT_TRUE(desc.option_);
- ASSERT_EQ(1, desc.option_->getData().size());
+ ASSERT_EQ(1U, desc.option_->getData().size());
// The options with even option codes should hold one byte of data
// equal to 0x1. These are the ones that we have initially added to
// the destination configuration. The other options should hold the
for (uint16_t code = 100; code < 110; ++code) {
OptionDescriptor desc = cfg_dst.get(123, code);
ASSERT_TRUE(desc.option_);
- ASSERT_EQ(1, desc.option_->getData().size());
+ ASSERT_EQ(1U, desc.option_->getData().size());
// This time, the options with even option codes should hold a byte
// of data equal to 0xFF. The other options should hold the byte of
// data equal to 0x01.
for (uint16_t code = 100; code < 110; ++code) {
OptionDescriptor desc = cfg_dst.get("foo", code);
ASSERT_TRUE(desc.option_);
- ASSERT_EQ(1, desc.option_->getData().size());
+ ASSERT_EQ(1U, desc.option_->getData().size());
EXPECT_EQ(0x01, desc.option_->getData()[0]);
}
// The option space "foo" should contain exactly 10 options.
container = cfg_dst.getAll("foo");
ASSERT_TRUE(container);
- EXPECT_EQ(10, container->size());
+ EXPECT_EQ(10U, container->size());
// Source config wasn't encapsulated, so the destination shouldn't be too.
EXPECT_FALSE(cfg_dst.isEncapsulated());
ASSERT_NO_THROW_LOG(this_cfg.merge(defs, other_cfg));
EXPECT_EQ(countFile("DHCPSRV_CFGMGR_OPTION_DEFINITION_MISMATCH failed to "
"create option: option: isc.2 has a formatted value: "
- "'one,two,three' but no option definition"), 1);
+ "'one,two,three' but no option definition"), 1U);
// Now let's add an option definition that will force data truncated
// error for option 1.
ASSERT_NO_THROW_LOG(this_cfg.merge(defs, other_cfg));
EXPECT_EQ(countFile("DHCPSRV_CFGMGR_OPTION_DEFINITION_MISMATCH failed to "
"create option: could not create option: isc.1 from data"
- " specified, reason: OptionInt 1 truncated"), 1);
+ " specified, reason: OptionInt 1 truncated"), 1U);
}
// This test verifies the all of the valid option cases
ASSERT_NO_THROW(updated = CfgOption::createDescriptorOption(defs, space, *desc));
ASSERT_FALSE(updated);
- ASSERT_EQ(1, desc->option_->getData().size());
+ ASSERT_EQ(1U, desc->option_->getData().size());
EXPECT_EQ(0x77, desc->option_->getData()[0]);
}
// Verify that we have 40 top-level options.
OptionContainerPtr options = cfg.getAll(DHCP6_OPTION_SPACE);
- ASSERT_EQ(40, options->size());
+ ASSERT_EQ(40U, options->size());
// Iterate over top level options.
for (uint16_t code = 1000; code < 1040; ++code) {
// First level sub options. There are 19 sub-options for each top
// level option.
const OptionCollection& first_level = option->getOptions();
- ASSERT_EQ(19, first_level.size());
+ ASSERT_EQ(19U, first_level.size());
// Iterate over all first level sub-options.
for (auto const& first_level_opt : first_level) {
// There are two sets of first level sub-options. Those that include
// a value of 1 and those that include a value of 2.
if (first_level_uint8->getType() < 20) {
- EXPECT_EQ(1, value);
+ EXPECT_EQ(1U, value);
} else {
- EXPECT_EQ(2, value);
+ EXPECT_EQ(2U, value);
}
// Each first level sub-option should include 9 second level
// sub options.
const OptionCollection& second_level = first_level_uint8->getOptions();
- ASSERT_EQ(9, second_level.size());
+ ASSERT_EQ(9U, second_level.size());
// Iterate over sub-options and make sure they include the expected
// values.
// Certain sub-options should have a value of 3, other the values
// of 4.
if (second_level_uint8->getType() < 20) {
- EXPECT_EQ(3, value2);
+ EXPECT_EQ(3U, value2);
} else {
- EXPECT_EQ(4, value2);
+ EXPECT_EQ(4U, value2);
}
}
}
// Delete option with the code 5 and belonging to option space "foo".
uint64_t deleted_num;
ASSERT_NO_THROW(deleted_num = cfg.del("foo", 5));
- EXPECT_EQ(1, deleted_num);
+ EXPECT_EQ(1U, deleted_num);
// The option should now be gone from options config.
EXPECT_FALSE(cfg.get("foo", 5).option_);
// Delete options with id of 100. It includes both regular options and
// the vendor options. There are two options with id of 100.
- EXPECT_EQ(2, cfg.del(100));
+ EXPECT_EQ(2U, cfg.del(100));
// Make sure that the option 100 was deleted but another option
// in the same option space was not.
// Delete the option for vendor id 123.
uint64_t deleted_num;
ASSERT_NO_THROW(deleted_num = cfg.del(123, 105));
- EXPECT_EQ(1, deleted_num);
+ EXPECT_EQ(1U, deleted_num);
// Make sure the option is gone.
EXPECT_FALSE(cfg.get(123, 105).option_);
// Now, try the valid option space.
list = cfg.getList(DHCP4_OPTION_SPACE, code);
// Test that the option code matches the expected code.
- ASSERT_EQ(2, list.size());
+ ASSERT_EQ(2U, list.size());
OptionDescriptor desc = list[0];
ASSERT_TRUE(desc.option_);
EXPECT_EQ(code, desc.option_->getType());
OptionBuffer content = desc.option_->getData();
- ASSERT_EQ(10, content.size());
+ ASSERT_EQ(10U, content.size());
uint8_t val = content[8];
EXPECT_TRUE((val == 0xFF) || (val == 0xEE));
desc = list[1];
ASSERT_TRUE(desc.option_);
EXPECT_EQ(code, desc.option_->getType());
content = desc.option_->getData();
- ASSERT_EQ(10, content.size());
+ ASSERT_EQ(10U, content.size());
if (val == 0xFF) {
EXPECT_EQ(0xEE, content[4]);
} else {
// Now, try the valid option space.
list = cfg.getList(12345678, code);
// Test that the option code matches the expected code.
- ASSERT_EQ(2, list.size());
+ ASSERT_EQ(2U, list.size());
OptionDescriptor desc = list[0];
ASSERT_TRUE(desc.option_);
EXPECT_EQ(code, desc.option_->getType());
OptionBuffer content = desc.option_->getData();
- ASSERT_EQ(10, content.size());
+ ASSERT_EQ(10U, content.size());
uint8_t val = content[8];
EXPECT_TRUE((val == 0xFF) || (val == 0xEE));
desc = list[1];
ASSERT_TRUE(desc.option_);
EXPECT_EQ(code, desc.option_->getType());
content = desc.option_->getData();
- ASSERT_EQ(10, content.size());
+ ASSERT_EQ(10U, content.size());
if (val == 0xFF) {
EXPECT_EQ(0xEE, content[4]);
} else {
// Sanity check that all options are there.
OptionContainerPtr options = cfg.getAll(DHCP6_OPTION_SPACE);
- ASSERT_EQ(20, options->size());
+ ASSERT_EQ(20U, options->size());
// Use container index #1 to get the options by their codes.
OptionContainerTypeIndex& idx = options->get<1>();
// Get options from the Subnet and check if all 10 are there.
OptionContainerPtr options = cfg.getAll(12345678);
ASSERT_TRUE(options);
- ASSERT_EQ(10, options->size());
+ ASSERT_EQ(10U, options->size());
// Make sure we can get vendor options by option space.
options = cfg.getAllCombined("vendor-12345678");
ASSERT_TRUE(options);
- ASSERT_EQ(10, options->size());
+ ASSERT_EQ(10U, options->size());
// Validate codes of options added to dhcp6 option space.
uint16_t expected_code = 100;
options = cfg.getAll(vendor_id);
ASSERT_TRUE(options);
- ASSERT_EQ(7, options->size());
+ ASSERT_EQ(7U, options->size());
// Validate codes of options added to isc option space.
expected_code = 105;
// We should now have 10 different vendor ids.
std::list<std::string> space_names = cfg.getVendorIdsSpaceNames();
- ASSERT_EQ(10, space_names.size());
+ ASSERT_EQ(10U, space_names.size());
// Check that the option space names for those vendor ids are correct.
size_t id = 0;
// Verify that we have two networks with a default identifier and one
// with a unique identifier.
- EXPECT_EQ(0, network1->getId());
- EXPECT_EQ(123, network2->getId());
- EXPECT_EQ(0, network3->getId());
+ EXPECT_EQ(0U, network1->getId());
+ EXPECT_EQ(123U, network2->getId());
+ EXPECT_EQ(0U, network3->getId());
// Add our networks to the configuration.
cfg.add(network1);
// Delete second network by id.
uint64_t deleted_num = 0;
ASSERT_NO_THROW(deleted_num = cfg.del(network2->getId()));
- EXPECT_EQ(1, deleted_num);
+ EXPECT_EQ(1U, deleted_num);
// Make sure that the subnet no longer points to the deleted network.
SharedNetwork4Ptr returned_network;
// Delete the remaining two shared network using id of 0.
ASSERT_NO_THROW(deleted_num = cfg.del(network1->getId()));
- EXPECT_EQ(2, deleted_num);
+ EXPECT_EQ(2U, deleted_num);
// The subnets should no longer point to the deleted networks and
// the shared networks should no longer exist in the configuration.
EXPECT_FALSE(returned_network);
EXPECT_FALSE(cfg.getByName("fly"));
- EXPECT_EQ(0, cfg.del(network1->getId()));
+ EXPECT_EQ(0U, cfg.del(network1->getId()));
}
// This test verifies that shared networks must have unique names.
CfgSharedNetworks4 cfg_from;
ASSERT_NO_THROW(cfg_to.merge(cfg_def, cfg_from));
- ASSERT_EQ(3, cfg_to.getAll()->size());
+ ASSERT_EQ(3U, cfg_to.getAll()->size());
ASSERT_NO_FATAL_FAILURE(checkMergedNetwork(cfg_to, "network1", Triplet<uint32_t>(100),
std::vector<SubnetID>{SubnetID(1), SubnetID(2)}));
ASSERT_NO_FATAL_FAILURE(checkMergedNetwork(cfg_to, "network2", Triplet<uint32_t>(200),
// Network1 should have doubled its valid lifetime but still only have
// the orignal two subnets. Merge should discard associations on CB
// subnets and preserve the associations from existing config.
- ASSERT_EQ(3, cfg_to.getAll()->size());
+ ASSERT_EQ(3U, cfg_to.getAll()->size());
ASSERT_NO_FATAL_FAILURE(checkMergedNetwork(cfg_to, "network1", Triplet<uint32_t>(200),
std::vector<SubnetID>{SubnetID(1), SubnetID(2)}));
// Verify that we have two networks with a default identifier and one
// with a unique identifier.
- EXPECT_EQ(0, network1->getId());
- EXPECT_EQ(123, network2->getId());
- EXPECT_EQ(0, network3->getId());
+ EXPECT_EQ(0U, network1->getId());
+ EXPECT_EQ(123U, network2->getId());
+ EXPECT_EQ(0U, network3->getId());
// Add our networks to the configuration.
cfg.add(network1);
// Delete second network by id.
uint64_t deleted_num = 0;
ASSERT_NO_THROW(deleted_num = cfg.del(network2->getId()));
- EXPECT_EQ(1, deleted_num);
+ EXPECT_EQ(1U, deleted_num);
// Make sure that the subnet no longer points to the deleted network.
SharedNetwork6Ptr returned_network;
// Delete the remaining two shared network using id of 0.
ASSERT_NO_THROW(deleted_num = cfg.del(network1->getId()));
- EXPECT_EQ(2, deleted_num);
+ EXPECT_EQ(2U, deleted_num);
// The subnets should no longer point to the deleted networks and
// the shared networks should no longer exist in the configuration.
EXPECT_FALSE(returned_network);
EXPECT_FALSE(cfg.getByName("fly"));
- EXPECT_EQ(0, cfg.del(network1->getId()));
+ EXPECT_EQ(0U, cfg.del(network1->getId()));
}
// This test verifies that shared networks must have unique names.
CfgSharedNetworks6 cfg_from;
ASSERT_NO_THROW(cfg_to.merge(cfg_def, cfg_from));
- ASSERT_EQ(3, cfg_to.getAll()->size());
+ ASSERT_EQ(3U, cfg_to.getAll()->size());
ASSERT_NO_FATAL_FAILURE(checkMergedNetwork(cfg_to, "network1", Triplet<uint32_t>(100),
std::vector<SubnetID>{SubnetID(1), SubnetID(2)}));
ASSERT_NO_FATAL_FAILURE(checkMergedNetwork(cfg_to, "network2", Triplet<uint32_t>(200),
// Network1 should have doubled its valid lifetime but still only have
// the orignal two subnets. Merge should discard associations on CB
// subnets and preserve the associations from existing config.
- ASSERT_EQ(3, cfg_to.getAll()->size());
+ ASSERT_EQ(3U, cfg_to.getAll()->size());
ASSERT_NO_FATAL_FAILURE(checkMergedNetwork(cfg_to, "network1", Triplet<uint32_t>(200),
std::vector<SubnetID>{SubnetID(1), SubnetID(2)}));
void checkMergedSubnet(CfgSubnets4& cfg_subnets,
const std::string& prefix,
const SubnetID exp_subnet_id,
- int exp_valid,
+ uint32_t exp_valid,
SharedNetwork4Ptr exp_network) {
// Look for the network by prefix.
auto subnet = cfg_subnets.getByPrefix(prefix);
ASSERT_NO_THROW(cfg.add(subnet3));
// There should be three subnets.
- ASSERT_EQ(3, cfg.getAll()->size());
+ ASSERT_EQ(3U, cfg.getAll()->size());
// We're going to remove the subnet #2. Let's make sure it exists before
// we remove it.
ASSERT_TRUE(cfg.getByPrefix("192.0.3.0/26"));
// Remove the subnet and make sure it is gone.
ASSERT_NO_THROW(cfg.del(subnet2));
- ASSERT_EQ(2, cfg.getAll()->size());
+ ASSERT_EQ(2U, cfg.getAll()->size());
EXPECT_FALSE(cfg.getByPrefix("192.0.3.0/26"));
// Remove another subnet by ID.
ASSERT_NO_THROW(cfg.del(subnet1->getID()));
- ASSERT_EQ(1, cfg.getAll()->size());
+ ASSERT_EQ(1U, cfg.getAll()->size());
EXPECT_FALSE(cfg.getByPrefix("192.0.2.0/26"));
}
ASSERT_NO_THROW(cfg.add(subnet3));
// There should be three subnets.
- ASSERT_EQ(3, cfg.getAll()->size());
+ ASSERT_EQ(3U, cfg.getAll()->size());
// We're going to replace the subnet #2. Let's make sure it exists before
// we replace it.
ASSERT_TRUE(cfg.getByPrefix("192.0.3.0/26"));
Subnet4Ptr replaced = cfg.replace(subnet);
ASSERT_TRUE(replaced);
EXPECT_TRUE(replaced == subnet2);
- ASSERT_EQ(3, cfg.getAll()->size());
+ ASSERT_EQ(3U, cfg.getAll()->size());
Subnet4Ptr returned = cfg.getSubnet(SubnetID(2));
ASSERT_TRUE(returned);
EXPECT_TRUE(returned == subnet);
replaced = cfg.replace(replaced);
ASSERT_TRUE(replaced);
EXPECT_TRUE(replaced == subnet);
- ASSERT_EQ(3, cfg.getAll()->size());
+ ASSERT_EQ(3U, cfg.getAll()->size());
returned = cfg.getSubnet(SubnetID(2));
ASSERT_TRUE(returned);
EXPECT_TRUE(returned == subnet2);
ASSERT_NO_THROW(cfg_to.merge(cfg_def, networks, cfg_from));
// We should have all four subnets, with no changes.
- ASSERT_EQ(4, cfg_to.getAll()->size());
+ ASSERT_EQ(4U, cfg_to.getAll()->size());
// Should be no changes to the configuration.
ASSERT_NO_FATAL_FAILURE(checkMergedSubnet(cfg_to, "192.0.1.0/26",
// Merge again.
ASSERT_NO_THROW(cfg_to.merge(cfg_def, networks, cfg_from));
- ASSERT_EQ(5, cfg_to.getAll()->size());
+ ASSERT_EQ(5U, cfg_to.getAll()->size());
// The subnet1 should be replaced by subnet1b.
ASSERT_NO_FATAL_FAILURE(checkMergedSubnet(cfg_to, "192.0.10.0/26",
const Subnet4SimpleCollection* subnets_eth1 =
network_returned->getAllSubnets();
- EXPECT_EQ(2, subnets_eth1->size());
+ EXPECT_EQ(2U, subnets_eth1->size());
ASSERT_TRUE(network_returned->getSubnet(SubnetID(1)));
ASSERT_TRUE(network_returned->getSubnet(SubnetID(2)));
selector.iface_name_ = "lo";
selected = cfg.selectSubnet(selector);
ASSERT_TRUE(selected);
- EXPECT_EQ(2, selected->getID());
+ EXPECT_EQ(2U, selected->getID());
// Try selecting by eth1 again, but this time set subnet specific
// interface name to eth0. Subnet selection should fail.
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getValid().unspecified());
- EXPECT_EQ(100, subnet->getValid().get());
- EXPECT_EQ(100, subnet->getValid().getMin());
- EXPECT_EQ(100, subnet->getValid().getMax());
+ EXPECT_EQ(100U, subnet->getValid().get());
+ EXPECT_EQ(100U, subnet->getValid().getMin());
+ EXPECT_EQ(100U, subnet->getValid().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("valid-lifetime");
ASSERT_TRUE(value);
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getValid().unspecified());
- EXPECT_EQ(100, subnet->getValid().get());
- EXPECT_EQ(100, subnet->getValid().getMin());
- EXPECT_EQ(100, subnet->getValid().getMax());
+ EXPECT_EQ(100U, subnet->getValid().get());
+ EXPECT_EQ(100U, subnet->getValid().getMin());
+ EXPECT_EQ(100U, subnet->getValid().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("valid-lifetime");
ASSERT_TRUE(value);
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getValid().unspecified());
- EXPECT_EQ(100, subnet->getValid().get());
- EXPECT_EQ(100, subnet->getValid().getMin());
- EXPECT_EQ(100, subnet->getValid().getMax());
+ EXPECT_EQ(100U, subnet->getValid().get());
+ EXPECT_EQ(100U, subnet->getValid().getMin());
+ EXPECT_EQ(100U, subnet->getValid().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("valid-lifetime");
ASSERT_TRUE(value);
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getValid().unspecified());
- EXPECT_EQ(200, subnet->getValid().get());
- EXPECT_EQ(100, subnet->getValid().getMin());
- EXPECT_EQ(200, subnet->getValid().getMax());
+ EXPECT_EQ(200U, subnet->getValid().get());
+ EXPECT_EQ(100U, subnet->getValid().getMin());
+ EXPECT_EQ(200U, subnet->getValid().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("valid-lifetime");
ASSERT_TRUE(value);
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getValid().unspecified());
- EXPECT_EQ(100, subnet->getValid().get());
- EXPECT_EQ(100, subnet->getValid().getMin());
- EXPECT_EQ(200, subnet->getValid().getMax());
+ EXPECT_EQ(100U, subnet->getValid().get());
+ EXPECT_EQ(100U, subnet->getValid().getMin());
+ EXPECT_EQ(200U, subnet->getValid().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("valid-lifetime");
ASSERT_TRUE(value);
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getValid().unspecified());
- EXPECT_EQ(200, subnet->getValid().get());
- EXPECT_EQ(100, subnet->getValid().getMin());
- EXPECT_EQ(300, subnet->getValid().getMax());
+ EXPECT_EQ(200U, subnet->getValid().get());
+ EXPECT_EQ(100U, subnet->getValid().getMin());
+ EXPECT_EQ(300U, subnet->getValid().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("valid-lifetime");
ASSERT_TRUE(value);
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getValid().unspecified());
- EXPECT_EQ(100, subnet->getValid().get());
- EXPECT_EQ(100, subnet->getValid().getMin());
- EXPECT_EQ(100, subnet->getValid().getMax());
+ EXPECT_EQ(100U, subnet->getValid().get());
+ EXPECT_EQ(100U, subnet->getValid().getMin());
+ EXPECT_EQ(100U, subnet->getValid().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("valid-lifetime");
ASSERT_TRUE(value);
CfgHostsPtr cfg_hosts = CfgMgr::instance().getStagingCfg()->getCfgHosts();
ASSERT_TRUE(cfg_hosts);
HostCollection hosts = cfg_hosts->getAll4(SubnetID(1));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
ConstHostPtr host = hosts[0];
ASSERT_TRUE(host);
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ("hwaddr=AABBCCDDEEFF", host->getIdentifierAsText());
EXPECT_EQ("10.1.2.1", host->getIPv4Reservation().toText());
void checkMergedSubnet(CfgSubnets6& cfg_subnets,
const std::string& prefix,
const SubnetID exp_subnet_id,
- int exp_valid,
+ uint32_t exp_valid,
SharedNetwork6Ptr exp_network) {
// Look for the network by prefix.
auto subnet = cfg_subnets.getByPrefix(prefix);
ASSERT_NO_THROW(cfg.add(subnet3));
// There should be three subnets.
- ASSERT_EQ(3, cfg.getAll()->size());
+ ASSERT_EQ(3U, cfg.getAll()->size());
// We're going to remove the subnet #2. Let's make sure it exists before
// we remove it.
ASSERT_TRUE(cfg.getByPrefix("2001:db8:2::/48"));
// Remove the subnet and make sure it is gone.
ASSERT_NO_THROW(cfg.del(subnet2));
- ASSERT_EQ(2, cfg.getAll()->size());
+ ASSERT_EQ(2U, cfg.getAll()->size());
EXPECT_FALSE(cfg.getByPrefix("2001:db8:2::/48"));
// Remove another subnet by ID.
ASSERT_NO_THROW(cfg.del(subnet1->getID()));
- ASSERT_EQ(1, cfg.getAll()->size());
+ ASSERT_EQ(1U, cfg.getAll()->size());
EXPECT_FALSE(cfg.getByPrefix("2001:db8:1::/48"));
}
ASSERT_NO_THROW(cfg.add(subnet3));
// There should be three subnets.
- ASSERT_EQ(3, cfg.getAll()->size());
+ ASSERT_EQ(3U, cfg.getAll()->size());
// We're going to replace the subnet #2. Let's make sure it exists before
// we replace it.
ASSERT_TRUE(cfg.getByPrefix("2001:db8:2::/48"));
Subnet6Ptr replaced = cfg.replace(subnet);
ASSERT_TRUE(replaced);
EXPECT_TRUE(replaced == subnet2);
- ASSERT_EQ(3, cfg.getAll()->size());
+ ASSERT_EQ(3U, cfg.getAll()->size());
Subnet6Ptr returned = cfg.getSubnet(SubnetID(2));
ASSERT_TRUE(returned);
EXPECT_TRUE(returned == subnet);
replaced = cfg.replace(replaced);
ASSERT_TRUE(replaced);
EXPECT_TRUE(replaced == subnet);
- ASSERT_EQ(3, cfg.getAll()->size());
+ ASSERT_EQ(3U, cfg.getAll()->size());
returned = cfg.getSubnet(SubnetID(2));
ASSERT_TRUE(returned);
EXPECT_TRUE(returned == subnet2);
ASSERT_NO_THROW(cfg_to.merge(cfg_def, networks, cfg_from));
// We should have all four subnets, with no changes.
- ASSERT_EQ(4, cfg_to.getAll()->size());
+ ASSERT_EQ(4U, cfg_to.getAll()->size());
// Should be no changes to the configuration.
ASSERT_NO_FATAL_FAILURE(checkMergedSubnet(cfg_to, "2001:1::/64",
// Merge again.
ASSERT_NO_THROW(cfg_to.merge(cfg_def, networks, cfg_from));
- ASSERT_EQ(5, cfg_to.getAll()->size());
+ ASSERT_EQ(5U, cfg_to.getAll()->size());
// The subnet1 should be replaced by subnet1b.
ASSERT_NO_FATAL_FAILURE(checkMergedSubnet(cfg_to, "2001:10::/64",
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getPreferred().unspecified());
- EXPECT_EQ(100, subnet->getPreferred().get());
- EXPECT_EQ(100, subnet->getPreferred().getMin());
- EXPECT_EQ(100, subnet->getPreferred().getMax());
+ EXPECT_EQ(100U, subnet->getPreferred().get());
+ EXPECT_EQ(100U, subnet->getPreferred().getMin());
+ EXPECT_EQ(100U, subnet->getPreferred().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("preferred-lifetime");
ASSERT_TRUE(value);
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getPreferred().unspecified());
- EXPECT_EQ(100, subnet->getPreferred().get());
- EXPECT_EQ(100, subnet->getPreferred().getMin());
- EXPECT_EQ(100, subnet->getPreferred().getMax());
+ EXPECT_EQ(100U, subnet->getPreferred().get());
+ EXPECT_EQ(100U, subnet->getPreferred().getMin());
+ EXPECT_EQ(100U, subnet->getPreferred().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("preferred-lifetime");
ASSERT_TRUE(value);
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getPreferred().unspecified());
- EXPECT_EQ(100, subnet->getPreferred().get());
- EXPECT_EQ(100, subnet->getPreferred().getMin());
- EXPECT_EQ(100, subnet->getPreferred().getMax());
+ EXPECT_EQ(100U, subnet->getPreferred().get());
+ EXPECT_EQ(100U, subnet->getPreferred().getMin());
+ EXPECT_EQ(100U, subnet->getPreferred().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("preferred-lifetime");
ASSERT_TRUE(value);
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getPreferred().unspecified());
- EXPECT_EQ(200, subnet->getPreferred().get());
- EXPECT_EQ(100, subnet->getPreferred().getMin());
- EXPECT_EQ(200, subnet->getPreferred().getMax());
+ EXPECT_EQ(200U, subnet->getPreferred().get());
+ EXPECT_EQ(100U, subnet->getPreferred().getMin());
+ EXPECT_EQ(200U, subnet->getPreferred().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("preferred-lifetime");
ASSERT_TRUE(value);
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getPreferred().unspecified());
- EXPECT_EQ(100, subnet->getPreferred().get());
- EXPECT_EQ(100, subnet->getPreferred().getMin());
- EXPECT_EQ(200, subnet->getPreferred().getMax());
+ EXPECT_EQ(100U, subnet->getPreferred().get());
+ EXPECT_EQ(100U, subnet->getPreferred().getMin());
+ EXPECT_EQ(200U, subnet->getPreferred().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("preferred-lifetime");
ASSERT_TRUE(value);
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getPreferred().unspecified());
- EXPECT_EQ(200, subnet->getPreferred().get());
- EXPECT_EQ(100, subnet->getPreferred().getMin());
- EXPECT_EQ(300, subnet->getPreferred().getMax());
+ EXPECT_EQ(200U, subnet->getPreferred().get());
+ EXPECT_EQ(100U, subnet->getPreferred().getMin());
+ EXPECT_EQ(300U, subnet->getPreferred().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("preferred-lifetime");
ASSERT_TRUE(value);
ASSERT_NO_THROW(subnet = parser.parse(copied));
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getPreferred().unspecified());
- EXPECT_EQ(100, subnet->getPreferred().get());
- EXPECT_EQ(100, subnet->getPreferred().getMin());
- EXPECT_EQ(100, subnet->getPreferred().getMax());
+ EXPECT_EQ(100U, subnet->getPreferred().get());
+ EXPECT_EQ(100U, subnet->getPreferred().getMin());
+ EXPECT_EQ(100U, subnet->getPreferred().getMax());
data::ConstElementPtr repr = subnet->toElement();
data::ConstElementPtr value = repr->get("preferred-lifetime");
ASSERT_TRUE(value);
CfgHostsPtr cfg_hosts = CfgMgr::instance().getStagingCfg()->getCfgHosts();
ASSERT_TRUE(cfg_hosts);
HostCollection hosts = cfg_hosts->getAll6(SubnetID(1));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
ConstHostPtr host = hosts[0];
ASSERT_TRUE(host);
- EXPECT_EQ(1, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv6SubnetID());
EXPECT_EQ("hwaddr=AABBCCDDEEFF", host->getIdentifierAsText());
IPv6ResrvRange addresses = host->getIPv6Reservations(IPv6Resrv::TYPE_NA);
ASSERT_EQ(1, std::distance(addresses.first, addresses.second));
CfgHostsPtr cfg_hosts = CfgMgr::instance().getStagingCfg()->getCfgHosts();
ASSERT_TRUE(cfg_hosts);
HostCollection hosts = cfg_hosts->getAll6(SubnetID(1));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
ConstHostPtr host = hosts[0];
ASSERT_TRUE(host);
- EXPECT_EQ(1, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv6SubnetID());
EXPECT_EQ("hwaddr=AABBCCDDEEFF", host->getIdentifierAsText());
IPv6ResrvRange prefixes = host->getIPv6Reservations(IPv6Resrv::TYPE_PD);
ASSERT_EQ(1, std::distance(prefixes.first, prefixes.second));
EXPECT_EQ("2001:db8:2::", prefixes.first->second.getPrefix().toText());
- EXPECT_EQ(64, prefixes.first->second.getPrefixLen());
+ EXPECT_EQ(64U, prefixes.first->second.getPrefixLen());
// Verify the prefix is not in the subnet range.
EXPECT_FALSE(subnet->inRange(prefixes.first->second.getPrefix()));
EXPECT_FALSE(testStore.getParam("firstBool"));
EXPECT_TRUE(testStore.getParam("secondBool"));
- EXPECT_EQ(123, testStore.getPosition("firstBool").line_);
- EXPECT_EQ(234, testStore.getPosition("firstBool").pos_);
+ EXPECT_EQ(123U, testStore.getPosition("firstBool").line_);
+ EXPECT_EQ(234U, testStore.getPosition("firstBool").pos_);
EXPECT_EQ("kea.conf", testStore.getPosition("firstBool").file_);
- EXPECT_EQ(10, testStore.getPosition("secondBool").line_);
- EXPECT_EQ(20, testStore.getPosition("secondBool").pos_);
+ EXPECT_EQ(10U, testStore.getPosition("secondBool").line_);
+ EXPECT_EQ(20U, testStore.getPosition("secondBool").pos_);
EXPECT_EQ("keax.conf", testStore.getPosition("secondBool").file_);
// Verify that we can update parameters.
EXPECT_TRUE(testStore.getParam("firstBool"));
EXPECT_FALSE(testStore.getParam("secondBool"));
- EXPECT_EQ(555, testStore.getPosition("firstBool").line_);
- EXPECT_EQ(111, testStore.getPosition("firstBool").pos_);
+ EXPECT_EQ(555U, testStore.getPosition("firstBool").line_);
+ EXPECT_EQ(111U, testStore.getPosition("firstBool").pos_);
EXPECT_EQ("keax.conf", testStore.getPosition("firstBool").file_);
- EXPECT_EQ(1, testStore.getPosition("secondBool").line_);
- EXPECT_EQ(3, testStore.getPosition("secondBool").pos_);
+ EXPECT_EQ(1U, testStore.getPosition("secondBool").line_);
+ EXPECT_EQ(3U, testStore.getPosition("secondBool").pos_);
EXPECT_EQ("kea.conf", testStore.getPosition("secondBool").file_);
// Verify that we can delete a parameter and it will no longer be found.
// Verify that the delete was safe and the store still operates.
EXPECT_FALSE(testStore.getParam("secondBool"));
- EXPECT_EQ(1, testStore.getPosition("secondBool").line_);
- EXPECT_EQ(3, testStore.getPosition("secondBool").pos_);
+ EXPECT_EQ(1U, testStore.getPosition("secondBool").line_);
+ EXPECT_EQ(3U, testStore.getPosition("secondBool").pos_);
EXPECT_EQ("kea.conf", testStore.getPosition("secondBool").file_);
// Verify that looking for a parameter that never existed throws.
EXPECT_EQ(testStore.getParam("firstInt"), int_one);
EXPECT_EQ(testStore.getParam("secondInt"), int_two);
- EXPECT_EQ(123, testStore.getPosition("firstInt").line_);
- EXPECT_EQ(234, testStore.getPosition("firstInt").pos_);
+ EXPECT_EQ(123U, testStore.getPosition("firstInt").line_);
+ EXPECT_EQ(234U, testStore.getPosition("firstInt").pos_);
EXPECT_EQ("kea.conf", testStore.getPosition("firstInt").file_);
- EXPECT_EQ(10, testStore.getPosition("secondInt").line_);
- EXPECT_EQ(20, testStore.getPosition("secondInt").pos_);
+ EXPECT_EQ(10U, testStore.getPosition("secondInt").line_);
+ EXPECT_EQ(20U, testStore.getPosition("secondInt").pos_);
EXPECT_EQ("keax.conf", testStore.getPosition("secondInt").file_);
// Verify that we can update parameters.
EXPECT_EQ(testStore.getParam("firstInt"), int_one);
EXPECT_EQ(testStore.getParam("secondInt"), int_two);
- EXPECT_EQ(555, testStore.getPosition("firstInt").line_);
- EXPECT_EQ(111, testStore.getPosition("firstInt").pos_);
+ EXPECT_EQ(555U, testStore.getPosition("firstInt").line_);
+ EXPECT_EQ(111U, testStore.getPosition("firstInt").pos_);
EXPECT_EQ("keax.conf", testStore.getPosition("firstInt").file_);
- EXPECT_EQ(1, testStore.getPosition("secondInt").line_);
- EXPECT_EQ(3, testStore.getPosition("secondInt").pos_);
+ EXPECT_EQ(1U, testStore.getPosition("secondInt").line_);
+ EXPECT_EQ(3U, testStore.getPosition("secondInt").pos_);
EXPECT_EQ("kea.conf", testStore.getPosition("secondInt").file_);
// Verify that we can delete a parameter and it will no longer be found.
// Verify that the delete was safe and the store still operates.
EXPECT_EQ(testStore.getParam("secondInt"), int_two);
- EXPECT_EQ(1, testStore.getPosition("secondInt").line_);
- EXPECT_EQ(3, testStore.getPosition("secondInt").pos_);
+ EXPECT_EQ(1U, testStore.getPosition("secondInt").line_);
+ EXPECT_EQ(3U, testStore.getPosition("secondInt").pos_);
EXPECT_EQ("kea.conf", testStore.getPosition("secondInt").file_);
// Verify that looking for a parameter that never existed throws.
EXPECT_EQ(testStore.getParam("firstString"), string_one);
EXPECT_EQ(testStore.getParam("secondString"), string_two);
- EXPECT_EQ(123, testStore.getPosition("firstString").line_);
- EXPECT_EQ(234, testStore.getPosition("firstString").pos_);
+ EXPECT_EQ(123U, testStore.getPosition("firstString").line_);
+ EXPECT_EQ(234U, testStore.getPosition("firstString").pos_);
EXPECT_EQ("kea.conf", testStore.getPosition("firstString").file_);
- EXPECT_EQ(10, testStore.getPosition("secondString").line_);
- EXPECT_EQ(20, testStore.getPosition("secondString").pos_);
+ EXPECT_EQ(10U, testStore.getPosition("secondString").line_);
+ EXPECT_EQ(20U, testStore.getPosition("secondString").pos_);
EXPECT_EQ("keax.conf", testStore.getPosition("secondString").file_);
// Verify that we can update parameters.
EXPECT_EQ(testStore.getParam("firstString"), string_one);
EXPECT_EQ(testStore.getParam("secondString"), string_two);
- EXPECT_EQ(555, testStore.getPosition("firstString").line_);
- EXPECT_EQ(111, testStore.getPosition("firstString").pos_);
+ EXPECT_EQ(555U, testStore.getPosition("firstString").line_);
+ EXPECT_EQ(111U, testStore.getPosition("firstString").pos_);
EXPECT_EQ("kea.conf", testStore.getPosition("firstString").file_);
- EXPECT_EQ(1, testStore.getPosition("secondString").line_);
- EXPECT_EQ(3, testStore.getPosition("secondString").pos_);
+ EXPECT_EQ(1U, testStore.getPosition("secondString").line_);
+ EXPECT_EQ(3U, testStore.getPosition("secondString").pos_);
EXPECT_EQ("keax.conf", testStore.getPosition("secondString").file_);
// Verify that we can delete a parameter and it will no longer be found.
// Verify that the delete was safe and the store still operates.
EXPECT_EQ(testStore.getParam("secondString"), string_two);
- EXPECT_EQ(1, testStore.getPosition("secondString").line_);
- EXPECT_EQ(3, testStore.getPosition("secondString").pos_);
+ EXPECT_EQ(1U, testStore.getPosition("secondString").line_);
+ EXPECT_EQ(3U, testStore.getPosition("secondString").pos_);
EXPECT_EQ("keax.conf", testStore.getPosition("secondString").file_);
// Verify that looking for a parameter that never existed throws.
const_config = cfg_mgr.getCurrentCfg();
ASSERT_TRUE(const_config) << "Returned NULL current configuration"
" for iteration " << i;
- EXPECT_EQ(0, const_config->getSequence())
+ EXPECT_EQ(0U, const_config->getSequence())
<< "Returned invalid sequence number "
<< const_config->getSequence() << " for iteration " << i;
}
" iteration " << i;
// The sequence id is 1 for staging because it is ahead of current
// configuration having sequence number 0.
- EXPECT_EQ(1, config->getSequence()) << "Returned invalid sequence"
+ EXPECT_EQ(1U, config->getSequence()) << "Returned invalid sequence"
" number " << config->getSequence() << " for iteration " << i;
}
ASSERT_TRUE(const_config);
// Sequence id equal to 1 indicates that the current configuration points
// to the configuration that used to be a staging configuration previously.
- EXPECT_EQ(1, const_config->getSequence());
+ EXPECT_EQ(1U, const_config->getSequence());
// Last commit timestamp should be between before and after.
auto reload = const_config->getLastCommitTime();
ASSERT_FALSE(reload.is_not_a_date_time());
// sequence id.
config = cfg_mgr.getStagingCfg();
ASSERT_TRUE(config);
- EXPECT_EQ(2, config->getSequence());
+ EXPECT_EQ(2U, config->getSequence());
// Let's execute commit a couple of times. The first invocation to commit
// changes the configuration having sequence 2 to current configuration.
// The current configuration now have sequence number 2.
const_config = cfg_mgr.getCurrentCfg();
ASSERT_TRUE(const_config);
- EXPECT_EQ(2, const_config->getSequence());
+ EXPECT_EQ(2U, const_config->getSequence());
// Clear configuration along with a history.
cfg_mgr.clear();
// new staging configuration.
config = cfg_mgr.getStagingCfg();
ASSERT_TRUE(config);
- EXPECT_EQ(1, config->getSequence());
+ EXPECT_EQ(1U, config->getSequence());
// Modify the staging configuration.
config->addLoggingInfo(LoggingInfo());
ASSERT_TRUE(config);
// The modified staging configuration should have one logger configured.
- ASSERT_EQ(1, config->getLoggingInfo().size());
+ ASSERT_EQ(1U, config->getLoggingInfo().size());
// Remove the staging configuration, including the logger.
ASSERT_NO_THROW(cfg_mgr.clearStagingConfiguration());
// rollback worked.
config = cfg_mgr.getStagingCfg();
ASSERT_TRUE(config);
- EXPECT_EQ(0, config->getLoggingInfo().size());
+ EXPECT_EQ(0U, config->getLoggingInfo().size());
}
// This test verifies that the address family can be set and obtained
// Let's commit it
cfg_mgr.commit();
- EXPECT_EQ(15, stats_mgr.getMaxSampleCountDefault());
+ EXPECT_EQ(15U, stats_mgr.getMaxSampleCountDefault());
EXPECT_EQ("00:00:02", durationToText(stats_mgr.getMaxSampleAgeDefault(), 0));
EXPECT_FALSE(stats_mgr.getObservation("subnet[123].total-addresses"));
ASSERT_TRUE(total_addrs);
EXPECT_EQ(128, total_addrs->getInteger().first);
EXPECT_TRUE(total_addrs->getMaxSampleCount().first);
- EXPECT_EQ(15, total_addrs->getMaxSampleCount().second);
+ EXPECT_EQ(15U, total_addrs->getMaxSampleCount().second);
EXPECT_FALSE(total_addrs->getMaxSampleAge().first);
EXPECT_EQ("00:00:02", durationToText(total_addrs->getMaxSampleAge().second, 0));
EXPECT_NO_THROW(total_addrs = stats_mgr.getObservation("subnet[42].pool[0].total-addresses"));
// The stats should have been updated and so we should be able to get
// observations for subnet 42.
- EXPECT_EQ(16, stats_mgr.getMaxSampleCountDefault());
+ EXPECT_EQ(16U, stats_mgr.getMaxSampleCountDefault());
EXPECT_EQ("00:00:03", durationToText(stats_mgr.getMaxSampleAgeDefault(), 0));
EXPECT_TRUE(stats_mgr.getObservation("subnet[42].total-addresses"));
// Let's commit it
cfg_mgr.commit();
- EXPECT_EQ(14, stats_mgr.getMaxSampleCountDefault());
+ EXPECT_EQ(14U, stats_mgr.getMaxSampleCountDefault());
EXPECT_EQ("00:00:10", durationToText(stats_mgr.getMaxSampleAgeDefault(), 0));
EXPECT_FALSE(stats_mgr.getObservation("subnet[123].total-nas"));
ASSERT_TRUE(total_addrs);
EXPECT_EQ(128, total_addrs->getBigInteger().first);
EXPECT_TRUE(total_addrs->getMaxSampleCount().first);
- EXPECT_EQ(14, total_addrs->getMaxSampleCount().second);
+ EXPECT_EQ(14U, total_addrs->getMaxSampleCount().second);
EXPECT_FALSE(total_addrs->getMaxSampleAge().first);
EXPECT_EQ("00:00:10", durationToText(total_addrs->getMaxSampleAge().second, 0));
EXPECT_NO_THROW(total_addrs = stats_mgr.getObservation("subnet[42].pool[0].total-nas"));
ASSERT_TRUE(total_prfx);
EXPECT_EQ(65536, total_prfx->getBigInteger().first);
EXPECT_TRUE(total_prfx->getMaxSampleCount().first);
- EXPECT_EQ(14, total_prfx->getMaxSampleCount().second);
+ EXPECT_EQ(14U, total_prfx->getMaxSampleCount().second);
EXPECT_FALSE(total_prfx->getMaxSampleAge().first);
EXPECT_EQ("00:00:10", durationToText(total_prfx->getMaxSampleAge().second, 0));
EXPECT_NO_THROW(total_prfx = stats_mgr.getObservation("subnet[42].pd-pool[0].total-pds"));
// The stats should have been updated and so we should be able to get
// observations for subnet 42.
- EXPECT_EQ(17, stats_mgr.getMaxSampleCountDefault());
+ EXPECT_EQ(17U, stats_mgr.getMaxSampleCountDefault());
EXPECT_EQ("00:00:04", durationToText(stats_mgr.getMaxSampleAgeDefault(), 0));
EXPECT_TRUE(stats_mgr.getObservation("subnet[42].total-nas"));
ASSERT_NO_THROW(ext_cfg1 = cfg_mgr.createExternalCfg());
ASSERT_TRUE(ext_cfg1);
// It should pick the first available sequence number.
- EXPECT_EQ(0, ext_cfg1->getSequence());
+ EXPECT_EQ(0U, ext_cfg1->getSequence());
// Create second external configuration.
SrvConfigPtr ext_cfg2;
ASSERT_NO_THROW(ext_cfg2 = cfg_mgr.createExternalCfg());
ASSERT_TRUE(ext_cfg2);
// It should pick the next available sequence number.
- EXPECT_EQ(1, ext_cfg2->getSequence());
+ EXPECT_EQ(1U, ext_cfg2->getSequence());
// Those must be two separate instances.
ASSERT_FALSE(ext_cfg1 == ext_cfg2);
SrvConfigPtr ext_cfg3;
ASSERT_NO_THROW(ext_cfg3 = cfg_mgr.createExternalCfg());
ASSERT_TRUE(ext_cfg3);
- EXPECT_EQ(2, ext_cfg3->getSequence());
+ EXPECT_EQ(2U, ext_cfg3->getSequence());
// Merge the second and third (empty) configuration.
ASSERT_NO_THROW(cfg_mgr.mergeIntoStagingCfg(ext_cfg2->getSequence()));
SrvConfigPtr ext_cfg4;
ASSERT_NO_THROW(ext_cfg4 = cfg_mgr.createExternalCfg());
ASSERT_TRUE(ext_cfg4);
- EXPECT_EQ(0, ext_cfg4->getSequence());
+ EXPECT_EQ(0U, ext_cfg4->getSequence());
// Try to commit the staging configuration.
ASSERT_NO_THROW(cfg_mgr.commit());
ASSERT_NO_THROW(ext_cfg1 = cfg_mgr.createExternalCfg());
ASSERT_TRUE(ext_cfg1);
// It should pick the first available sequence number.
- EXPECT_EQ(0, ext_cfg1->getSequence());
+ EXPECT_EQ(0U, ext_cfg1->getSequence());
// Create second external configuration.
SrvConfigPtr ext_cfg2;
ASSERT_NO_THROW(ext_cfg2 = cfg_mgr.createExternalCfg());
ASSERT_TRUE(ext_cfg2);
// It should pick the next available sequence number.
- EXPECT_EQ(1, ext_cfg2->getSequence());
+ EXPECT_EQ(1U, ext_cfg2->getSequence());
// Those must be two separate instances.
ASSERT_FALSE(ext_cfg1 == ext_cfg2);
SrvConfigPtr ext_cfg3;
ASSERT_NO_THROW(ext_cfg3 = cfg_mgr.createExternalCfg());
ASSERT_TRUE(ext_cfg3);
- EXPECT_EQ(2, ext_cfg3->getSequence());
+ EXPECT_EQ(2U, ext_cfg3->getSequence());
// Merge the second and third (empty) configuration.
ASSERT_NO_THROW(cfg_mgr.mergeIntoCurrentCfg(ext_cfg2->getSequence()));
SrvConfigPtr ext_cfg4;
ASSERT_NO_THROW(ext_cfg4 = cfg_mgr.createExternalCfg());
ASSERT_TRUE(ext_cfg4);
- EXPECT_EQ(0, ext_cfg4->getSequence());
+ EXPECT_EQ(0U, ext_cfg4->getSequence());
}
/// @todo Add unit-tests for testing:
ASSERT_TRUE(cfg_option);
OptionContainerPtr oc;
ASSERT_TRUE(oc = cclass->getCfgOption()->getAll(DHCP4_OPTION_SPACE));
- EXPECT_EQ(0, oc->size());
+ EXPECT_EQ(0U, oc->size());
// Verify we have no expression.
ASSERT_FALSE(cclass->getMatchExpr());
ASSERT_TRUE(cfg_option);
OptionContainerPtr oc;
ASSERT_TRUE(oc = cclass->getCfgOption()->getAll(DHCP4_OPTION_SPACE));
- EXPECT_EQ(0, oc->size());
+ EXPECT_EQ(0U, oc->size());
// Verify we can retrieve the expression
ExpressionPtr match_expr = cclass->getMatchExpr();
ASSERT_TRUE(cfg_option);
OptionContainerPtr oc;
ASSERT_TRUE(oc = cclass->getCfgOption()->getAll(DHCP4_OPTION_SPACE));
- EXPECT_EQ(0, oc->size());
+ EXPECT_EQ(0U, oc->size());
// Verify we can retrieve the expression
ExpressionPtr match_expr = cclass->getMatchExpr();
ASSERT_TRUE(cfg_option);
OptionContainerPtr oc;
ASSERT_TRUE(oc = cclass->getCfgOption()->getAll(DHCP6_OPTION_SPACE));
- EXPECT_EQ(0, oc->size());
+ EXPECT_EQ(0U, oc->size());
// Verify we can retrieve the expression
ExpressionPtr match_expr = cclass->getMatchExpr();
ASSERT_TRUE(cfg_option);
OptionContainerPtr oc;
ASSERT_TRUE(oc = cclass->getCfgOption()->getAll(DHCP6_OPTION_SPACE));
- EXPECT_EQ(0, oc->size());
+ EXPECT_EQ(0U, oc->size());
// Verify we can retrieve the expression
ExpressionPtr match_expr = cclass->getMatchExpr();
ASSERT_TRUE(dictionary);
// We should have three classes in the dictionary.
- EXPECT_EQ(3, dictionary->getClasses()->size());
+ EXPECT_EQ(3U, dictionary->getClasses()->size());
// Make sure we can find all three.
ClientClassDefPtr cclass;
ASSERT_TRUE(dictionary);
// We should have three classes in the dictionary.
- EXPECT_EQ(3, dictionary->getClasses()->size());
+ EXPECT_EQ(3U, dictionary->getClasses()->size());
// Make sure we can find all three.
ClientClassDefPtr cclass;
// And it should not have any fixed fields set
EXPECT_EQ(IOAddress("0.0.0.0"), cclass->getNextServer());
- EXPECT_EQ(0, cclass->getSname().size());
- EXPECT_EQ(0, cclass->getFilename().size());
+ EXPECT_EQ(0U, cclass->getSname().size());
+ EXPECT_EQ(0U, cclass->getFilename().size());
EXPECT_TRUE(cclass->getOfferLft().unspecified());
// Nor option definitions
ASSERT_TRUE(cclass);
// And it should not have any fixed fields set
- EXPECT_EQ(0, cclass->getPreferred().get());
- EXPECT_EQ(0, cclass->getPreferred().getMin());
- EXPECT_EQ(0, cclass->getPreferred().getMax());
+ EXPECT_EQ(0U, cclass->getPreferred().get());
+ EXPECT_EQ(0U, cclass->getPreferred().getMin());
+ EXPECT_EQ(0U, cclass->getPreferred().getMax());
// Nor option definitions
CfgOptionDefPtr cfg = cclass->getCfgOptionDef();
ASSERT_TRUE(od.option_);
EXPECT_EQ(43, od.option_->getType());
const OptionCollection& oc = od.option_->getOptions();
- ASSERT_EQ(1, oc.size());
+ ASSERT_EQ(1U, oc.size());
OptionPtr opt = od.option_->getOption(1);
ASSERT_TRUE(opt);
- EXPECT_EQ(1, opt->getType());
- ASSERT_EQ(4, opt->getData().size());
+ EXPECT_EQ(1U, opt->getType());
+ ASSERT_EQ(4U, opt->getData().size());
const uint8_t expected[4] = { 0xc0, 0x00, 0x02, 0x00 };
EXPECT_EQ(0, std::memcmp(expected, &opt->getData()[0], 4));
}
auto const& option_data = unparsed->get("option-data");
ASSERT_TRUE(option_data);
ASSERT_EQ(option_data->getType(), Element::list);
- ASSERT_EQ(1, option_data->size());
+ ASSERT_EQ(1U, option_data->size());
auto const& option = option_data->get(0);
ASSERT_TRUE(option);
ASSERT_EQ(option->getType(), Element::map);
// And it should have next-server set, but everything else not set.
EXPECT_EQ(IOAddress("192.0.2.254"), cclass->getNextServer());
- EXPECT_EQ(0, cclass->getSname().size());
- EXPECT_EQ(0, cclass->getFilename().size());
+ EXPECT_EQ(0U, cclass->getSname().size());
+ EXPECT_EQ(0U, cclass->getFilename().size());
EXPECT_TRUE(cclass->getOfferLft().unspecified());
}
ASSERT_TRUE(dictionary);
// We should have three classes in the dictionary.
- EXPECT_EQ(3, dictionary->getClasses()->size());
+ EXPECT_EQ(3U, dictionary->getClasses()->size());
// Make sure we can find all three.
ClientClassDefPtr cclass;
ASSERT_TRUE(dictionary);
// We should have five classes in the dictionary.
- EXPECT_EQ(5, dictionary->getClasses()->size());
+ EXPECT_EQ(5U, dictionary->getClasses()->size());
// Check alpha.
ClientClassDefPtr cclass;
auto offer_lft = cclass->getOfferLft();
ASSERT_FALSE(offer_lft.unspecified());
- EXPECT_EQ(99, offer_lft.get());
+ EXPECT_EQ(99U, offer_lft.get());
}
// Test verifies that the parser rejects bogus offer-lifetime value.
// that we start with no classes defined
const ClientClassDefListPtr classes = dictionary->getClasses();
ASSERT_TRUE(classes);
- EXPECT_EQ(0, classes->size());
+ EXPECT_EQ(0U, classes->size());
EXPECT_TRUE(classes->empty());
// Verify that we can add classes with both addClass variants
ASSERT_THROW(dictionary->addClass(cclass), BadValue);
// Map should show 3 entries.
- EXPECT_EQ(3, classes->size());
+ EXPECT_EQ(3U, classes->size());
EXPECT_FALSE(classes->empty());
// Removing client class by id of 0 should be no-op.
ASSERT_NO_THROW(dictionary->removeClass(0));
- EXPECT_EQ(3, classes->size());
+ EXPECT_EQ(3U, classes->size());
EXPECT_FALSE(classes->empty());
// Verify we can find them all.
// Verify that we can remove a class
ASSERT_NO_THROW(dictionary->removeClass("cc3"));
- EXPECT_EQ(2, classes->size());
+ EXPECT_EQ(2U, classes->size());
EXPECT_FALSE(classes->empty());
// Shouldn't be able to find anymore
// Verify that we can attempt to remove a non-existing class
// without harm.
ASSERT_NO_THROW(dictionary->removeClass("cc3"));
- EXPECT_EQ(2, classes->size());
+ EXPECT_EQ(2U, classes->size());
EXPECT_FALSE(classes->empty());
// Verify that we can remove client class by id.
ASSERT_NO_THROW(dictionary->removeClass(2));
- EXPECT_EQ(1, classes->size());
+ EXPECT_EQ(1U, classes->size());
EXPECT_FALSE(classes->empty());
ASSERT_NO_THROW(cclass = dictionary->findClass("cc2"));
EXPECT_FALSE(cclass);
EXPECT_FALSE(classes[0]->getMatchExpr());
EXPECT_TRUE(classes[1]->getMatchExpr());
- EXPECT_EQ(4, classes[1]->getMatchExpr()->size());
+ EXPECT_EQ(4U, classes[1]->getMatchExpr()->size());
EXPECT_TRUE(classes[2]->getMatchExpr());
- EXPECT_EQ(6, classes[2]->getMatchExpr()->size());
+ EXPECT_EQ(6U, classes[2]->getMatchExpr()->size());
}
// Tests that an error is returned when any of the test expressions is
// that we start with no classes defined
const ClientClassDefListPtr classes = dictionary->getClasses();
ASSERT_TRUE(classes);
- EXPECT_EQ(0, classes->size());
+ EXPECT_EQ(0U, classes->size());
EXPECT_TRUE(classes->empty());
// Verify that we can add classes with both addClass variants
ASSERT_THROW(dictionary->addClass(cclass), BadValue);
// Map should show 3 entries.
- EXPECT_EQ(3, classes->size());
+ EXPECT_EQ(3U, classes->size());
EXPECT_FALSE(classes->empty());
// Removing client class by id of 0 should be no-op.
ASSERT_NO_THROW(dictionary->removeClass(0));
- EXPECT_EQ(3, classes->size());
+ EXPECT_EQ(3U, classes->size());
EXPECT_FALSE(classes->empty());
// Verify we can find them all.
// Verify that we can remove a class
ASSERT_NO_THROW(dictionary->removeClass("cc3"));
- EXPECT_EQ(2, classes->size());
+ EXPECT_EQ(2U, classes->size());
EXPECT_FALSE(classes->empty());
// Shouldn't be able to find anymore
// Verify that we can attempt to remove a non-existing class
// without harm.
ASSERT_NO_THROW(dictionary->removeClass("cc3"));
- EXPECT_EQ(2, classes->size());
+ EXPECT_EQ(2U, classes->size());
EXPECT_FALSE(classes->empty());
// Verify that we can remove client class by id.
ASSERT_NO_THROW(dictionary->removeClass(2));
- EXPECT_EQ(1, classes->size());
+ EXPECT_EQ(1U, classes->size());
EXPECT_FALSE(classes->empty());
ASSERT_NO_THROW(cclass = dictionary->findClass("cc2"));
EXPECT_FALSE(cclass);
EXPECT_FALSE(classes[0]->getMatchExpr());
EXPECT_TRUE(classes[1]->getMatchExpr());
- EXPECT_EQ(1, classes[1]->getMatchExpr()->size());
+ EXPECT_EQ(1U, classes[1]->getMatchExpr()->size());
EXPECT_TRUE(classes[2]->getMatchExpr());
- EXPECT_EQ(3, classes[2]->getMatchExpr()->size());
+ EXPECT_EQ(3U, classes[2]->getMatchExpr()->size());
}
// Tests that an error is returned when any of the test expressions is
HWAddr hwaddr1(*lease->hwaddr_);
EXPECT_EQ("06:07:08:09:0a:bc", hwaddr1.toText(false));
EXPECT_FALSE(lease->client_id_);
- EXPECT_EQ(200, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(8, lease->subnet_id_);
+ EXPECT_EQ(8U, lease->subnet_id_);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_EQ("host.example.com", lease->hostname_);
EXPECT_EQ("dd:de:ba:0d:1b:2e:3e:4f", hwaddr3.toText(false));
ASSERT_TRUE(lease->client_id_);
EXPECT_EQ("0a:00:01:04", lease->client_id_->toText());
- EXPECT_EQ(100, lease->valid_lft_);
+ EXPECT_EQ(100U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(7, lease->subnet_id_);
+ EXPECT_EQ(7U, lease->subnet_id_);
EXPECT_FALSE(lease->fqdn_fwd_);
EXPECT_FALSE(lease->fqdn_rev_);
EXPECT_TRUE(lease->hostname_.empty());
HWAddr hwaddr1(*lease->hwaddr_);
EXPECT_EQ("06:07:08:09:1a:bc", hwaddr1.toText(false));
EXPECT_FALSE(lease->client_id_);
- EXPECT_EQ(200, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(8, lease->subnet_id_);
+ EXPECT_EQ(8U, lease->subnet_id_);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_EQ("one.example.com", lease->hostname_);
HWAddr hwaddr1(*lease->hwaddr_);
EXPECT_EQ("06:07:08:09:2a:bc", hwaddr1.toText(false));
EXPECT_FALSE(lease->client_id_);
- EXPECT_EQ(200, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(8, lease->subnet_id_);
+ EXPECT_EQ(8U, lease->subnet_id_);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_EQ("two.example.com", lease->hostname_);
HWAddr hwaddr1(*lease->hwaddr_);
EXPECT_EQ("06:07:08:09:3a:bc", hwaddr1.toText(false));
EXPECT_FALSE(lease->client_id_);
- EXPECT_EQ(200, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(8, lease->subnet_id_);
+ EXPECT_EQ(8U, lease->subnet_id_);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_EQ("three.example.com", lease->hostname_);
HWAddr hwaddr1(*lease->hwaddr_);
EXPECT_EQ("06:07:08:09:3a:bc", hwaddr1.toText(false));
EXPECT_FALSE(lease->client_id_);
- EXPECT_EQ(200, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(8, lease->subnet_id_);
+ EXPECT_EQ(8U, lease->subnet_id_);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_EQ("three.example.com", lease->hostname_);
SCOPED_TRACE("No hardware and not declined, invalid");
EXPECT_FALSE(lf.next(lease));
ASSERT_FALSE(lease);
- EXPECT_EQ(lf.getReadErrs(),1);
+ EXPECT_EQ(lf.getReadErrs(), 1U);
}
{
SCOPED_TRACE("No hardware and declined, valid");
EXPECT_TRUE(lf.next(lease));
ASSERT_TRUE(lease);
- EXPECT_EQ(lf.getReadErrs(),1);
+ EXPECT_EQ(lf.getReadErrs(), 1U);
}
}
EXPECT_EQ("2001:db8:1::1", lease->addr_.toText());
ASSERT_TRUE(lease->duid_);
EXPECT_EQ("00:01:02:03:04:05:06:0a:0b:0c:0d:0e:0f", lease->duid_->toText());
- EXPECT_EQ(200, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(8, lease->subnet_id_);
- EXPECT_EQ(100, lease->preferred_lft_);
+ EXPECT_EQ(8U, lease->subnet_id_);
+ EXPECT_EQ(100U, lease->preferred_lft_);
EXPECT_EQ(Lease::TYPE_NA, lease->type_);
- EXPECT_EQ(7, lease->iaid_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(7U, lease->iaid_);
+ EXPECT_EQ(128U, lease->prefixlen_);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_EQ("host.example.com", lease->hostname_);
EXPECT_EQ("2001:db8:2::10", lease->addr_.toText());
ASSERT_TRUE(lease->duid_);
EXPECT_EQ("01:01:01:01:0a:01:02:03:04:05", lease->duid_->toText());
- EXPECT_EQ(300, lease->valid_lft_);
+ EXPECT_EQ(300U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(6, lease->subnet_id_);
- EXPECT_EQ(150, lease->preferred_lft_);
+ EXPECT_EQ(6U, lease->subnet_id_);
+ EXPECT_EQ(150U, lease->preferred_lft_);
EXPECT_EQ(Lease::TYPE_NA, lease->type_);
- EXPECT_EQ(8, lease->iaid_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(8U, lease->iaid_);
+ EXPECT_EQ(128U, lease->prefixlen_);
EXPECT_FALSE(lease->fqdn_fwd_);
EXPECT_FALSE(lease->fqdn_rev_);
EXPECT_TRUE(lease->hostname_.empty());
EXPECT_EQ("3000:1::", lease->addr_.toText());
ASSERT_TRUE(lease->duid_);
EXPECT_EQ("00:01:02:03:04:05:06:0a:0b:0c:0d:0e:0f", lease->duid_->toText());
- EXPECT_EQ(0, lease->valid_lft_);
+ EXPECT_EQ(0U, lease->valid_lft_);
EXPECT_EQ(200, lease->cltt_);
- EXPECT_EQ(8, lease->subnet_id_);
- EXPECT_EQ(0, lease->preferred_lft_);
+ EXPECT_EQ(8U, lease->subnet_id_);
+ EXPECT_EQ(0U, lease->preferred_lft_);
EXPECT_EQ(Lease::TYPE_PD, lease->type_);
- EXPECT_EQ(16, lease->iaid_);
- EXPECT_EQ(64, lease->prefixlen_);
+ EXPECT_EQ(16U, lease->iaid_);
+ EXPECT_EQ(64U, lease->prefixlen_);
EXPECT_FALSE(lease->fqdn_fwd_);
EXPECT_FALSE(lease->fqdn_rev_);
EXPECT_TRUE(lease->hostname_.empty());
EXPECT_EQ("2001:db8:1::1", lease->addr_.toText());
ASSERT_TRUE(lease->duid_);
EXPECT_EQ("00:01:02:03:04:05:06:0a:0b:0c:0d:0e:01", lease->duid_->toText());
- EXPECT_EQ(200, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(8, lease->subnet_id_);
- EXPECT_EQ(100, lease->preferred_lft_);
+ EXPECT_EQ(8U, lease->subnet_id_);
+ EXPECT_EQ(100U, lease->preferred_lft_);
EXPECT_EQ(Lease::TYPE_NA, lease->type_);
- EXPECT_EQ(7, lease->iaid_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(7U, lease->iaid_);
+ EXPECT_EQ(128U, lease->prefixlen_);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_EQ("one.example.com", lease->hostname_);
EXPECT_EQ("2001:db8:1::2", lease->addr_.toText());
ASSERT_TRUE(lease->duid_);
EXPECT_EQ("00:01:02:03:04:05:06:0a:0b:0c:0d:0e:02", lease->duid_->toText());
- EXPECT_EQ(200, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(8, lease->subnet_id_);
- EXPECT_EQ(100, lease->preferred_lft_);
+ EXPECT_EQ(8U, lease->subnet_id_);
+ EXPECT_EQ(100U, lease->preferred_lft_);
EXPECT_EQ(Lease::TYPE_NA, lease->type_);
- EXPECT_EQ(7, lease->iaid_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(7U, lease->iaid_);
+ EXPECT_EQ(128U, lease->prefixlen_);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_EQ("two.example.com", lease->hostname_);
EXPECT_EQ("2001:db8:1::3", lease->addr_.toText());
ASSERT_TRUE(lease->duid_);
EXPECT_EQ("00:01:02:03:04:05:06:0a:0b:0c:0d:0e:03", lease->duid_->toText());
- EXPECT_EQ(200, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(8, lease->subnet_id_);
- EXPECT_EQ(100, lease->preferred_lft_);
+ EXPECT_EQ(8U, lease->subnet_id_);
+ EXPECT_EQ(100U, lease->preferred_lft_);
EXPECT_EQ(Lease::TYPE_NA, lease->type_);
- EXPECT_EQ(7, lease->iaid_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(7U, lease->iaid_);
+ EXPECT_EQ(128U, lease->prefixlen_);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_EQ("three.example.com", lease->hostname_);
EXPECT_EQ("2001:db8:1::4", lease->addr_.toText());
ASSERT_TRUE(lease->duid_);
EXPECT_EQ("00:01:02:03:04:05:06:0a:0b:0c:0d:0e:03", lease->duid_->toText());
- EXPECT_EQ(200, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(8, lease->subnet_id_);
- EXPECT_EQ(100, lease->preferred_lft_);
+ EXPECT_EQ(8U, lease->subnet_id_);
+ EXPECT_EQ(100U, lease->preferred_lft_);
EXPECT_EQ(Lease::TYPE_NA, lease->type_);
- EXPECT_EQ(7, lease->iaid_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(7U, lease->iaid_);
+ EXPECT_EQ(128U, lease->prefixlen_);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_EQ("three.example.com", lease->hostname_);
EXPECT_EQ("2001:db8:1::3", lease->addr_.toText());
ASSERT_TRUE(lease->duid_);
EXPECT_EQ("00:01:02:03:04:05:06:0a:0b:0c:0d:0e:03", lease->duid_->toText());
- EXPECT_EQ(200, lease->valid_lft_);
+ EXPECT_EQ(200U, lease->valid_lft_);
EXPECT_EQ(0, lease->cltt_);
- EXPECT_EQ(8, lease->subnet_id_);
- EXPECT_EQ(100, lease->preferred_lft_);
+ EXPECT_EQ(8U, lease->subnet_id_);
+ EXPECT_EQ(100U, lease->preferred_lft_);
EXPECT_EQ(Lease::TYPE_NA, lease->type_);
- EXPECT_EQ(7, lease->iaid_);
- EXPECT_EQ(128, lease->prefixlen_);
+ EXPECT_EQ(7U, lease->iaid_);
+ EXPECT_EQ(128U, lease->prefixlen_);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_EQ("three.example.com", lease->hostname_);
EXPECT_EQ(Lease::STATE_DECLINED, lease->state_);
ASSERT_TRUE(lease->getContext());
EXPECT_EQ("{ \"foobar\": true }", lease->getContext()->str());
- EXPECT_EQ(1, lease->hwaddr_->htype_);
- EXPECT_EQ(0, lease->hwaddr_->source_);
+ EXPECT_EQ(1U, lease->hwaddr_->htype_);
+ EXPECT_EQ(0U, lease->hwaddr_->source_);
}
}
SCOPED_TRACE("\"Empty\" DUID and not declined, invalid");
EXPECT_FALSE(lf.next(lease));
EXPECT_FALSE(lease);
- EXPECT_EQ(lf.getReadErrs(), 1);
+ EXPECT_EQ(lf.getReadErrs(), 1U);
EXPECT_EQ(lf.getReadMsg(),
"The Empty DUID is only valid for declined leases");
}
SCOPED_TRACE("Missing (blank) DUID and not declined, invalid");
EXPECT_FALSE(lf.next(lease));
EXPECT_FALSE(lease);
- EXPECT_EQ(lf.getReadErrs(), 2);
+ EXPECT_EQ(lf.getReadErrs(), 2U);
EXPECT_EQ(lf.getReadMsg(), "identifier is too short (0), at least 3 is required");
}
SCOPED_TRACE("Empty DUID and declined, valid");
EXPECT_TRUE(lf.next(lease));
EXPECT_TRUE(lease);
- EXPECT_EQ(lf.getReadErrs(), 2);
+ EXPECT_EQ(lf.getReadErrs(), 2U);
EXPECT_EQ(lf.getReadMsg(), "validation not started");
}
}
ASSERT_FALSE(handle_->amSending());
// Queue should be empty.
- EXPECT_EQ(0, handle_->getQueueSize());
+ EXPECT_EQ(0U, handle_->getQueueSize());
// Trying to peek past the end of the queue should throw.
EXPECT_THROW(handle_->peekAt(1), dhcp_ddns::NcrSenderError);
ASSERT_NO_THROW(handle_->sendRequest(ncr));
// Queue should have 1 entry.
- EXPECT_EQ(1, handle_->getQueueSize());
+ EXPECT_EQ(1U, handle_->getQueueSize());
// Attempt to fetch the entry we just queued.
dhcp_ddns::NameChangeRequestPtr ncr2;
ASSERT_THROW(handle_->clearQueue(), dhcp_ddns::NcrSenderError);
// We should still have 1 in the queue.
- EXPECT_EQ(1, handle_->getQueueSize());
+ EXPECT_EQ(1U, handle_->getQueueSize());
// Get out of send mode.
ASSERT_NO_THROW(handle_->stopSender());
// Clear queue should succeed now.
ASSERT_NO_THROW(handle_->clearQueue());
- EXPECT_EQ(0, handle_->getQueueSize());
+ EXPECT_EQ(0U, handle_->getQueueSize());
}
/// @brief Checks that D2ClientMgr can send with a UDP sender and
}
// Make sure queue count is correct.
- EXPECT_EQ(3, handle_->getQueueSize());
+ EXPECT_EQ(3U, handle_->getQueueSize());
// select_fd should evaluate to ready to read.
selectCheck(true);
IfaceMgr::instance().receive4(0, 0);
// Verify the callback handler was invoked, no errors counted.
- EXPECT_EQ(2, handle_->getQueueSize());
+ EXPECT_EQ(2U, handle_->getQueueSize());
ASSERT_EQ(1, handle_->callback_count_);
ASSERT_EQ(0, error_handler_count_);
// Stop the sender. This should complete the second message but leave
// the third in the queue.
ASSERT_NO_THROW(handle_->stopSender());
- EXPECT_EQ(1, handle_->getQueueSize());
+ EXPECT_EQ(1U, handle_->getQueueSize());
ASSERT_EQ(2, handle_->callback_count_);
ASSERT_EQ(0, error_handler_count_);
// Calling receive again should have no affect.
IfaceMgr::instance().receive4(0, 0);
- EXPECT_EQ(1, handle_->getQueueSize());
+ EXPECT_EQ(1U, handle_->getQueueSize());
ASSERT_EQ(2, handle_->callback_count_);
ASSERT_EQ(0, error_handler_count_);
}
dhcp_ddns::NameChangeRequestPtr ncr = buildTestNcr();
ASSERT_NO_THROW(handle_->sendRequest(ncr));
}
- ASSERT_EQ(3, handle_->getQueueSize());
+ ASSERT_EQ(3U, handle_->getQueueSize());
// Call the ready handler. This should complete the first message
// and initiate sending the second message.
ASSERT_NO_THROW(handle_->runReadyIO());
// Queue count should have gone down by 1.
- ASSERT_EQ(2, handle_->getQueueSize());
+ ASSERT_EQ(2U, handle_->getQueueSize());
// Suspend updates. This should disable updates and stop the sender.
ASSERT_NO_THROW(handle_->suspendUpdates());
// Stopping the sender should have completed the second message's
// in-progress send, so queue size should be 1.
- ASSERT_EQ(1, handle_->getQueueSize());
+ ASSERT_EQ(1U, handle_->getQueueSize());
}
/// @brief Tests that invokeErrorHandler does not fail if there is no handler.
// Check that the interface is correct.
EXPECT_EQ(concatenate("eth", i % 2), pkt_received->getIface());
- EXPECT_EQ(ETH0_INDEX + i % 2, pkt_received->getIndex());
+ EXPECT_EQ(static_cast<int>(ETH0_INDEX + i % 2),
+ pkt_received->getIndex());
// Check that the address conveyed is correct.
EXPECT_EQ(concatenate("2001:db8:1::", i),
ASSERT_NO_THROW_LOG(parser.parse(pools, config_element));
// Should have two pools.
- ASSERT_EQ(pools->size(), 2);
+ ASSERT_EQ(pools->size(), 2U);
// First pool specifies all but ddns-ttl.
PoolPtr pool = (*pools)[0];
ASSERT_TRUE(pool->getDdnsTtl().unspecified());
ASSERT_FALSE(pool->getDdnsTtlMin().unspecified());
- EXPECT_EQ(pool->getDdnsTtlMin().get(), 200);
+ EXPECT_EQ(pool->getDdnsTtlMin().get(), 200U);
ASSERT_FALSE(pool->getDdnsTtlMax().unspecified());
- EXPECT_EQ(pool->getDdnsTtlMax().get(), 500);
+ EXPECT_EQ(pool->getDdnsTtlMax().get(), 500U);
// Second pool only specifies ddns-ttl.
pool = (*pools)[1];
ASSERT_TRUE(pool->getDdnsTtlMin().unspecified());
ASSERT_FALSE(pool->getDdnsTtl().unspecified());
- EXPECT_EQ(pool->getDdnsTtl().get(), 300);
+ EXPECT_EQ(pool->getDdnsTtl().get(), 300U);
ASSERT_TRUE(pool->getDdnsTtlMax().unspecified());
}
// Finally, check the sources that were configured
CfgMACSources configured_sources = cfg->getMACSources().get();
- ASSERT_EQ(2, configured_sources.size());
+ ASSERT_EQ(2U, configured_sources.size());
EXPECT_EQ(HWAddr::HWADDR_SOURCE_DUID, configured_sources[0]);
EXPECT_EQ(HWAddr::HWADDR_SOURCE_IPV6_LINK_LOCAL, configured_sources[1]);
}
uint8_t exp[] = { DHO_BOOT_FILE_NAME, 23, '\\', 'S', 'M', 'S', 'B', 'o', 'o',
't', '\\', 'x', '6', '4', '\\', 'w', 'd', 's', 'n', 'b',
'p', '.', 'c', 'o', 'm' };
- ASSERT_EQ(25, sizeof(exp));
+ ASSERT_EQ(25U, sizeof(exp));
opt->pack(buf);
EXPECT_EQ(Option::OPTION4_HDR_LEN + 23, buf.getLength());
ipv6_prefix = s46_rule->readPrefix(4);
});
- EXPECT_EQ(1, flags);
- EXPECT_EQ(0, ea_len);
- EXPECT_EQ(24, prefix4_len);
+ EXPECT_EQ(1U, flags);
+ EXPECT_EQ(0U, ea_len);
+ EXPECT_EQ(24U, prefix4_len);
EXPECT_EQ("192.0.2.0", ipv4_prefix.toText());
- EXPECT_EQ(64, ipv6_prefix.first.asUnsigned());
+ EXPECT_EQ(64U, ipv6_prefix.first.asUnsigned());
EXPECT_EQ("2001:db8:1::", ipv6_prefix.second.toText());
ElementPtr expected = Element::fromJSON(config);
ASSERT_EQ(0, rcode);
OptionPtr opt = getOptionPtr(DHCP6_OPTION_SPACE, 25000);
ASSERT_TRUE(opt);
- ASSERT_EQ(1, opt->getData().size());
+ ASSERT_EQ(1U, opt->getData().size());
EXPECT_EQ(0, opt->getData()[0]);
ElementPtr expected = Element::fromJSON(config);
EXPECT_EQ(0, rcode);
opt = getOptionPtr(DHCP6_OPTION_SPACE, 25000);
ASSERT_TRUE(opt);
- ASSERT_EQ(3, opt->getData().size());
+ ASSERT_EQ(3U, opt->getData().size());
EXPECT_EQ(0x12, opt->getData()[0]);
EXPECT_EQ(0x34, opt->getData()[1]);
EXPECT_EQ(0x56, opt->getData()[2]);
Option6AddrLstPtr opt = boost::dynamic_pointer_cast<
Option6AddrLst>(getOptionPtr(DHCP6_OPTION_SPACE, 23));
ASSERT_TRUE(opt);
- ASSERT_EQ(1, opt->getAddresses().size());
+ ASSERT_EQ(1U, opt->getAddresses().size());
EXPECT_EQ( "2001:db8:1::1", opt->getAddresses()[0].toText());
ElementPtr expected = Element::fromJSON(config);
Option6AddrLstPtr opt = boost::dynamic_pointer_cast<
Option6AddrLst>(getOptionPtr(DHCP6_OPTION_SPACE, 23));
ASSERT_TRUE(opt);
- ASSERT_EQ(1, opt->getAddresses().size());
+ ASSERT_EQ(1U, opt->getAddresses().size());
EXPECT_EQ( "2001:db8:1::1", opt->getAddresses()[0].toText());
ElementPtr expected = Element::fromJSON(config);
Option6AddrLstPtr opt = boost::dynamic_pointer_cast<
Option6AddrLst>(getOptionPtr(DHCP6_OPTION_SPACE, 23));
ASSERT_TRUE(opt);
- ASSERT_EQ(1, opt->getAddresses().size());
+ ASSERT_EQ(1U, opt->getAddresses().size());
EXPECT_EQ( "2001:db8:1::10", opt->getAddresses()[0].toText());
ElementPtr expected = Element::fromJSON(config);
opt = boost::dynamic_pointer_cast<Option6AddrLst>(getOptionPtr(DHCP6_OPTION_SPACE,
23));
ASSERT_TRUE(opt);
- ASSERT_EQ(1, opt->getAddresses().size());
+ ASSERT_EQ(1U, opt->getAddresses().size());
EXPECT_EQ( "2001:db8:1::20", opt->getAddresses()[0].toText());
expected = Element::fromJSON(config);
Option6AddrLstPtr opt = boost::dynamic_pointer_cast<
Option6AddrLst>(getOptionPtr(DHCP6_OPTION_SPACE, 2345));
ASSERT_TRUE(opt);
- ASSERT_EQ(2, opt->getAddresses().size());
+ ASSERT_EQ(2U, opt->getAddresses().size());
EXPECT_EQ("2001:db8:1::10", opt->getAddresses()[0].toText());
EXPECT_EQ("2001:db8:1::123", opt->getAddresses()[1].toText());
opt = boost::dynamic_pointer_cast<Option6AddrLst>(getOptionPtr(DHCP6_OPTION_SPACE,
2345));
ASSERT_TRUE(opt);
- ASSERT_EQ(2, opt->getAddresses().size());
+ ASSERT_EQ(2U, opt->getAddresses().size());
EXPECT_EQ("2001:db8:1::10", opt->getAddresses()[0].toText());
EXPECT_EQ("2001:db8:1::123", opt->getAddresses()[1].toText());
const Option6AddrLstPtr opt = boost::dynamic_pointer_cast<
Option6AddrLst>(getOptionPtr(DHCP6_OPTION_SPACE, D6O_DHCPV4_O_DHCPV6_SERVER));
ASSERT_TRUE(opt);
- ASSERT_EQ(0, opt->getAddresses().size());
+ ASSERT_EQ(0U, opt->getAddresses().size());
ElementPtr expected = Element::fromJSON(config);
ElementPtr opt_data = expected->get("option-data")->getNonConst(0);
EXPECT_EQ(0, rcode);
const OptionPtr opt = getOptionPtr(DHCP4_OPTION_SPACE, DHO_VENDOR_ENCAPSULATED_OPTIONS);
ASSERT_TRUE(opt);
- ASSERT_EQ(0, opt->getOptions().size());
+ ASSERT_EQ(0U, opt->getOptions().size());
ElementPtr expected = Element::fromJSON(config);
ElementPtr opt_data = expected->get("option-data")->getNonConst(0);
Option4AddrLstPtr opt = boost::dynamic_pointer_cast<Option4AddrLst>
(getOptionPtr(DHCP4_OPTION_SPACE, 6));
ASSERT_TRUE(opt);
- ASSERT_EQ(2, opt->getAddresses().size());
+ ASSERT_EQ(2U, opt->getAddresses().size());
EXPECT_EQ("12.0.3.1", opt->getAddresses()[0].toText());
EXPECT_EQ("192.0.3.2", opt->getAddresses()[1].toText());
}
// Check that the parser recorded a single library.
isc::hooks::HookLibsCollection libraries = getLibraries();
- ASSERT_EQ(1, libraries.size());
+ ASSERT_EQ(1U, libraries.size());
EXPECT_EQ(CALLOUT_LIBRARY_1, libraries[0].libname_);
EXPECT_EQ("libco1.so", libraries[0].cfgname_);
// Check that the change was propagated to the hooks manager.
hooks_libraries = HooksManager::getLibraryNames();
- ASSERT_EQ(1, hooks_libraries.size());
+ ASSERT_EQ(1U, hooks_libraries.size());
EXPECT_EQ(CALLOUT_LIBRARY_1, hooks_libraries[0]);
}
// Check that the parser recorded two libraries in the expected order.
isc::hooks::HookLibsCollection libraries = getLibraries();
- ASSERT_EQ(2, libraries.size());
+ ASSERT_EQ(2U, libraries.size());
EXPECT_EQ(CALLOUT_LIBRARY_1, libraries[0].libname_);
EXPECT_EQ(CALLOUT_LIBRARY_1, libraries[0].cfgname_);
EXPECT_EQ(CALLOUT_LIBRARY_2, libraries[1].libname_);
// Verify that the change was propagated to the hooks manager.
hooks_libraries = HooksManager::getLibraryNames();
- ASSERT_EQ(2, hooks_libraries.size());
+ ASSERT_EQ(2U, hooks_libraries.size());
EXPECT_EQ(CALLOUT_LIBRARY_1, hooks_libraries[0]);
EXPECT_EQ(CALLOUT_LIBRARY_2, hooks_libraries[1]);
}
CfgMgr::instance().getStagingCfg()->getHooksConfig();
runToElementTest<HooksConfig>(expected, cfg2);
isc::hooks::HookLibsCollection libraries = getLibraries();
- ASSERT_EQ(2, libraries.size());
+ ASSERT_EQ(2U, libraries.size());
EXPECT_EQ(CALLOUT_LIBRARY_1, libraries[0].libname_);
EXPECT_EQ(CALLOUT_LIBRARY_2, libraries[1].libname_);
// ... and check that the same two libraries are still loaded in the
// HooksManager.
hooks_libraries = HooksManager::getLibraryNames();
- ASSERT_EQ(2, hooks_libraries.size());
+ ASSERT_EQ(2U, hooks_libraries.size());
EXPECT_EQ(CALLOUT_LIBRARY_1, hooks_libraries[0]);
EXPECT_EQ(CALLOUT_LIBRARY_2, hooks_libraries[1]);
}
// The list has changed, and this is what we should see.
isc::hooks::HookLibsCollection libraries = getLibraries();
- ASSERT_EQ(2, libraries.size());
+ ASSERT_EQ(2U, libraries.size());
EXPECT_EQ(CALLOUT_LIBRARY_2, libraries[0].libname_);
EXPECT_EQ(CALLOUT_LIBRARY_1, libraries[1].libname_);
// ... and check that this was propagated to the HooksManager.
hooks_libraries = HooksManager::getLibraryNames();
- ASSERT_EQ(2, hooks_libraries.size());
+ ASSERT_EQ(2U, hooks_libraries.size());
EXPECT_EQ(CALLOUT_LIBRARY_2, hooks_libraries[0]);
EXPECT_EQ(CALLOUT_LIBRARY_1, hooks_libraries[1]);
}
// Check that the parser recorded the names but, as they were in error,
// does not flag them as changed.
isc::hooks::HookLibsCollection libraries = getLibraries();
- ASSERT_EQ(3, libraries.size());
+ ASSERT_EQ(3U, libraries.size());
EXPECT_EQ(CALLOUT_LIBRARY_1, libraries[0].libname_);
EXPECT_EQ(NOT_PRESENT_LIBRARY, libraries[1].libname_);
EXPECT_EQ(CALLOUT_LIBRARY_2, libraries[2].libname_);
// Check that the parser recorded the names but, as the library set was
// incorrect, did not mark the configuration as changed.
isc::hooks::HookLibsCollection libraries = getLibraries();
- ASSERT_EQ(3, libraries.size());
+ ASSERT_EQ(3U, libraries.size());
EXPECT_EQ(CALLOUT_LIBRARY_1, libraries[0].libname_);
EXPECT_EQ(NOT_PRESENT_LIBRARY, libraries[1].libname_);
EXPECT_EQ(CALLOUT_LIBRARY_2, libraries[2].libname_);
// names.
hooks_libraries.clear();
hooks_libraries = HooksManager::getLibraryNames();
- ASSERT_EQ(1, hooks_libraries.size());
+ ASSERT_EQ(1U, hooks_libraries.size());
EXPECT_EQ(CALLOUT_LIBRARY_1, hooks_libraries[0]);
}
// Check that the parser recorded the names.
isc::hooks::HookLibsCollection libraries = getLibraries();
- ASSERT_EQ(3, libraries.size());
+ ASSERT_EQ(3U, libraries.size());
EXPECT_EQ(CALLOUT_LIBRARY_1, libraries[0].libname_);
EXPECT_EQ(CALLOUT_LIBRARY_2, libraries[1].libname_);
EXPECT_EQ(CALLOUT_PARAMS_LIBRARY, libraries[2].libname_);
// Verify that the configuration values are as expected.
EXPECT_TRUE(d2_client_config->getEnableUpdates());
EXPECT_EQ("192.0.2.0", d2_client_config->getServerIp().toText());
- EXPECT_EQ(3432, d2_client_config->getServerPort());
+ EXPECT_EQ(3432U, d2_client_config->getServerPort());
EXPECT_EQ(dhcp_ddns::NCR_UDP, d2_client_config->getNcrProtocol());
EXPECT_EQ(dhcp_ddns::FMT_JSON, d2_client_config->getNcrFormat());
ASSERT_TRUE(d2_client_config->getContext());
// Verify that the configuration values are as expected.
EXPECT_FALSE(d2_client_config->getEnableUpdates());
EXPECT_EQ("2001:db8::", d2_client_config->getServerIp().toText());
- EXPECT_EQ(43567, d2_client_config->getServerPort());
+ EXPECT_EQ(43567U, d2_client_config->getServerPort());
EXPECT_EQ(dhcp_ddns::NCR_UDP, d2_client_config->getNcrProtocol());
EXPECT_EQ(dhcp_ddns::FMT_JSON, d2_client_config->getNcrFormat());
ASSERT_TRUE(d2_client_config->getContext());
EXPECT_TRUE(subnet->getClientClasses().empty());
EXPECT_TRUE(subnet->getValid().unspecified());
- EXPECT_EQ(0, subnet->getValid().get());
+ EXPECT_EQ(0U, subnet->getValid().get());
EXPECT_TRUE(subnet->getT1().unspecified());
- EXPECT_EQ(0, subnet->getT1().get());
+ EXPECT_EQ(0U, subnet->getT1().get());
EXPECT_TRUE(subnet->getT2().unspecified());
- EXPECT_EQ(0, subnet->getT2().get());
+ EXPECT_EQ(0U, subnet->getT2().get());
EXPECT_TRUE(subnet->getReservationsGlobal().unspecified());
EXPECT_FALSE(subnet->getReservationsGlobal().get());
EXPECT_TRUE(boost::dynamic_pointer_cast<IterativeAllocator>(allocator));
EXPECT_TRUE(subnet->getOfferLft().unspecified());
- EXPECT_EQ(0, subnet->getOfferLft().get());
+ EXPECT_EQ(0U, subnet->getOfferLft().get());
EXPECT_TRUE(subnet->getCacheMaxAge().unspecified());
- EXPECT_EQ(0, subnet->getCacheMaxAge().get());
+ EXPECT_EQ(0U, subnet->getCacheMaxAge().get());
EXPECT_TRUE(subnet->getCacheThreshold().unspecified());
EXPECT_EQ(0.0, subnet->getCacheThreshold().get());
EXPECT_TRUE(subnet->getClientClasses().empty());
EXPECT_TRUE(subnet->getValid().unspecified());
- EXPECT_EQ(0, subnet->getValid().get());
+ EXPECT_EQ(0U, subnet->getValid().get());
EXPECT_TRUE(subnet->getT1().unspecified());
- EXPECT_EQ(0, subnet->getT1().get());
+ EXPECT_EQ(0U, subnet->getT1().get());
EXPECT_TRUE(subnet->getT2().unspecified());
- EXPECT_EQ(0, subnet->getT2().get());
+ EXPECT_EQ(0U, subnet->getT2().get());
EXPECT_TRUE(subnet->getReservationsGlobal().unspecified());
EXPECT_FALSE(subnet->getReservationsGlobal().get());
EXPECT_EQ(0.0, subnet->getT2Percent().get());
EXPECT_TRUE(subnet->getPreferred().unspecified());
- EXPECT_EQ(0, subnet->getPreferred().get());
+ EXPECT_EQ(0U, subnet->getPreferred().get());
EXPECT_TRUE(subnet->getRapidCommit().unspecified());
EXPECT_FALSE(subnet->getRapidCommit().get());
EXPECT_TRUE(boost::dynamic_pointer_cast<IterativeAllocator>(allocator));
EXPECT_TRUE(subnet->getCacheMaxAge().unspecified());
- EXPECT_EQ(0, subnet->getCacheMaxAge().get());
+ EXPECT_EQ(0U, subnet->getCacheMaxAge().get());
EXPECT_TRUE(subnet->getCacheThreshold().unspecified());
EXPECT_EQ(0.0, subnet->getCacheThreshold().get());
EXPECT_TRUE(network->getClientClasses().empty());
EXPECT_TRUE(network->getValid().unspecified());
- EXPECT_EQ(0, network->getValid().get());
+ EXPECT_EQ(0U, network->getValid().get());
EXPECT_TRUE(network->getT1().unspecified());
- EXPECT_EQ(0, network->getT1().get());
+ EXPECT_EQ(0U, network->getT1().get());
EXPECT_TRUE(network->getT2().unspecified());
- EXPECT_EQ(0, network->getT2().get());
+ EXPECT_EQ(0U, network->getT2().get());
EXPECT_TRUE(network->getReservationsGlobal().unspecified());
EXPECT_FALSE(network->getReservationsGlobal().get());
EXPECT_TRUE(network->getAllocatorType().get().empty());
EXPECT_TRUE(network->getOfferLft().unspecified());
- EXPECT_EQ(0, network->getOfferLft().get());
+ EXPECT_EQ(0U, network->getOfferLft().get());
EXPECT_TRUE(network->getCacheMaxAge().unspecified());
- EXPECT_EQ(0, network->getCacheMaxAge().get());
+ EXPECT_EQ(0U, network->getCacheMaxAge().get());
EXPECT_TRUE(network->getCacheThreshold().unspecified());
EXPECT_EQ(0.0, network->getCacheThreshold().get());
EXPECT_TRUE(network->getClientClasses().empty());
EXPECT_TRUE(network->getValid().unspecified());
- EXPECT_EQ(0, network->getValid().get());
+ EXPECT_EQ(0U, network->getValid().get());
EXPECT_TRUE(network->getT1().unspecified());
- EXPECT_EQ(0, network->getT1().get());
+ EXPECT_EQ(0U, network->getT1().get());
EXPECT_TRUE(network->getT2().unspecified());
- EXPECT_EQ(0, network->getT2().get());
+ EXPECT_EQ(0U, network->getT2().get());
EXPECT_TRUE(network->getReservationsGlobal().unspecified());
EXPECT_FALSE(network->getReservationsGlobal().get());
EXPECT_EQ(0.0, network->getT2Percent().get());
EXPECT_TRUE(network->getPreferred().unspecified());
- EXPECT_EQ(0, network->getPreferred().get());
+ EXPECT_EQ(0U, network->getPreferred().get());
EXPECT_TRUE(network->getRapidCommit().unspecified());
EXPECT_FALSE(network->getRapidCommit().get());
EXPECT_TRUE(network->getPdAllocatorType().get().empty());
EXPECT_TRUE(network->getCacheMaxAge().unspecified());
- EXPECT_EQ(0, network->getCacheMaxAge().get());
+ EXPECT_EQ(0U, network->getCacheMaxAge().get());
EXPECT_TRUE(network->getCacheThreshold().unspecified());
EXPECT_EQ(0.0, network->getCacheThreshold().get());
ASSERT_TRUE(subnet);
EXPECT_FALSE(subnet->getOfferLft().unspecified());
- EXPECT_EQ(888, subnet->getOfferLft().get());
+ EXPECT_EQ(888U, subnet->getOfferLft().get());
}
// This test verifies parsing invalid offer-lifetime for Subnet4.
ASSERT_TRUE(subnet);
const auto cclasses = subnet->getAdditionalClasses();
- EXPECT_EQ(cclasses.size(), 2);
+ EXPECT_EQ(cclasses.size(), 2U);
auto cclass = cclasses.begin();
EXPECT_EQ(*cclass, "one");
++cclass;
ASSERT_TRUE(subnet);
const auto cclasses = subnet->getAdditionalClasses();
- EXPECT_EQ(cclasses.size(), 2);
+ EXPECT_EQ(cclasses.size(), 2U);
auto cclass = cclasses.begin();
EXPECT_EQ(*cclass, "one");
++cclass;
PoolStoragePtr pools(new PoolStorage());
ASSERT_NO_THROW(parser.parse(pools, config_element, AF_INET));
- EXPECT_EQ(1, pools->size());
+ EXPECT_EQ(1U, pools->size());
const auto cclasses = (*pools)[0]->getAdditionalClasses();
- EXPECT_EQ(cclasses.size(), 2);
+ EXPECT_EQ(cclasses.size(), 2U);
auto cclass = cclasses.begin();
EXPECT_EQ(*cclass, "one");
++cclass;
PoolStoragePtr pools(new PoolStorage());
ASSERT_NO_THROW(parser.parse(pools, config_element, AF_INET6, Lease::TYPE_NA));
- EXPECT_EQ(1, pools->size());
+ EXPECT_EQ(1U, pools->size());
const auto cclasses = (*pools)[0]->getAdditionalClasses();
- EXPECT_EQ(cclasses.size(), 2);
+ EXPECT_EQ(cclasses.size(), 2U);
auto cclass = cclasses.begin();
EXPECT_EQ(*cclass, "one");
++cclass;
ASSERT_NO_THROW(subnet = parser.parse(config_element));
ASSERT_TRUE(subnet);
- EXPECT_EQ(subnet->getClientClasses().size(), 0);
+ EXPECT_EQ(subnet->getClientClasses().size(), 0U);
// Valid entry.
config =
ASSERT_TRUE(subnet);
const auto cclasses = subnet->getClientClasses();
- EXPECT_EQ(cclasses.size(), 1);
+ EXPECT_EQ(cclasses.size(), 1U);
auto cclass = cclasses.begin();
EXPECT_EQ(*cclass, "one");
ASSERT_NO_THROW(subnet = parser.parse(config_element));
ASSERT_TRUE(subnet);
- EXPECT_EQ(subnet->getClientClasses().size(), 0);
+ EXPECT_EQ(subnet->getClientClasses().size(), 0U);
// Valid entry.
config =
ASSERT_TRUE(subnet);
const auto cclasses = subnet->getClientClasses();
- EXPECT_EQ(cclasses.size(), 1);
+ EXPECT_EQ(cclasses.size(), 1U);
auto cclass = cclasses.begin();
EXPECT_EQ(*cclass, "one");
PoolStoragePtr pools(new PoolStorage());
ASSERT_NO_THROW(parser.parse(pools, config_element, AF_INET));
- EXPECT_EQ(1, pools->size());
+ EXPECT_EQ(1U, pools->size());
const auto cclasses = (*pools)[0]->getClientClasses();
- EXPECT_EQ(cclasses.size(), 1);
+ EXPECT_EQ(cclasses.size(), 1U);
auto cclass = cclasses.begin();
EXPECT_EQ(*cclass, "one");
PoolStoragePtr pools(new PoolStorage());
ASSERT_NO_THROW(parser.parse(pools, config_element, AF_INET6, Lease::TYPE_NA));
- EXPECT_EQ(1, pools->size());
+ EXPECT_EQ(1U, pools->size());
const auto cclasses = (*pools)[0]->getClientClasses();
- EXPECT_EQ(cclasses.size(), 1);
+ EXPECT_EQ(cclasses.size(), 1U);
auto cclass = cclasses.begin();
EXPECT_EQ(*cclass, "one");
ASSERT_TRUE(cfg_duid_);
EXPECT_EQ(duid_type, cfg_duid_->getType());
EXPECT_TRUE(cfg_duid_->getIdentifier().empty());
- EXPECT_EQ(0, cfg_duid_->getHType());
- EXPECT_EQ(0, cfg_duid_->getTime());
- EXPECT_EQ(0, cfg_duid_->getEnterpriseId());
+ EXPECT_EQ(0U, cfg_duid_->getHType());
+ EXPECT_EQ(0U, cfg_duid_->getTime());
+ EXPECT_EQ(0U, cfg_duid_->getEnterpriseId());
}
void
ASSERT_TRUE(cfg_duid_);
EXPECT_EQ(DUID::DUID_EN, cfg_duid_->getType());
EXPECT_EQ("ABCDEF", toString(cfg_duid_->getIdentifier()));
- EXPECT_EQ(8, cfg_duid_->getHType());
- EXPECT_EQ(100, cfg_duid_->getTime());
- EXPECT_EQ(2024, cfg_duid_->getEnterpriseId());
+ EXPECT_EQ(8U, cfg_duid_->getHType());
+ EXPECT_EQ(100U, cfg_duid_->getTime());
+ EXPECT_EQ(2024U, cfg_duid_->getEnterpriseId());
EXPECT_FALSE(cfg_duid_->persist());
// Check the config can be got back.
CfgExpirationPtr cfg;
ASSERT_NO_THROW(cfg = renderConfig());
- EXPECT_EQ(20, cfg->getReclaimTimerWaitTime());
- EXPECT_EQ(35, cfg->getFlushReclaimedTimerWaitTime());
- EXPECT_EQ(1800, cfg->getHoldReclaimedTime());
- EXPECT_EQ(50, cfg->getMaxReclaimLeases());
- EXPECT_EQ(100, cfg->getMaxReclaimTime());
- EXPECT_EQ(10, cfg->getUnwarnedReclaimCycles());
+ EXPECT_EQ(20U, cfg->getReclaimTimerWaitTime());
+ EXPECT_EQ(35U, cfg->getFlushReclaimedTimerWaitTime());
+ EXPECT_EQ(1800U, cfg->getHoldReclaimedTime());
+ EXPECT_EQ(50U, cfg->getMaxReclaimLeases());
+ EXPECT_EQ(100U, cfg->getMaxReclaimTime());
+ EXPECT_EQ(10U, cfg->getUnwarnedReclaimCycles());
}
// This test verifies that default values are used if no parameter is
CfgExpirationPtr cfg;
ASSERT_NO_THROW(cfg = renderConfig());
- EXPECT_EQ(15, cfg->getReclaimTimerWaitTime());
+ EXPECT_EQ(15U, cfg->getReclaimTimerWaitTime());
EXPECT_EQ(CfgExpiration::DEFAULT_FLUSH_RECLAIMED_TIMER_WAIT_TIME,
cfg->getFlushReclaimedTimerWaitTime());
- EXPECT_EQ(2000, cfg->getHoldReclaimedTime());
+ EXPECT_EQ(2000U, cfg->getHoldReclaimedTime());
EXPECT_EQ(CfgExpiration::DEFAULT_MAX_RECLAIM_LEASES,
cfg->getMaxReclaimLeases());
- EXPECT_EQ(200, cfg->getMaxReclaimTime());
+ EXPECT_EQ(200U, cfg->getMaxReclaimTime());
EXPECT_EQ(CfgExpiration::DEFAULT_UNWARNED_RECLAIM_CYCLES,
cfg->getUnwarnedReclaimCycles());
}
EXPECT_EQ(CfgExpiration::DEFAULT_RECLAIM_TIMER_WAIT_TIME,
cfg->getReclaimTimerWaitTime());
- EXPECT_EQ(50, cfg->getFlushReclaimedTimerWaitTime());
+ EXPECT_EQ(50U, cfg->getFlushReclaimedTimerWaitTime());
EXPECT_EQ(CfgExpiration::DEFAULT_HOLD_RECLAIMED_TIME,
cfg->getHoldReclaimedTime());
- EXPECT_EQ(60, cfg->getMaxReclaimLeases());
+ EXPECT_EQ(60U, cfg->getMaxReclaimLeases());
EXPECT_EQ(CfgExpiration::DEFAULT_MAX_RECLAIM_TIME,
cfg->getMaxReclaimTime());
- EXPECT_EQ(20, cfg->getUnwarnedReclaimCycles());
+ EXPECT_EQ(20U, cfg->getUnwarnedReclaimCycles());
}
// This test verifies that negative parameter values are not allowed.
auto state = PoolFreeLeaseQueueAllocationState::create(pool);
ASSERT_TRUE(state);
// A new state lacks free leases until we add them.
- EXPECT_EQ(0, state->getFreeLeaseCount());
+ EXPECT_EQ(0U, state->getFreeLeaseCount());
// Add the first free lease. The pool should now have one free lease
// that is always offered.
EXPECT_FALSE(state->isFreeLease(IOAddress("192.0.2.1")));
state->addFreeLease(IOAddress("192.0.2.1"));
EXPECT_FALSE(state->exhausted());
- EXPECT_EQ(1, state->getFreeLeaseCount());
+ EXPECT_EQ(1U, state->getFreeLeaseCount());
EXPECT_TRUE(state->isFreeLease(IOAddress("192.0.2.1")));
// The same lease is always offered.
EXPECT_EQ("192.0.2.1", state->offerFreeLease().toText());
// Add another free lease. We should now have two free leases.
state->addFreeLease(IOAddress("192.0.2.3"));
EXPECT_FALSE(state->exhausted());
- EXPECT_EQ(2, state->getFreeLeaseCount());
+ EXPECT_EQ(2U, state->getFreeLeaseCount());
// The new free lease is appended at the end of the queue. Thus, our
// first lease should be offered now.
EXPECT_EQ("192.0.2.1", state->offerFreeLease().toText());
EXPECT_FALSE(state->isFreeLease(IOAddress("192.0.2.2")));
state->deleteFreeLease(IOAddress("192.0.2.2"));
EXPECT_FALSE(state->exhausted());
- EXPECT_EQ(2, state->getFreeLeaseCount());
+ EXPECT_EQ(2U, state->getFreeLeaseCount());
EXPECT_EQ("192.0.2.1", state->offerFreeLease().toText());
EXPECT_EQ("192.0.2.3", state->offerFreeLease().toText());
// Delete one of the free leases.
state->deleteFreeLease(IOAddress("192.0.2.1"));
EXPECT_FALSE(state->exhausted());
- EXPECT_EQ(1, state->getFreeLeaseCount());
+ EXPECT_EQ(1U, state->getFreeLeaseCount());
// The sole lease should be now offered.
EXPECT_EQ("192.0.2.3", state->offerFreeLease().toText());
EXPECT_EQ("192.0.2.3", state->offerFreeLease().toText());
auto pool = boost::make_shared<Pool4>(IOAddress("192.0.2.1"), IOAddress("192.0.2.10"));
auto state = PoolFreeLeaseQueueAllocationState::create(pool);
ASSERT_TRUE(state);
- EXPECT_EQ(0, state->getFreeLeaseCount());
+ EXPECT_EQ(0U, state->getFreeLeaseCount());
// Add the free lease for the first time.
state->addFreeLease(IOAddress("192.0.2.1"));
EXPECT_FALSE(state->exhausted());
EXPECT_EQ("192.0.2.1", state->offerFreeLease().toText());
- EXPECT_EQ(1, state->getFreeLeaseCount());
+ EXPECT_EQ(1U, state->getFreeLeaseCount());
// Add the same lease the second time. The second lease instance should
// not be inserted.
state->addFreeLease(IOAddress("192.0.2.1"));
EXPECT_FALSE(state->exhausted());
EXPECT_EQ("192.0.2.1", state->offerFreeLease().toText());
- EXPECT_EQ(1, state->getFreeLeaseCount());
+ EXPECT_EQ(1U, state->getFreeLeaseCount());
// Delete the sole lease and ensure there are no more leases.
state->deleteFreeLease(IOAddress("192.0.2.1"));
EXPECT_TRUE(state->exhausted());
- EXPECT_EQ(0, state->getFreeLeaseCount());
+ EXPECT_EQ(0U, state->getFreeLeaseCount());
}
auto state = PoolFreeLeaseQueueAllocationState::create(pool);
ASSERT_TRUE(state);
// A new state lacks free leases until we add them.
- EXPECT_EQ(0, state->getFreeLeaseCount());
+ EXPECT_EQ(0U, state->getFreeLeaseCount());
// Add the first free lease. The pool should now have one free lease
// that is always offered.
EXPECT_FALSE(state->isFreeLease(IOAddress("2001:db8:1::1")));
state->addFreeLease(IOAddress("2001:db8:1::1"));
EXPECT_FALSE(state->exhausted());
- EXPECT_EQ(1, state->getFreeLeaseCount());
+ EXPECT_EQ(1U, state->getFreeLeaseCount());
EXPECT_TRUE(state->isFreeLease(IOAddress("2001:db8:1::1")));
// The same lease is always offered.
EXPECT_EQ("2001:db8:1::1", state->offerFreeLease().toText());
// Add another free lease. We should now have two free leases.
state->addFreeLease(IOAddress("2001:db8:1::3"));
EXPECT_FALSE(state->exhausted());
- EXPECT_EQ(2, state->getFreeLeaseCount());
+ EXPECT_EQ(2U, state->getFreeLeaseCount());
// The new free lease is appended at the end of the queue. Thus, our
// first lease should be offered now.
EXPECT_EQ("2001:db8:1::1", state->offerFreeLease().toText());
EXPECT_FALSE(state->isFreeLease(IOAddress("2001:db8:1::2")));
state->deleteFreeLease(IOAddress("2001:db8:1::2"));
EXPECT_FALSE(state->exhausted());
- EXPECT_EQ(2, state->getFreeLeaseCount());
+ EXPECT_EQ(2U, state->getFreeLeaseCount());
EXPECT_EQ("2001:db8:1::1", state->offerFreeLease().toText());
EXPECT_EQ("2001:db8:1::3", state->offerFreeLease().toText());
// Delete one of the free leases.
state->deleteFreeLease(IOAddress("2001:db8:1::1"));
EXPECT_FALSE(state->exhausted());
- EXPECT_EQ(1, state->getFreeLeaseCount());
+ EXPECT_EQ(1U, state->getFreeLeaseCount());
// The sole lease should be now offered.
EXPECT_EQ("2001:db8:1::3", state->offerFreeLease().toText());
EXPECT_EQ("2001:db8:1::3", state->offerFreeLease().toText());
IOAddress("2001:db8:1::10"));
auto state = PoolFreeLeaseQueueAllocationState::create(pool);
ASSERT_TRUE(state);
- EXPECT_EQ(0, state->getFreeLeaseCount());
+ EXPECT_EQ(0U, state->getFreeLeaseCount());
// Add the free lease for the first time.
state->addFreeLease(IOAddress("2001:db8:1::5"));
EXPECT_FALSE(state->exhausted());
EXPECT_EQ("2001:db8:1::5", state->offerFreeLease().toText());
- EXPECT_EQ(1, state->getFreeLeaseCount());
+ EXPECT_EQ(1U, state->getFreeLeaseCount());
// Add the same lease the second time. The second lease instance should
// not be inserted.
state->addFreeLease(IOAddress("2001:db8:1::5"));
EXPECT_FALSE(state->exhausted());
EXPECT_EQ("2001:db8:1::5", state->offerFreeLease().toText());
- EXPECT_EQ(1, state->getFreeLeaseCount());
+ EXPECT_EQ(1U, state->getFreeLeaseCount());
// Delete the sole lease and ensure there are no more leases.
state->deleteFreeLease(IOAddress("2001:db8:1::5"));
auto state = PoolFreeLeaseQueueAllocationState::create(pool);
ASSERT_TRUE(state);
// A new state lacks free leases until we add them.
- EXPECT_EQ(0, state->getFreeLeaseCount());
+ EXPECT_EQ(0U, state->getFreeLeaseCount());
// Add the first free lease. The pool should now have one free lease
// that is always offered.
EXPECT_FALSE(state->isFreeLease(IOAddress("3000::5600")));
state->addFreeLease(IOAddress("3000::5600"));
EXPECT_FALSE(state->exhausted());
- EXPECT_EQ(1, state->getFreeLeaseCount());
+ EXPECT_EQ(1U, state->getFreeLeaseCount());
EXPECT_TRUE(state->isFreeLease(IOAddress("3000::5600")));
// The same lease is always offered.
EXPECT_EQ("3000::5600", state->offerFreeLease().toText());
// Add another free lease. We should now have two free leases.
state->addFreeLease(IOAddress("3000::7800"));
EXPECT_FALSE(state->exhausted());
- EXPECT_EQ(2, state->getFreeLeaseCount());
+ EXPECT_EQ(2U, state->getFreeLeaseCount());
// The new free lease is appended at the end of the queue. Thus, our
// first lease should be offered now.
EXPECT_EQ("3000::5600", state->offerFreeLease().toText());
EXPECT_FALSE(state->isFreeLease(IOAddress("3000::6400")));
state->deleteFreeLease(IOAddress("3000::6400"));
EXPECT_FALSE(state->exhausted());
- EXPECT_EQ(2, state->getFreeLeaseCount());
+ EXPECT_EQ(2U, state->getFreeLeaseCount());
EXPECT_EQ("3000::5600", state->offerFreeLease().toText());
EXPECT_EQ("3000::7800", state->offerFreeLease().toText());
// Delete one of the free leases.
state->deleteFreeLease(IOAddress("3000::5600"));
EXPECT_FALSE(state->exhausted());
- EXPECT_EQ(1, state->getFreeLeaseCount());
+ EXPECT_EQ(1U, state->getFreeLeaseCount());
// The sole lease should be now offered.
EXPECT_EQ("3000::7800", state->offerFreeLease().toText());
EXPECT_EQ("3000::7800", state->offerFreeLease().toText());
auto pool = boost::make_shared<Pool6>(Lease::TYPE_PD, IOAddress("3000::"), 112, 120);
auto state = PoolFreeLeaseQueueAllocationState::create(pool);
ASSERT_TRUE(state);
- EXPECT_EQ(0, state->getFreeLeaseCount());
+ EXPECT_EQ(0U, state->getFreeLeaseCount());
// Add the free lease for the first time.
state->addFreeLease(IOAddress("3000::5600"));
EXPECT_FALSE(state->exhausted());
EXPECT_EQ("3000::5600", state->offerFreeLease().toText());
- EXPECT_EQ(1, state->getFreeLeaseCount());
+ EXPECT_EQ(1U, state->getFreeLeaseCount());
// Add the same lease the second time. The second lease instance should
// not be inserted.
state->addFreeLease(IOAddress("3000::5600"));
EXPECT_FALSE(state->exhausted());
EXPECT_EQ("3000::5600", state->offerFreeLease().toText());
- EXPECT_EQ(1, state->getFreeLeaseCount());
+ EXPECT_EQ(1U, state->getFreeLeaseCount());
// Delete the sole lease and ensure there are no more leases.
state->deleteFreeLease(IOAddress("3000::5600"));
ASSERT_FALSE(lease.isV4Zero());
addresses.insert(lease);
}
- ASSERT_EQ(5, addresses.size());
- EXPECT_EQ(1, addresses.count(IOAddress("192.0.2.101")));
- EXPECT_EQ(1, addresses.count(IOAddress("192.0.2.103")));
- EXPECT_EQ(1, addresses.count(IOAddress("192.0.2.105")));
- EXPECT_EQ(1, addresses.count(IOAddress("192.0.2.107")));
- EXPECT_EQ(1, addresses.count(IOAddress("192.0.2.109")));
+ ASSERT_EQ(5U, addresses.size());
+ EXPECT_EQ(1U, addresses.count(IOAddress("192.0.2.101")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("192.0.2.103")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("192.0.2.105")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("192.0.2.107")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("192.0.2.109")));
}
// Test allocating IPv4 addresses when a subnet has a single pool.
EXPECT_TRUE(subnet_->inPool(Lease::TYPE_V4, candidate, cc_));
}
// The pool comprises 10 addresses. All should be returned.
- EXPECT_EQ(10, addresses.size());
+ EXPECT_EQ(10U, addresses.size());
}
// Test allocating IPv4 addresses and re-allocating these that are
EXPECT_TRUE(lease_mgr.addLease(lease));
}
// The pool comprises 10 addresses. All should be returned.
- EXPECT_EQ(10, leases.size());
+ EXPECT_EQ(10U, leases.size());
IOAddress candidate = alloc.pickAddress(cc_, clientid_, IOAddress("0.0.0.0"));
EXPECT_TRUE(candidate.isV4Zero());
EXPECT_TRUE(lease_mgr.addLease(lease));
}
// The pool comprises 10 addresses. All should be returned.
- EXPECT_EQ(10, leases.size());
+ EXPECT_EQ(10U, leases.size());
IOAddress candidate = alloc.pickAddress(cc_, clientid_, IOAddress("0.0.0.0"));
EXPECT_TRUE(candidate.isV4Zero());
}
// There are ten pools with 10 addresses each.
- int total = 100;
+ size_t total = 100;
ASSERT_NO_THROW(alloc.initAfterConfigure());
// Pick random addresses the number of times equal to the
// subnet capacity to ensure that all addresses are returned.
- for (auto i = 0; i < total; ++i) {
+ for (size_t i = 0; i < total; ++i) {
IOAddress candidate = alloc.pickAddress(cc_, clientid_, IOAddress("0.0.0.0"));
addresses_set.insert(candidate);
addresses_vector.push_back(candidate);
addresses_set.insert(candidate);
EXPECT_TRUE(pool1->inRange(candidate) || pool3->inRange(candidate));
}
- EXPECT_EQ(20, addresses_set.size());
+ EXPECT_EQ(20U, addresses_set.size());
r = alloc.getOccupancyRate(IOAddress("192.0.2.120"), cc_);
EXPECT_EQ(1., r);
EXPECT_TRUE(lease_mgr.addLease(createLease4(candidate, i+100)));
EXPECT_TRUE(subnet_->inRange(candidate));
}
- EXPECT_EQ(20, addresses_set.size());
+ EXPECT_EQ(20U, addresses_set.size());
r = alloc.getOccupancyRate(IOAddress("192.0.2.100"), cc_);
EXPECT_EQ(1., r);
ASSERT_FALSE(lease.isV6Zero());
addresses.insert(lease);
}
- ASSERT_EQ(12, addresses.size());
- EXPECT_EQ(1, addresses.count(IOAddress("2001:db8:1::11")));
- EXPECT_EQ(1, addresses.count(IOAddress("2001:db8:1::13")));
- EXPECT_EQ(1, addresses.count(IOAddress("2001:db8:1::15")));
- EXPECT_EQ(1, addresses.count(IOAddress("2001:db8:1::17")));
- EXPECT_EQ(1, addresses.count(IOAddress("2001:db8:1::19")));
- EXPECT_EQ(1, addresses.count(IOAddress("2001:db8:1::1a")));
- EXPECT_EQ(1, addresses.count(IOAddress("2001:db8:1::1b")));
- EXPECT_EQ(1, addresses.count(IOAddress("2001:db8:1::1c")));
- EXPECT_EQ(1, addresses.count(IOAddress("2001:db8:1::1d")));
- EXPECT_EQ(1, addresses.count(IOAddress("2001:db8:1::1e")));
- EXPECT_EQ(1, addresses.count(IOAddress("2001:db8:1::1f")));
- EXPECT_EQ(1, addresses.count(IOAddress("2001:db8:1::20")));
+ ASSERT_EQ(12U, addresses.size());
+ EXPECT_EQ(1U, addresses.count(IOAddress("2001:db8:1::11")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("2001:db8:1::13")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("2001:db8:1::15")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("2001:db8:1::17")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("2001:db8:1::19")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("2001:db8:1::1a")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("2001:db8:1::1b")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("2001:db8:1::1c")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("2001:db8:1::1d")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("2001:db8:1::1e")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("2001:db8:1::1f")));
+ EXPECT_EQ(1U, addresses.count(IOAddress("2001:db8:1::20")));
}
// Test allocating IPv6 addresses when a subnet has a single pool.
EXPECT_TRUE(subnet_->inPool(Lease::TYPE_NA, candidate, cc_));
}
// The pool comprises 17 addresses. All should be returned.
- EXPECT_EQ(17, addresses.size());
+ EXPECT_EQ(17U, addresses.size());
}
// Test allocating IPv6 addresses and re-allocating these that are
EXPECT_TRUE(lease_mgr.addLease(lease));
}
// The pool comprises 17 addresses. All should be returned.
- EXPECT_EQ(17, leases.size());
+ EXPECT_EQ(17U, leases.size());
IOAddress candidate = alloc.pickAddress(cc_, duid_, IOAddress("::"));
EXPECT_TRUE(candidate.isV6Zero());
EXPECT_TRUE(lease_mgr.addLease(lease));
}
// The pool comprises 17 addresses. All should be returned.
- EXPECT_EQ(17, leases.size());
+ EXPECT_EQ(17U, leases.size());
IOAddress candidate = alloc.pickAddress(cc_, duid_, IOAddress("::"));
EXPECT_TRUE(candidate.isV6Zero());
// First pool (::10 - ::20) has 17 addresses.
// There are 8 extra pools with 16 addresses in each.
- int total = 17 + 8 * 16;
+ size_t total = 17 + 8 * 16;
ASSERT_NO_THROW(alloc.initAfterConfigure());
// Pick random addresses the number of times equal to the
// subnet capacity to ensure that all addresses are returned.
- for (auto i = 0; i < total; ++i) {
+ for (size_t i = 0; i < total; ++i) {
IOAddress candidate = alloc.pickAddress(cc_, duid_, IOAddress("::"));
addresses_set.insert(candidate);
addresses_vector.push_back(candidate);
addresses_set.insert(candidate);
EXPECT_TRUE(pool1->inRange(candidate) || pool3->inRange(candidate));
}
- EXPECT_EQ(20, addresses_set.size());
+ EXPECT_EQ(20U, addresses_set.size());
// Simulate the case that the client also belongs to the class foo.
// All pools should now be available.
EXPECT_TRUE(lease_mgr.addLease(createLease6(Lease::TYPE_NA, candidate, i+100)));
EXPECT_TRUE(subnet_->inRange(candidate));
}
- EXPECT_EQ(47, addresses_set.size());
+ EXPECT_EQ(47U, addresses_set.size());
}
// Test populating free DHCPv6 prefix leases to the queue.
ASSERT_FALSE(lease.isV6Zero());
addresses.insert(lease);
}
- ASSERT_EQ(251, addresses.size());
- EXPECT_EQ(0, addresses.count(IOAddress("2001:db8:2::")));
- EXPECT_EQ(0, addresses.count(IOAddress("2001:db8:2::1000")));
- EXPECT_EQ(0, addresses.count(IOAddress("2001:db8:2::2000")));
- EXPECT_EQ(0, addresses.count(IOAddress("2001:db8:2::3000")));
- EXPECT_EQ(0, addresses.count(IOAddress("2001:db8:2::4000")));
+ ASSERT_EQ(251U, addresses.size());
+ EXPECT_EQ(0U, addresses.count(IOAddress("2001:db8:2::")));
+ EXPECT_EQ(0U, addresses.count(IOAddress("2001:db8:2::1000")));
+ EXPECT_EQ(0U, addresses.count(IOAddress("2001:db8:2::2000")));
+ EXPECT_EQ(0U, addresses.count(IOAddress("2001:db8:2::3000")));
+ EXPECT_EQ(0U, addresses.count(IOAddress("2001:db8:2::4000")));
}
// Test allocating delegated prefixes when a subnet has a single pool.
EXPECT_TRUE(subnet_->inPool(Lease::TYPE_PD, candidate, cc_));
}
// The pool comprises 65536 prefixes. All should be returned.
- EXPECT_EQ(65536, prefixes.size());
+ EXPECT_EQ(65536U, prefixes.size());
double r = alloc.getOccupancyRate(IOAddress("2001:db8:1:2::"), 128, cc_);
EXPECT_EQ(1., r);
EXPECT_TRUE(lease_mgr.addLease(lease));
}
// The pool comprises 256 delegated prefixes. All should be returned.
- EXPECT_EQ(256, leases.size());
+ EXPECT_EQ(256U, leases.size());
IOAddress candidate = alloc.pickPrefix(cc_, pool, duid_, Allocator::PREFIX_LEN_HIGHER, IOAddress("::"), 0);
EXPECT_TRUE(candidate.isV6Zero());
EXPECT_TRUE(lease_mgr.addLease(lease));
}
// The pool comprises 256 delegated prefixes. All should be returned.
- EXPECT_EQ(256, leases.size());
+ EXPECT_EQ(256U, leases.size());
IOAddress candidate = alloc.pickPrefix(cc_, pool, duid_, Allocator::PREFIX_LEN_HIGHER, IOAddress("::"), 0);
EXPECT_TRUE(candidate.isV6Zero());
// Check we have what we need.
ASSERT_TRUE(hcptr_);
EXPECT_TRUE(HostMgr::checkCacheBackend());
- EXPECT_EQ(0, hcptr_->size());
- EXPECT_EQ(0, hcptr_->inserts_);
+ EXPECT_EQ(0U, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->inserts_);
ASSERT_TRUE(memptr_);
// Create a host reservation.
HostDataSourceUtils::compareHosts(got, host);
// Verify it was cached.
- EXPECT_EQ(1, hcptr_->size());
- EXPECT_EQ(1, hcptr_->inserts_);
+ EXPECT_EQ(1U, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->inserts_);
// Remove it from test host data source.
EXPECT_TRUE(memptr_->del(host->getIPv4SubnetID(), address));
HostDataSourceUtils::compareHosts(got, host);
// Verify cache status.
- EXPECT_EQ(1, hcptr_->size());
- EXPECT_EQ(1, hcptr_->inserts_);
+ EXPECT_EQ(1U, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->inserts_);
}
// Check basic cache feature for IPv6.
// Check we have what we need.
ASSERT_TRUE(hcptr_);
EXPECT_TRUE(HostMgr::checkCacheBackend());
- EXPECT_EQ(0, hcptr_->size());
- EXPECT_EQ(0, hcptr_->inserts_);
+ EXPECT_EQ(0U, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->inserts_);
ASSERT_TRUE(memptr_);
// Create a host reservation.
HostDataSourceUtils::compareHosts(got, host);
// Verify it was cached.
- EXPECT_EQ(1, hcptr_->size());
- EXPECT_EQ(1, hcptr_->inserts_);
+ EXPECT_EQ(1U, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->inserts_);
// Remove it from test host data source.
EXPECT_TRUE(memptr_->del(host->getIPv6SubnetID(), address));
HostDataSourceUtils::compareHosts(got, host);
// Verify cache status.
- EXPECT_EQ(1, hcptr_->size());
- EXPECT_EQ(1, hcptr_->inserts_);
+ EXPECT_EQ(1U, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->inserts_);
}
// Check by address caching for IPv4.
// Check we have what we need.
ASSERT_TRUE(hcptr_);
EXPECT_TRUE(HostMgr::checkCacheBackend());
- EXPECT_EQ(0, hcptr_->size());
- EXPECT_EQ(0, hcptr_->inserts_);
+ EXPECT_EQ(0U, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->inserts_);
ASSERT_TRUE(memptr_);
// Create a host reservation.
HostDataSourceUtils::compareHosts(got, host);
// Verify it was cached.
- EXPECT_EQ(1, hcptr_->size());
- EXPECT_EQ(1, hcptr_->inserts_);
+ EXPECT_EQ(1U, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->inserts_);
// Remove it from test host data source.
EXPECT_TRUE(memptr_->del(host->getIPv4SubnetID(), address));
HostDataSourceUtils::compareHosts(got, host);
// Verify cache status.
- EXPECT_EQ(1, hcptr_->size());
- EXPECT_EQ(1, hcptr_->inserts_);
+ EXPECT_EQ(1U, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->inserts_);
}
// Check by address caching for IPv6.
// Check we have what we need.
ASSERT_TRUE(hcptr_);
EXPECT_TRUE(HostMgr::checkCacheBackend());
- EXPECT_EQ(0, hcptr_->size());
- EXPECT_EQ(0, hcptr_->inserts_);
+ EXPECT_EQ(0U, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->inserts_);
ASSERT_TRUE(memptr_);
// Create a host reservation.
HostDataSourceUtils::compareHosts(got, host);
// Verify it was cached.
- EXPECT_EQ(1, hcptr_->size());
- EXPECT_EQ(1, hcptr_->inserts_);
+ EXPECT_EQ(1U, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->inserts_);
// Remove it from test host data source.
EXPECT_TRUE(memptr_->del(host->getIPv6SubnetID(), address));
HostDataSourceUtils::compareHosts(got, host);
// Verify cache status.
- EXPECT_EQ(1, hcptr_->size());
- EXPECT_EQ(1, hcptr_->inserts_);
+ EXPECT_EQ(1U, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->inserts_);
}
// Check negative cache feature for IPv4.
// Check we have what we need.
ASSERT_TRUE(hcptr_);
EXPECT_TRUE(HostMgr::checkCacheBackend());
- EXPECT_EQ(0, hcptr_->size());
- EXPECT_EQ(0, hcptr_->adds_);
+ EXPECT_EQ(0U, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->adds_);
ASSERT_TRUE(memptr_);
ASSERT_FALSE(HostMgr::instance().getNegativeCaching());
&host->getIdentifier()[0],
host->getIdentifier().size());
ASSERT_FALSE(got);
- EXPECT_EQ(1, hcptr_->size());
- EXPECT_EQ(1, hcptr_->adds_);
+ EXPECT_EQ(1U, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->adds_);
got = HostMgr::instance().get4Any(host->getIPv4SubnetID(),
host->getIdentifierType(),
&host->getIdentifier()[0],
EXPECT_FALSE(got);
// Verify cache status.
- EXPECT_EQ(1, hcptr_->size());
- EXPECT_EQ(1, hcptr_->adds_);
- EXPECT_EQ(0, hcptr_->inserts_);
+ EXPECT_EQ(1U, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->adds_);
+ EXPECT_EQ(0U, hcptr_->inserts_);
// We can verify other overloads of get4() but the hwaddr/duid is
// not implemented by the memory test backend and the negative cache
// Check we have what we need.
ASSERT_TRUE(hcptr_);
EXPECT_TRUE(HostMgr::checkCacheBackend());
- EXPECT_EQ(0, hcptr_->size());
- EXPECT_EQ(0, hcptr_->adds_);
+ EXPECT_EQ(0U, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->adds_);
ASSERT_TRUE(memptr_);
// Create a host reservation.
&host->getIdentifier()[0],
host->getIdentifier().size());
ASSERT_FALSE(got);
- EXPECT_EQ(0, hcptr_->size());
- EXPECT_EQ(0, hcptr_->adds_);
+ EXPECT_EQ(0U, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->adds_);
got = HostMgr::instance().get6(host->getIPv6SubnetID(),
host->getIdentifierType(),
ASSERT_FALSE(got);
// There is a negative cached value now.
- EXPECT_EQ(1, hcptr_->size());
- EXPECT_EQ(1, hcptr_->adds_);
+ EXPECT_EQ(1U, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->adds_);
got = HostMgr::instance().get6Any(host->getIPv6SubnetID(),
host->getIdentifierType(),
&host->getIdentifier()[0],
EXPECT_FALSE(got);
// Verify cache status.
- EXPECT_EQ(1, hcptr_->size());
- EXPECT_EQ(1, hcptr_->adds_);
- EXPECT_EQ(0, hcptr_->inserts_);
+ EXPECT_EQ(1U, hcptr_->size());
+ EXPECT_EQ(1U, hcptr_->adds_);
+ EXPECT_EQ(0U, hcptr_->inserts_);
// No other tests, cf negativeIdentifier4 end comment.
}
// Check we have what we need.
ASSERT_TRUE(hcptr_);
EXPECT_TRUE(HostMgr::checkCacheBackend());
- EXPECT_EQ(0, hcptr_->size());
- EXPECT_EQ(0, hcptr_->adds_);
+ EXPECT_EQ(0U, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->adds_);
ASSERT_TRUE(memptr_);
// Create a host reservation.
ConstHostPtr got = HostMgr::instance().get4(host->getIPv4SubnetID(),
address);
ASSERT_FALSE(got);
- EXPECT_EQ(0, hcptr_->size());
- EXPECT_EQ(0, hcptr_->adds_);
+ EXPECT_EQ(0U, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->adds_);
}
// Check that negative caching by address is not done for IPv6.
// Check we have what we need.
ASSERT_TRUE(hcptr_);
EXPECT_TRUE(HostMgr::checkCacheBackend());
- EXPECT_EQ(0, hcptr_->size());
- EXPECT_EQ(0, hcptr_->adds_);
+ EXPECT_EQ(0U, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->adds_);
ASSERT_TRUE(memptr_);
// Create a host reservation.
ConstHostPtr got = HostMgr::instance().get6(host->getIPv6SubnetID(),
address);
ASSERT_FALSE(got);
- EXPECT_EQ(0, hcptr_->size());
- EXPECT_EQ(0, hcptr_->adds_);
+ EXPECT_EQ(0U, hcptr_->size());
+ EXPECT_EQ(0U, hcptr_->adds_);
}
/// @brief Test one backend class.
HostMgr::instance().getAll(host->getIdentifierType(),
&host->getIdentifier()[0],
host->getIdentifier().size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
EXPECT_EQ(host, hosts[0]);
ASSERT_NO_THROW(hosts =
HostMgr::instance().getAll4(host->getIPv4Reservation()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
EXPECT_EQ(host, hosts[0]);
}
TEST_F(HostDataSourceFactoryTest, add) {
EXPECT_TRUE(registerFactory());
EXPECT_NO_THROW(HostDataSourceFactory::add(sources_, "type=mem"));
- ASSERT_EQ(1, sources_.size());
+ ASSERT_EQ(1U, sources_.size());
EXPECT_EQ("mem", sources_[0]->getType());
}
// Add mem
EXPECT_TRUE(registerFactory());
EXPECT_NO_THROW(HostDataSourceFactory::add(sources_, "type=mem"));
- ASSERT_EQ(1, sources_.size());
+ ASSERT_EQ(1U, sources_.size());
// Delete another
EXPECT_FALSE(HostDataSourceFactory::del(sources_, "another"));
EXPECT_TRUE(HostDataSourceFactory::del(sources_, "mem1"));
// No more sources
- EXPECT_EQ(0, sources_.size());
+ EXPECT_EQ(0U, sources_.size());
EXPECT_FALSE(HostDataSourceFactory::del(sources_, "mem1"));
EXPECT_FALSE(HostDataSourceFactory::del(sources_, "mem2"));
}
ASSERT_NO_THROW(host = parser.parse(SubnetID(10), config_element));
ASSERT_TRUE(host);
- EXPECT_EQ(10, host->getIPv4SubnetID());
+ EXPECT_EQ(10U, host->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.112", host->getIPv4Reservation().toText());
EXPECT_TRUE(host->getHostname().empty());
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_DUID,
&duid_->getDuid()[0],
duid_->getDuid().size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
- EXPECT_EQ(10, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(10U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, hosts[0]->getIPv6SubnetID());
EXPECT_EQ("192.0.2.10", hosts[0]->getIPv4Reservation().toText());
EXPECT_TRUE(hosts[0]->getHostname().empty());
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_HWADDR,
&hwaddr_->hwaddr_[0],
hwaddr_->hwaddr_.size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
const ClientClasses& classes = hosts[0]->getClientClasses4();
- ASSERT_EQ(2, classes.size());
+ ASSERT_EQ(2U, classes.size());
EXPECT_TRUE(classes.contains("foo"));
EXPECT_TRUE(classes.contains("bar"));
&hwaddr_->hwaddr_[0],
hwaddr_->hwaddr_.size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
- EXPECT_EQ(10, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(10U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ("192.0.2.11", hosts[0]->getNextServer().toText());
EXPECT_EQ("some-name.example.org", hosts[0]->getServerHostname());
EXPECT_EQ("/tmp/some-file.efi", hosts[0]->getBootFileName());
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_DUID,
&duid_->getDuid()[0],
duid_->getDuid().size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
- EXPECT_EQ(10, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(10U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, hosts[0]->getIPv6SubnetID());
EXPECT_EQ("0.0.0.0", hosts[0]->getIPv4Reservation().toText());
EXPECT_EQ("foo.example.com", hosts[0]->getHostname());
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_HWADDR,
&hwaddr_->hwaddr_[0],
hwaddr_->hwaddr_.size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
EXPECT_EQ(SUBNET_ID_UNUSED, hosts[0]->getIPv4SubnetID());
- EXPECT_EQ(10, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(10U, hosts[0]->getIPv6SubnetID());
EXPECT_EQ("foo.example.com", hosts[0]->getHostname());
IPv6ResrvRange addresses = hosts[0]->
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_DUID,
&duid_->getDuid()[0],
duid_->getDuid().size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
EXPECT_EQ(SUBNET_ID_UNUSED, hosts[0]->getIPv4SubnetID());
- EXPECT_EQ(12, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(12U, hosts[0]->getIPv6SubnetID());
EXPECT_EQ("foo.example.com", hosts[0]->getHostname());
IPv6ResrvRange addresses = hosts[0]->
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_DUID,
&duid_->getDuid()[0],
duid_->getDuid().size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
EXPECT_EQ(SUBNET_ID_UNUSED, hosts[0]->getIPv4SubnetID());
- EXPECT_EQ(12, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(12U, hosts[0]->getIPv6SubnetID());
EXPECT_TRUE(hosts[0]->getHostname().empty());
IPv6ResrvRange addresses = hosts[0]->
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_DUID,
&duid_->getDuid()[0],
duid_->getDuid().size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
const ClientClasses& classes = hosts[0]->getClientClasses6();
- ASSERT_EQ(2, classes.size());
+ ASSERT_EQ(2U, classes.size());
EXPECT_TRUE(classes.contains("foo"));
EXPECT_TRUE(classes.contains("bar"));
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_HWADDR,
&hwaddr_->hwaddr_[0],
hwaddr_->hwaddr_.size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
// Retrieve and sanity check name servers.
Option4AddrLstPtr opt_dns = boost::dynamic_pointer_cast<
Option4AddrLst>(retrieveOption(*hosts[0], DHCP4_OPTION_SPACE, DHO_NAME_SERVERS));
ASSERT_TRUE(opt_dns);
Option4AddrLst::AddressContainer dns_addrs = opt_dns->getAddresses();
- ASSERT_EQ(2, dns_addrs.size());
+ ASSERT_EQ(2U, dns_addrs.size());
EXPECT_EQ("172.16.15.10", dns_addrs[0].toText());
EXPECT_EQ("172.16.15.20", dns_addrs[1].toText());
Option4AddrLst>(retrieveOption(*hosts[0], DHCP4_OPTION_SPACE, DHO_LOG_SERVERS));
ASSERT_TRUE(opt_log);
Option4AddrLst::AddressContainer log_addrs = opt_log->getAddresses();
- ASSERT_EQ(1, log_addrs.size());
+ ASSERT_EQ(1U, log_addrs.size());
EXPECT_EQ("172.16.15.23", log_addrs[0].toText());
// Retrieve and sanity check default IP TTL.
OptionUint8Ptr opt_ttl = boost::dynamic_pointer_cast<
OptionUint8>(retrieveOption(*hosts[0], DHCP4_OPTION_SPACE, DHO_DEFAULT_IP_TTL));
ASSERT_TRUE(opt_ttl);
- EXPECT_EQ(64, opt_ttl->getValue());
+ EXPECT_EQ(64U, opt_ttl->getValue());
// Canonize the config
ElementPtr option = config_element->get("option-data")->getNonConst(0);
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_DUID,
&duid_->getDuid()[0],
duid_->getDuid().size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
// Retrieve and sanity check DNS servers option.
Option6AddrLstPtr opt_dns = boost::dynamic_pointer_cast<
Option6AddrLst>(retrieveOption(*hosts[0], DHCP6_OPTION_SPACE, D6O_NAME_SERVERS));
ASSERT_TRUE(opt_dns);
Option6AddrLst::AddressContainer dns_addrs = opt_dns->getAddresses();
- ASSERT_EQ(2, dns_addrs.size());
+ ASSERT_EQ(2U, dns_addrs.size());
EXPECT_EQ("2001:db8:1::1", dns_addrs[0].toText());
EXPECT_EQ("2001:db8:1::2", dns_addrs[1].toText());
Option6AddrLst>(retrieveOption(*hosts[0], DHCP6_OPTION_SPACE, D6O_NIS_SERVERS));
ASSERT_TRUE(opt_nis);
Option6AddrLst::AddressContainer nis_addrs = opt_nis->getAddresses();
- ASSERT_EQ(1, nis_addrs.size());
+ ASSERT_EQ(1U, nis_addrs.size());
EXPECT_EQ("2001:db8:1::1204", nis_addrs[0].toText());
// Retrieve and sanity check preference option.
OptionUint8Ptr opt_prf = boost::dynamic_pointer_cast<
OptionUint8>(retrieveOption(*hosts[0], DHCP6_OPTION_SPACE, D6O_PREFERENCE));
ASSERT_TRUE(opt_prf);
- EXPECT_EQ(11, opt_prf->getValue());
+ EXPECT_EQ(11U, opt_prf->getValue());
// Canonize the config
ElementPtr option = config_element->get("option-data")->getNonConst(0);
ConstCfgHostOperationsPtr cfg = CfgMgr::instance().getStagingCfg()->
getCfgHostOperations4();
const CfgHostOperations::IdentifierTypes& ids = cfg->getIdentifierTypes();
- ASSERT_EQ(4, ids.size());
+ ASSERT_EQ(4U, ids.size());
CfgHostOperations::IdentifierTypes::const_iterator id = ids.begin();
EXPECT_EQ(*id++, Host::IDENT_CIRCUIT_ID);
ConstCfgHostOperationsPtr cfg = CfgMgr::instance().getStagingCfg()->
getCfgHostOperations6();
const CfgHostOperations::IdentifierTypes& ids = cfg->getIdentifierTypes();
- ASSERT_EQ(2, ids.size());
+ ASSERT_EQ(2U, ids.size());
CfgHostOperations::IdentifierTypes::const_iterator id = ids.begin();
EXPECT_EQ(*id++, Host::IDENT_DUID);
ConstCfgHostOperationsPtr cfg = CfgMgr::instance().getStagingCfg()->
getCfgHostOperations4();
const CfgHostOperations::IdentifierTypes& ids = cfg->getIdentifierTypes();
- ASSERT_EQ(5, ids.size());
+ ASSERT_EQ(5U, ids.size());
CfgHostOperations::IdentifierTypes::const_iterator id = ids.begin();
EXPECT_EQ(*id++, Host::IDENT_HWADDR);
ConstCfgHostOperationsPtr cfg = CfgMgr::instance().getStagingCfg()->
getCfgHostOperations6();
const CfgHostOperations::IdentifierTypes& ids = cfg->getIdentifierTypes();
- ASSERT_EQ(3, ids.size());
+ ASSERT_EQ(3U, ids.size());
CfgHostOperations::IdentifierTypes::const_iterator id = ids.begin();
EXPECT_EQ(*id++, Host::IDENT_HWADDR);
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_HWADDR,
&hwaddr_->hwaddr_[0],
hwaddr_->hwaddr_.size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, hosts[0]->getIPv6SubnetID());
EXPECT_EQ("192.0.2.134", hosts[0]->getIPv4Reservation().toText());
EXPECT_EQ("foo.example.com", hosts[0]->getHostname());
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_DUID,
&duid_->getDuid()[0],
duid_->getDuid().size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ(SUBNET_ID_UNUSED, hosts[0]->getIPv6SubnetID());
EXPECT_EQ("192.0.2.110", hosts[0]->getIPv4Reservation().toText());
EXPECT_EQ("bar.example.com", hosts[0]->getHostname());
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_HWADDR,
&hwaddr_->hwaddr_[0],
hwaddr_->hwaddr_.size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
// Make sure it belongs to a valid subnet.
EXPECT_EQ(SUBNET_ID_UNUSED, hosts[0]->getIPv4SubnetID());
- EXPECT_EQ(2, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(2U, hosts[0]->getIPv6SubnetID());
// Get the reserved addresses for the host. There should be exactly one
// address reserved for this host.
EXPECT_EQ(IPv6Resrv::TYPE_NA, prefixes.first->second.getType());
EXPECT_EQ("2001:db8:1::123", prefixes.first->second.getPrefix().toText());
- EXPECT_EQ(128, prefixes.first->second.getPrefixLen());
+ EXPECT_EQ(128U, prefixes.first->second.getPrefixLen());
// Validate the second reservation.
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_DUID,
&duid_->getDuid()[0],
duid_->getDuid().size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
EXPECT_EQ(SUBNET_ID_UNUSED, hosts[0]->getIPv4SubnetID());
- EXPECT_EQ(2, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(2U, hosts[0]->getIPv6SubnetID());
// This reservation was for a prefix, instead of an IPv6 address.
prefixes = hosts[0]->getIPv6Reservations(IPv6Resrv::TYPE_PD);
EXPECT_EQ(IPv6Resrv::TYPE_PD, prefixes.first->second.getType());
EXPECT_EQ("2001:db8:1:2::", prefixes.first->second.getPrefix().toText());
- EXPECT_EQ(80, prefixes.first->second.getPrefixLen());
+ EXPECT_EQ(80U, prefixes.first->second.getPrefixLen());
// Get back the config from cfg_hosts
ElementPtr resv = config_element->getNonConst(0);
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_HWADDR,
&hwaddr_->hwaddr_[0],
hwaddr_->hwaddr_.size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
// Make sure it belongs to a valid subnet.
EXPECT_EQ(SUBNET_ID_UNUSED, hosts[0]->getIPv4SubnetID());
- EXPECT_EQ(2, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(2U, hosts[0]->getIPv6SubnetID());
// Get the reserved addresses for the host. There should be exactly one
// address reserved for this host.
EXPECT_EQ(IPv6Resrv::TYPE_NA, prefixes.first->second.getType());
EXPECT_EQ("2001:db8:1::123", prefixes.first->second.getPrefix().toText());
- EXPECT_EQ(128, prefixes.first->second.getPrefixLen());
+ EXPECT_EQ(128U, prefixes.first->second.getPrefixLen());
// Validate the second reservation.
ASSERT_NO_THROW(hosts = cfg_hosts->getAll(Host::IDENT_DUID,
&duid_->getDuid()[0],
duid_->getDuid().size()));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
EXPECT_EQ(SUBNET_ID_UNUSED, hosts[0]->getIPv4SubnetID());
- EXPECT_EQ(2, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(2U, hosts[0]->getIPv6SubnetID());
// This reservation was for a prefix, instead of an IPv6 address.
prefixes = hosts[0]->getIPv6Reservations(IPv6Resrv::TYPE_PD);
EXPECT_EQ(IPv6Resrv::TYPE_PD, prefixes.first->second.getType());
EXPECT_EQ("2001:db8::", prefixes.first->second.getPrefix().toText());
- EXPECT_EQ(48, prefixes.first->second.getPrefixLen());
+ EXPECT_EQ(48U, prefixes.first->second.getPrefixLen());
EXPECT_TRUE(prefixes.first->second.getPDExclude());
EXPECT_EQ("2001:db8:0:1::/64", prefixes.first->second.PDExcludetoText());
TEST(IPv6ResrvTest, constructorAddress) {
IPv6Resrv resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::cafe"));
EXPECT_EQ("2001:db8:1::cafe", resrv.getPrefix().toText());
- EXPECT_EQ(128, resrv.getPrefixLen());
+ EXPECT_EQ(128U, resrv.getPrefixLen());
EXPECT_EQ(IPv6Resrv::TYPE_NA, resrv.getType());
}
TEST(IPv6ResrvTest, constructorPrefix) {
IPv6Resrv resrv(IPv6Resrv::TYPE_PD, IOAddress("2001:db8:1::"), 64);
EXPECT_EQ("2001:db8:1::", resrv.getPrefix().toText());
- EXPECT_EQ(64, resrv.getPrefixLen());
+ EXPECT_EQ(64U, resrv.getPrefixLen());
EXPECT_EQ(IPv6Resrv::TYPE_PD, resrv.getType());
}
// Create a reservation using an address and prefix length 128.
IPv6Resrv resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::1"));
ASSERT_EQ("2001:db8:1::1", resrv.getPrefix().toText());
- ASSERT_EQ(128, resrv.getPrefixLen());
+ ASSERT_EQ(128U, resrv.getPrefixLen());
ASSERT_EQ(IPv6Resrv::TYPE_NA, resrv.getType());
// Modify the reservation to use a prefix having a length of 48.
ASSERT_NO_THROW(resrv.set(IPv6Resrv::TYPE_PD, IOAddress("2001:db8::"), 48));
EXPECT_EQ("2001:db8::", resrv.getPrefix().toText());
- EXPECT_EQ(48, resrv.getPrefixLen());
+ EXPECT_EQ(48U, resrv.getPrefixLen());
EXPECT_EQ(IPv6Resrv::TYPE_PD, resrv.getType());
// IPv4 address is invalid for IPv6 reservation.
EXPECT_EQ("2001:db8:0:1::",
opt->getExcludedPrefix(resrv.getPrefix(),
resrv.getPrefixLen()).toText());
- EXPECT_EQ(64, opt->getExcludedPrefixLength());
+ EXPECT_EQ(64U, opt->getExcludedPrefixLength());
string expected = "2001:db8::/48 (excluded_prefix=2001:db8:0:1::/64)";
EXPECT_EQ(expected, resrv.toText());
// This test verifies that expected identifier max length is returned.
TEST_F(HostTest, getIdentifierMaxLength) {
- EXPECT_EQ(20, Host::getIdentifierMaxLength(Host::IDENT_HWADDR));
- EXPECT_EQ(130, Host::getIdentifierMaxLength(Host::IDENT_DUID));
- EXPECT_EQ(128, Host::getIdentifierMaxLength(Host::IDENT_CIRCUIT_ID));
- EXPECT_EQ(255, Host::getIdentifierMaxLength(Host::IDENT_CLIENT_ID));
- EXPECT_EQ(128, Host::getIdentifierMaxLength(Host::IDENT_FLEX));
+ EXPECT_EQ(20U, Host::getIdentifierMaxLength(Host::IDENT_HWADDR));
+ EXPECT_EQ(130U, Host::getIdentifierMaxLength(Host::IDENT_DUID));
+ EXPECT_EQ(128U, Host::getIdentifierMaxLength(Host::IDENT_CIRCUIT_ID));
+ EXPECT_EQ(255U, Host::getIdentifierMaxLength(Host::IDENT_CLIENT_ID));
+ EXPECT_EQ(128U, Host::getIdentifierMaxLength(Host::IDENT_FLEX));
}
// This test verifies that correct identifier name is returned for
// DUID should be null if hardware address is in use.
EXPECT_FALSE(host->getDuid());
- EXPECT_EQ(1, host->getIPv4SubnetID());
- EXPECT_EQ(2, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
+ EXPECT_EQ(2U, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.3", host->getIPv4Reservation().toText());
EXPECT_EQ("somehost.example.org", host->getHostname());
EXPECT_EQ("192.0.0.2", host->getNextServer().toText());
// Hardware address must be null if DUID is in use.
EXPECT_FALSE(host->getHWAddress());
- EXPECT_EQ(10, host->getIPv4SubnetID());
- EXPECT_EQ(20, host->getIPv6SubnetID());
+ EXPECT_EQ(10U, host->getIPv4SubnetID());
+ EXPECT_EQ(20U, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
EXPECT_EQ("me.example.org", host->getHostname());
EXPECT_FALSE(host->getContext());
// DUID should be null if hardware address is in use.
EXPECT_FALSE(host->getDuid());
- EXPECT_EQ(1, host->getIPv4SubnetID());
- EXPECT_EQ(2, host->getIPv6SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
+ EXPECT_EQ(2U, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.3", host->getIPv4Reservation().toText());
EXPECT_EQ("somehost.example.org", host->getHostname());
EXPECT_EQ("192.0.0.2", host->getNextServer().toText());
// Hardware address should be null if DUID is in use.
EXPECT_FALSE(host->getHWAddress());
- EXPECT_EQ(10, host->getIPv4SubnetID());
- EXPECT_EQ(20, host->getIPv6SubnetID());
+ EXPECT_EQ(10U, host->getIPv4SubnetID());
+ EXPECT_EQ(20U, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
EXPECT_EQ("me.example.org", host->getHostname());
EXPECT_FALSE(host->getContext());
EXPECT_TRUE(identifier_returned == identifier);
EXPECT_EQ(type, host->getIdentifierType());
- EXPECT_EQ(10, host->getIPv4SubnetID());
- EXPECT_EQ(20, host->getIPv6SubnetID());
+ EXPECT_EQ(10U, host->getIPv4SubnetID());
+ EXPECT_EQ(20U, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
EXPECT_EQ("me.example.org", host->getHostname());
EXPECT_FALSE(host->getContext());
EXPECT_TRUE(identifier_returned == identifier);
EXPECT_EQ(type, host->getIdentifierType());
- EXPECT_EQ(10, host->getIPv4SubnetID());
- EXPECT_EQ(20, host->getIPv6SubnetID());
+ EXPECT_EQ(10U, host->getIPv4SubnetID());
+ EXPECT_EQ(20U, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
EXPECT_EQ("me.example.org", host->getHostname());
EXPECT_FALSE(host->getContext());
EXPECT_EQ(identifier_without_quotes.str(), identifier_returned_str);
EXPECT_EQ(type, host->getIdentifierType());
- EXPECT_EQ(10, host->getIPv4SubnetID());
- EXPECT_EQ(20, host->getIPv6SubnetID());
+ EXPECT_EQ(10U, host->getIPv4SubnetID());
+ EXPECT_EQ(20U, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
EXPECT_EQ("me.example.org", host->getHostname());
EXPECT_FALSE(host->getContext());
EXPECT_TRUE(identifier_returned == identifier);
EXPECT_EQ(type, host->getIdentifierType());
- EXPECT_EQ(10, host->getIPv4SubnetID());
- EXPECT_EQ(20, host->getIPv6SubnetID());
+ EXPECT_EQ(10U, host->getIPv4SubnetID());
+ EXPECT_EQ(20U, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
EXPECT_EQ("me.example.org", host->getHostname());
EXPECT_FALSE(host->getContext());
EXPECT_TRUE(identifier_returned == identifier);
EXPECT_EQ(type, host->getIdentifierType());
- EXPECT_EQ(10, host->getIPv4SubnetID());
- EXPECT_EQ(20, host->getIPv6SubnetID());
+ EXPECT_EQ(10U, host->getIPv4SubnetID());
+ EXPECT_EQ(20U, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
EXPECT_EQ("me.example.org", host->getHostname());
EXPECT_FALSE(host->getContext());
EXPECT_TRUE(identifier_returned == identifier);
EXPECT_EQ(type, host->getIdentifierType());
- EXPECT_EQ(10, host->getIPv4SubnetID());
- EXPECT_EQ(20, host->getIPv6SubnetID());
+ EXPECT_EQ(10U, host->getIPv4SubnetID());
+ EXPECT_EQ(20U, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
EXPECT_EQ("me.example.org", host->getHostname());
EXPECT_FALSE(host->getContext());
EXPECT_TRUE(identifier_returned == identifier);
EXPECT_EQ(type, host->getIdentifierType());
- EXPECT_EQ(10, host->getIPv4SubnetID());
- EXPECT_EQ(20, host->getIPv6SubnetID());
+ EXPECT_EQ(10U, host->getIPv4SubnetID());
+ EXPECT_EQ(20U, host->getIPv6SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
EXPECT_EQ("me.example.org", host->getHostname());
EXPECT_FALSE(host->getContext());
IOAddress("192.0.2.3"),
"some-host.eXAMple.org")));
- ASSERT_EQ(1, host->getIPv4SubnetID());
- ASSERT_EQ(2, host->getIPv6SubnetID());
+ ASSERT_EQ(1U, host->getIPv4SubnetID());
+ ASSERT_EQ(2U, host->getIPv6SubnetID());
ASSERT_EQ("192.0.2.3", host->getIPv4Reservation().toText());
ASSERT_EQ("some-host.eXAMple.org", host->getHostname());
ASSERT_EQ("some-host.example.org", host->getLowerHostname());
host->setContext(Element::fromJSON(user_context));
host->setNegative(true);
- EXPECT_EQ(123, host->getIPv4SubnetID());
- EXPECT_EQ(234, host->getIPv6SubnetID());
+ EXPECT_EQ(123U, host->getIPv4SubnetID());
+ EXPECT_EQ(234U, host->getIPv6SubnetID());
EXPECT_EQ("10.0.0.1", host->getIPv4Reservation().toText());
EXPECT_EQ("other-host.eXAMple.org", host->getHostname());
ASSERT_EQ("other-host.example.org", host->getLowerHostname());
// Get options from the Subnet and check if all 10 are there.
OptionContainerPtr options = host.getCfgOption4()->getAll(DHCP4_OPTION_SPACE);
ASSERT_TRUE(options);
- ASSERT_EQ(10, options->size());
+ ASSERT_EQ(10U, options->size());
// It should be possible to retrieve DHCPv6 options but the container
// should be empty.
options = host.getCfgOption4()->getAll("isc");
ASSERT_TRUE(options);
- ASSERT_EQ(7, options->size());
+ ASSERT_EQ(7U, options->size());
// Validate codes of options added to isc option space.
expected_code = 105;
// Get options from the Subnet and check if all 10 are there.
OptionContainerPtr options = host.getCfgOption6()->getAll(DHCP6_OPTION_SPACE);
ASSERT_TRUE(options);
- ASSERT_EQ(10, options->size());
+ ASSERT_EQ(10U, options->size());
// It should be possible to retrieve DHCPv4 options but the container
// should be empty.
options = host.getCfgOption6()->getAll("isc");
ASSERT_TRUE(options);
- ASSERT_EQ(7, options->size());
+ ASSERT_EQ(7U, options->size());
// Validate codes of options added to isc option space.
expected_code = 105;
// name works correctly.
TEST_F(HostTest, getIdentifierName) {
EXPECT_EQ("hw-address", Host::getIdentifierName(Host::IDENT_HWADDR));
-
}
// This test checks that Host object is correctly described in the
SubnetID(1), SubnetID(2),
IOAddress("192.0.2.3"),
"myhost.example.com")));
- EXPECT_EQ(0, host->getHostId());
+ EXPECT_EQ(0U, host->getHostId());
EXPECT_NO_THROW(host->setHostId(12345));
- EXPECT_EQ(12345, host->getHostId());
+ EXPECT_EQ(12345U, host->getHostId());
}
// Test verifies if we can modify the host keys.
IOAddress("192.0.2.3"),
"myhost.example.com")));
// Key must be empty
- EXPECT_EQ(0, host->getKey().getAuthKey().size());
+ EXPECT_EQ(0U, host->getKey().getAuthKey().size());
EXPECT_EQ("", host->getKey().toText());
// now set to random value
// Call the constructor with default argument
// Default constructor should generate random string of 16 bytes
AuthKey defaultKey;
- ASSERT_EQ(16, defaultKey.getAuthKey().size());
+ ASSERT_EQ(16U, defaultKey.getAuthKey().size());
AuthKey longKey("0123456789abcdef1122334455667788");
- ASSERT_EQ(16, longKey.getAuthKey().size());
+ ASSERT_EQ(16U, longKey.getAuthKey().size());
// Check the setters for valid and invalid string
string key16ByteStr = "000102030405060708090A0B0C0D0E0F";
AuthKey defaultTestKey;
defaultTestKey.setAuthKey(key16ByteStr);
- ASSERT_EQ(16, defaultTestKey.getAuthKey().size());
+ ASSERT_EQ(16U, defaultTestKey.getAuthKey().size());
ASSERT_EQ(key16ByteStr, defaultTestKey.toText());
ASSERT_EQ(key16ByteBin, defaultTestKey.getAuthKey());
}
// Check how many leases were actually loaded.
- ASSERT_EQ((exp_present ? 1 : 0), storage4_.size());
+ ASSERT_EQ((exp_present ? 1U : 0U), storage4_.size());
Lease4Ptr l = getLease<Lease4Ptr>(lease, storage4_);
}
// Check how many leases were actually loaded.
- ASSERT_EQ((exp_present ? 1 : 0), storage6_.size());
+ ASSERT_EQ((exp_present ? 1U : 0U), storage6_.size());
Lease6Ptr l = getLease<Lease6Ptr>(lease, storage6_);
}
// There are two unique leases.
- ASSERT_EQ(2, storage.size());
+ ASSERT_EQ(2U, storage.size());
// The lease for 192.0.2.1 should exist and the cltt should be
// set to the expire-valid_lifetime for the second entry for
// There should only be one lease. The one with the valid_lifetime
// of 0 should be removed.
- ASSERT_EQ(1, storage.size());
+ ASSERT_EQ(1U, storage.size());
Lease4Ptr lease = getLease<Lease4Ptr>("192.0.3.15", storage);
ASSERT_TRUE(lease);
}
// There should be 3 unique leases.
- ASSERT_EQ(3, storage.size());
+ ASSERT_EQ(3U, storage.size());
// The 2001:db8:1::1 should be present and its cltt should be
// calculated according to the expiration time and the valid
// There should be only one lease for 2001:db8:2::10. The other one
// should have been deleted (or rather not loaded).
- ASSERT_EQ(1, storage.size());
+ ASSERT_EQ(1U, storage.size());
Lease6Ptr lease = getLease<Lease6Ptr>("2001:db8:2::10", storage);
ASSERT_TRUE(lease);
// Valid construction, verifiy member values.
ASSERT_NO_THROW(qry.reset(new LeaseStatsQuery()));
- ASSERT_EQ(0, qry->getFirstSubnetID());
- ASSERT_EQ(0, qry->getLastSubnetID());
+ ASSERT_EQ(0U, qry->getFirstSubnetID());
+ ASSERT_EQ(0U, qry->getLastSubnetID());
ASSERT_EQ(LeaseStatsQuery::ALL_SUBNETS, qry->getSelectMode());
}
// Valid values should work and set mode accordingly.
ASSERT_NO_THROW(qry.reset(new LeaseStatsQuery(77)));
- ASSERT_EQ(77, qry->getFirstSubnetID());
- ASSERT_EQ(0, qry->getLastSubnetID());
+ ASSERT_EQ(77U, qry->getFirstSubnetID());
+ ASSERT_EQ(0U, qry->getLastSubnetID());
ASSERT_EQ(LeaseStatsQuery::SINGLE_SUBNET, qry->getSelectMode());
}
// Valid values should work and set mode accordingly.
ASSERT_NO_THROW(qry.reset(new LeaseStatsQuery(1,2)));
- ASSERT_EQ(1, qry->getFirstSubnetID());
- ASSERT_EQ(2, qry->getLastSubnetID());
+ ASSERT_EQ(1U, qry->getFirstSubnetID());
+ ASSERT_EQ(2U, qry->getLastSubnetID());
ASSERT_EQ(LeaseStatsQuery::SUBNET_RANGE, qry->getSelectMode());
}
lease->setContext(user_context);
EXPECT_NO_THROW(mgr->addExtendedInfo6(lease));
- EXPECT_EQ(1, mgr->relay_id6_.size());
+ EXPECT_EQ(1U, mgr->relay_id6_.size());
Lease6ExtendedInfoPtr ex_info = mgr->relay_id6_.front();
ASSERT_TRUE(ex_info);
EXPECT_EQ("2001:db8::100", ex_info->lease_addr_.toText());
const vector<uint8_t>& exp_relay_id = vector<uint8_t>(8, 0x64);
EXPECT_EQ(exp_relay_id, relay_id);
- EXPECT_EQ(1, mgr->remote_id6_.size());
+ EXPECT_EQ(1U, mgr->remote_id6_.size());
ex_info = mgr->remote_id6_.front();
ASSERT_TRUE(ex_info);
EXPECT_EQ("2001:db8::100", ex_info->lease_addr_.toText());
lease->setContext(user_context);
EXPECT_NO_THROW(mgr->addExtendedInfo6(lease));
- EXPECT_EQ(1, mgr->relay_id6_.size());
+ EXPECT_EQ(1U, mgr->relay_id6_.size());
Lease6ExtendedInfoPtr ex_info = mgr->relay_id6_.front();
ASSERT_TRUE(ex_info);
EXPECT_EQ("2001:db8::100", ex_info->lease_addr_.toText());
const vector<uint8_t>& exp_relay_id = vector<uint8_t>(8, 0x64);
EXPECT_EQ(exp_relay_id, relay_id);
- EXPECT_EQ(1, mgr->remote_id6_.size());
+ EXPECT_EQ(1U, mgr->remote_id6_.size());
ex_info = mgr->remote_id6_.front();
ASSERT_TRUE(ex_info);
EXPECT_EQ("2001:db8::100", ex_info->lease_addr_.toText());
lease->setContext(user_context);
EXPECT_NO_THROW(mgr->addExtendedInfo6(lease));
- EXPECT_EQ(1, mgr->relay_id6_.size());
+ EXPECT_EQ(1U, mgr->relay_id6_.size());
Lease6ExtendedInfoPtr ex_info = mgr->relay_id6_.front();
ASSERT_TRUE(ex_info);
EXPECT_EQ("2001:db8::100", ex_info->lease_addr_.toText());
const vector<uint8_t>& exp_relay_id = vector<uint8_t>(8, 0x64);
EXPECT_EQ(exp_relay_id, relay_id);
- EXPECT_EQ(1, mgr->remote_id6_.size());
+ EXPECT_EQ(1U, mgr->remote_id6_.size());
ex_info = mgr->remote_id6_.front();
ASSERT_TRUE(ex_info);
EXPECT_EQ("2001:db8::100", ex_info->lease_addr_.toText());
ASSERT_TRUE(lease);
EXPECT_EQ("192.0.2.3", lease->addr_.toText());
- EXPECT_EQ(789, static_cast<uint32_t>(lease->subnet_id_));
- EXPECT_EQ(5, static_cast<uint32_t>(lease->pool_id_));
+ EXPECT_EQ(789U, static_cast<uint32_t>(lease->subnet_id_));
+ EXPECT_EQ(5U, static_cast<uint32_t>(lease->pool_id_));
ASSERT_TRUE(lease->hwaddr_);
EXPECT_EQ("hwtype=1 08:00:2b:02:3f:4e", lease->hwaddr_->toText());
ASSERT_TRUE(lease->client_id_);
EXPECT_EQ("17:34:e2:ff:09:92:54", lease->client_id_->toText());
EXPECT_EQ(12345678, lease->cltt_);
EXPECT_EQ(lease->cltt_, lease->current_cltt_);
- EXPECT_EQ(3600, lease->valid_lft_);
+ EXPECT_EQ(3600U, lease->valid_lft_);
EXPECT_EQ(lease->valid_lft_, lease->current_valid_lft_);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_FALSE(lease.fqdn_fwd_);
EXPECT_FALSE(lease.fqdn_rev_);
EXPECT_EQ(Lease::STATE_DECLINED, lease.state_);
- EXPECT_EQ(123, lease.valid_lft_);
+ EXPECT_EQ(123U, lease.valid_lft_);
EXPECT_FALSE(lease.getContext());
}
EXPECT_TRUE(lease->iaid_ == iaid);
EXPECT_TRUE(lease->subnet_id_ == subnet_id);
EXPECT_TRUE(lease->type_ == Lease::TYPE_NA);
- EXPECT_TRUE(lease->preferred_lft_ == 100);
- EXPECT_TRUE(lease->valid_lft_ == 200);
+ EXPECT_TRUE(lease->preferred_lft_ == 100U);
+ EXPECT_TRUE(lease->valid_lft_ == 200U);
EXPECT_FALSE(lease->fqdn_fwd_);
EXPECT_FALSE(lease->fqdn_rev_);
EXPECT_TRUE(lease->hostname_.empty());
EXPECT_TRUE(lease->iaid_ == iaid);
EXPECT_TRUE(lease->subnet_id_ == subnet_id);
EXPECT_TRUE(lease->type_ == Lease::TYPE_NA);
- EXPECT_TRUE(lease->preferred_lft_ == 100);
- EXPECT_TRUE(lease->valid_lft_ == 200);
+ EXPECT_TRUE(lease->preferred_lft_ == 100U);
+ EXPECT_TRUE(lease->valid_lft_ == 200U);
EXPECT_TRUE(lease->fqdn_fwd_);
EXPECT_TRUE(lease->fqdn_rev_);
EXPECT_EQ("host.example.com.", lease->hostname_);
ASSERT_TRUE(lease.duid_);
ASSERT_EQ("00:00:00", lease.duid_->toText());
ASSERT_FALSE(lease.hwaddr_);
- EXPECT_EQ(0, lease.preferred_lft_);
+ EXPECT_EQ(0U, lease.preferred_lft_);
EXPECT_TRUE(now <= lease.cltt_);
EXPECT_TRUE(lease.cltt_ <= now + 1);
EXPECT_FALSE(lease.fqdn_fwd_);
EXPECT_FALSE(lease.fqdn_rev_);
EXPECT_EQ(Lease::STATE_DECLINED, lease.state_);
- EXPECT_EQ(123, lease.valid_lft_);
+ EXPECT_EQ(123U, lease.valid_lft_);
EXPECT_FALSE(lease.getContext());
}
ConstElementPtr ctx = l->get("user-context");
ASSERT_TRUE(ctx);
ASSERT_EQ(Element::map, ctx->getType());
- EXPECT_EQ(1, ctx->size());
+ EXPECT_EQ(1U, ctx->size());
ASSERT_TRUE(ctx->contains("comment"));
EXPECT_EQ("a comment", ctx->get("comment")->stringValue());
ASSERT_TRUE(lease);
EXPECT_EQ("2001:db8::1", lease->addr_.toText());
- EXPECT_EQ(5678, static_cast<uint32_t>(lease->subnet_id_));
- EXPECT_EQ(5, static_cast<uint32_t>(lease->pool_id_));
+ EXPECT_EQ(5678U, static_cast<uint32_t>(lease->subnet_id_));
+ EXPECT_EQ(5U, static_cast<uint32_t>(lease->pool_id_));
ASSERT_TRUE(lease->hwaddr_);
EXPECT_EQ("hwtype=1 08:00:2b:02:3f:4e", lease->hwaddr_->toText());
EXPECT_EQ(12345678, lease->cltt_);
EXPECT_EQ(lease->cltt_, lease->current_cltt_);
- EXPECT_EQ(800, lease->valid_lft_);
+ EXPECT_EQ(800U, lease->valid_lft_);
EXPECT_EQ(lease->valid_lft_, lease->current_valid_lft_);
EXPECT_FALSE(lease->fqdn_fwd_);
EXPECT_FALSE(lease->fqdn_rev_);
// IPv6 specific properties.
EXPECT_EQ(Lease::TYPE_NA, lease->type_);
- EXPECT_EQ(128, lease->prefixlen_);
- EXPECT_EQ(123456, lease->iaid_);
+ EXPECT_EQ(128U, lease->prefixlen_);
+ EXPECT_EQ(123456U, lease->iaid_);
ASSERT_TRUE(lease->duid_);
EXPECT_EQ("00:01:02:03:04:05:06:0a:0b:0c:0d:0e:0f", lease->duid_->toText());
- EXPECT_EQ(400, lease->preferred_lft_);
+ EXPECT_EQ(400U, lease->preferred_lft_);
}
// Verify that the IA_PD can be created from JSON.
ASSERT_TRUE(lease);
EXPECT_EQ("3000::", lease->addr_.toText());
- EXPECT_EQ(1234, static_cast<uint32_t>(lease->subnet_id_));
- EXPECT_EQ(5, static_cast<uint32_t>(lease->pool_id_));
+ EXPECT_EQ(1234U, static_cast<uint32_t>(lease->subnet_id_));
+ EXPECT_EQ(5U, static_cast<uint32_t>(lease->pool_id_));
ASSERT_TRUE(lease->hwaddr_);
EXPECT_EQ("hwtype=1 08:00:2b:02:3f:4e", lease->hwaddr_->toText());
EXPECT_EQ(12345678, lease->cltt_);
EXPECT_EQ(lease->cltt_, lease->current_cltt_);
- EXPECT_EQ(600, lease->valid_lft_);
+ EXPECT_EQ(600U, lease->valid_lft_);
EXPECT_EQ(lease->valid_lft_, lease->current_valid_lft_);
EXPECT_FALSE(lease->fqdn_fwd_);
EXPECT_FALSE(lease->fqdn_rev_);
// IPv6 specific properties.
EXPECT_EQ(Lease::TYPE_PD, lease->type_);
EXPECT_EQ(32, static_cast<int>(lease->prefixlen_));
- EXPECT_EQ(123456, lease->iaid_);
+ EXPECT_EQ(123456U, lease->iaid_);
ASSERT_TRUE(lease->duid_);
EXPECT_EQ("00:01:02:03:04:05:06:0a:0b:0c:0d:0e:0f", lease->duid_->toText());
- EXPECT_EQ(400, lease->preferred_lft_);
+ EXPECT_EQ(400U, lease->preferred_lft_);
}
// Verify that a registered Lease6 can be created from JSON.
MemfileExtendedInfoTest::testInitLease4() {
start(Memfile_LeaseMgr::V4);
initLease4();
- EXPECT_EQ(8, leases4.size());
+ EXPECT_EQ(8U, leases4.size());
Lease4Collection got;
EXPECT_NO_THROW(got = lease_mgr_->getLeases4());
ASSERT_EQ(leases4.size(), got.size());
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id2,
zero,
LeasePageSize(100)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Unknown relay id #2, now - 1000, now + 1000: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id2,
LeasePageSize(100),
now_ - 1000,
now_ + 1000));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Relay id #0, now - 2000, now - 1000: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
LeasePageSize(100),
now_ - 2000,
now_ - 1000));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Relay id #0, now + 1000, now + 2000: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
LeasePageSize(100),
now_ + 1000,
now_ + 2000));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Relay id #0: 3 entries (0, 2, 3, 4).
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
zero,
LeasePageSize(100)));
- ASSERT_EQ(4, got.size());
+ ASSERT_EQ(4U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[0]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
zero,
LeasePageSize(2)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[0]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
addr2,
LeasePageSize(2)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[3]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
addr4,
LeasePageSize(2)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Relay id #0, from now - 500: 3 entries (0, 2, 4).
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
zero,
LeasePageSize(100),
now_ - 500));
- ASSERT_EQ(3, got.size());
+ ASSERT_EQ(3U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[0]);
zero,
LeasePageSize(100),
0, now_ - 200));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[2]);
LeasePageSize(1),
now_ - 500,
now_ - 100));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[2]);
LeasePageSize(1),
now_ - 500,
now_ - 100));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[4]);
LeasePageSize(1),
now_ - 500,
now_ - 100));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
}
TEST_F(MemfileExtendedInfoTest, getLeases4ByRelayId) {
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id2,
zero,
LeasePageSize(100)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Unknown remote id #2, now - 1000, now + 1000: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id2,
LeasePageSize(100),
now_ - 1000,
now_ + 1000));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Remote id #0, now - 2000, now - 1000: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
LeasePageSize(100),
now_ - 2000,
now_ - 1000));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Remote id #0, now + 1000, now + 2000: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
LeasePageSize(100),
now_ + 1000,
now_ + 2000));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Remote id #0: 3 entries (0, 2, 3, 4).
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
zero,
LeasePageSize(100)));
- ASSERT_EQ(4, got.size());
+ ASSERT_EQ(4U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[0]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
zero,
LeasePageSize(2)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[0]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
addr2,
LeasePageSize(2)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[3]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
addr4,
LeasePageSize(2)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Remote id #0, from now - 500: 3 entries (0, 2, 4).
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
zero,
LeasePageSize(100),
now_ - 500));
- ASSERT_EQ(3, got.size());
+ ASSERT_EQ(3U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[0]);
zero,
LeasePageSize(100),
0, now_ - 200));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[2]);
LeasePageSize(1),
now_ - 500,
now_ - 100));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[2]);
LeasePageSize(1),
now_ - 500,
now_ - 100));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[4]);
LeasePageSize(1),
now_ - 500,
now_ - 100));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
}
TEST_F(MemfileExtendedInfoTest, getLeases4ByRemoteId) {
MemfileExtendedInfoTest::testInitLease6() {
start(Memfile_LeaseMgr::V6);
initLease6();
- EXPECT_EQ(8, leases6.size());
+ EXPECT_EQ(8U, leases6.size());
Lease6Collection got;
EXPECT_NO_THROW(got = lease_mgr_->getLeases6());
ASSERT_EQ(leases6.size(), got.size());
TEST_F(MemfileExtendedInfoTest, relayIdTable6) {
// Lease manager is created with empty tables.
start(Memfile_LeaseMgr::V6);
- EXPECT_EQ(0, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(0U, lease_mgr_->relay_id6_.size());
// Create parameter values.
IOAddress lease_addr0(ADDRESS6[0]);
EXPECT_NO_THROW(lease_mgr_->addRelayId6(lease_addr2, relay_id1));
// Check delete.
- EXPECT_EQ(6, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(6U, lease_mgr_->relay_id6_.size());
EXPECT_NO_THROW(lease_mgr_->deleteExtendedInfo6(other_lease_addr));
// No match so doing nothing.
- EXPECT_EQ(6, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(6U, lease_mgr_->relay_id6_.size());
EXPECT_NO_THROW(lease_mgr_->deleteExtendedInfo6(lease_addr0));
// Removed 3 entries.
- EXPECT_EQ(3, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(3U, lease_mgr_->relay_id6_.size());
EXPECT_NO_THROW(lease_mgr_->deleteExtendedInfo6(lease_addr0));
// Already removed: doing nothing again.
- EXPECT_EQ(3, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(3U, lease_mgr_->relay_id6_.size());
EXPECT_NO_THROW(lease_mgr_->deleteExtendedInfo6(lease_addr1));
// Removed 2 entries.
- EXPECT_EQ(1, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(1U, lease_mgr_->relay_id6_.size());
EXPECT_NO_THROW(lease_mgr_->deleteExtendedInfo6(lease_addr2));
// Removed last entry.
- EXPECT_EQ(0, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(0U, lease_mgr_->relay_id6_.size());
}
/// @brief Verifies that add and delete work on the by remote id table.
TEST_F(MemfileExtendedInfoTest, remoteIdTable6) {
// Lease manager is created with empty tables.
start(Memfile_LeaseMgr::V6);
- EXPECT_EQ(0, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(0U, lease_mgr_->remote_id6_.size());
// Create parameter values.
IOAddress lease_addr0(ADDRESS6[0]);
EXPECT_NO_THROW(lease_mgr_->addRemoteId6(lease_addr2, remote_id1));
// Check delete.
- EXPECT_EQ(6, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(6U, lease_mgr_->remote_id6_.size());
EXPECT_NO_THROW(lease_mgr_->deleteExtendedInfo6(other_lease_addr));
// No match so doing nothing.
- EXPECT_EQ(6, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(6U, lease_mgr_->remote_id6_.size());
EXPECT_NO_THROW(lease_mgr_->deleteExtendedInfo6(lease_addr0));
// Removed 3 entries.
- EXPECT_EQ(3, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(3U, lease_mgr_->remote_id6_.size());
EXPECT_NO_THROW(lease_mgr_->deleteExtendedInfo6(lease_addr0));
// Already removed: doing nothing again.
- EXPECT_EQ(3, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(3U, lease_mgr_->remote_id6_.size());
EXPECT_NO_THROW(lease_mgr_->deleteExtendedInfo6(lease_addr1));
// Removed 2 entries.
- EXPECT_EQ(1, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(1U, lease_mgr_->remote_id6_.size());
EXPECT_NO_THROW(lease_mgr_->deleteExtendedInfo6(lease_addr2));
// Removed last entry.
- EXPECT_EQ(0, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(0U, lease_mgr_->remote_id6_.size());
}
/// @brief Verifies that getLeases6ByRelayId works as expected.
// Lease manager is created with empty tables.
start(Memfile_LeaseMgr::V6);
initLease6();
- EXPECT_EQ(0, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(0U, lease_mgr_->relay_id6_.size());
// Create parameter values.
IOAddress lease_addr0(ADDRESS6[0]);
EXPECT_NO_THROW(lease_mgr_->addRelayId6(lease_addr1, relay_id_data0));
EXPECT_NO_THROW(lease_mgr_->addRelayId6(lease_addr1, relay_id_data1));
EXPECT_NO_THROW(lease_mgr_->addRelayId6(lease_addr2, relay_id_data1));
- EXPECT_EQ(6, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(6U, lease_mgr_->relay_id6_.size());
Lease6Collection got;
// Unknown relay id #2: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRelayId(relay_id2,
zero,
LeasePageSize(100)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Relay id #0: 3 entries but 2 addresses.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRelayId(relay_id0,
zero,
LeasePageSize(100)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
Lease6Ptr lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(lease_addr0, lease->addr_);
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRelayId(relay_id1,
zero,
LeasePageSize(2)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(lease_addr0, lease->addr_);
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRelayId(relay_id1,
lease->addr_,
LeasePageSize(2)));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(lease_addr2, lease->addr_);
// Lease manager is created with empty tables.
start(Memfile_LeaseMgr::V6);
initLease6();
- EXPECT_EQ(0, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(0U, lease_mgr_->remote_id6_.size());
// Create parameter values.
IOAddress lease_addr0(ADDRESS6[0]);
EXPECT_NO_THROW(lease_mgr_->addRemoteId6(lease_addr1, remote_id0));
EXPECT_NO_THROW(lease_mgr_->addRemoteId6(lease_addr1, remote_id1));
EXPECT_NO_THROW(lease_mgr_->addRemoteId6(lease_addr2, remote_id1));
- EXPECT_EQ(6, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(6U, lease_mgr_->remote_id6_.size());
Lease6Collection got;
// Unknown remote id #2: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRemoteId(remote_id2,
zero,
LeasePageSize(10)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Remote id #0: 3 entries but 2 addresses.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRemoteId(remote_id0,
zero,
LeasePageSize(10)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
Lease6Ptr lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(lease_addr0, lease->addr_);
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRemoteId(remote_id1,
zero,
LeasePageSize(2)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(lease_addr0, lease->addr_);
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRemoteId(remote_id1,
lease->addr_,
LeasePageSize(2)));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(lease_addr2, lease->addr_);
// Other link: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6(10, zero,
LeasePageSize(10)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Link: 8 entries.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6(1, zero,
LeasePageSize(10)));
- ASSERT_EQ(8, got.size());
+ ASSERT_EQ(8U, got.size());
Lease6Ptr lease;
for (size_t i = 0; i < 8; ++i) {
lease = got[i];
// Link: initial partial: 4 entries.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6(1, zero,
LeasePageSize(4)));
- ASSERT_EQ(4, got.size());
+ ASSERT_EQ(4U, got.size());
for (size_t i = 0; i < 4; ++i) {
lease = got[i];
ASSERT_TRUE(lease);
// Link: next partial: 4 entries.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6(1, lease->addr_,
LeasePageSize(4)));
- ASSERT_EQ(4, got.size());
+ ASSERT_EQ(4U, got.size());
for (size_t i = 0; i < 4; ++i) {
lease = got[i];
ASSERT_TRUE(lease);
// Link: further partial: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6(1, lease->addr_,
LeasePageSize(4)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
}
TEST_F(MemfileExtendedInfoTest, getLeases6ByLink) {
EXPECT_NO_THROW(lease_mgr_->addRelayId6(lease_addr, relay_id2));
EXPECT_NO_THROW(lease_mgr_->addRemoteId6(lease_addr, remote_id2));
- EXPECT_EQ(2, lease_mgr_->relay_id6_.size());
- EXPECT_EQ(2, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(2U, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(2U, lease_mgr_->remote_id6_.size());
// Delete the second lease: no side effect on tables.
Lease6Ptr lease = leases6[1];
EXPECT_NO_THROW(ret = lease_mgr_->deleteLease(lease));
EXPECT_TRUE(ret);
EXPECT_EQ(Lease6::ACTION_IGNORE, lease->extended_info_action_);
- EXPECT_EQ(2, lease_mgr_->relay_id6_.size());
- EXPECT_EQ(2, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(2U, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(2U, lease_mgr_->remote_id6_.size());
// Delete the first lease: tables are cleared.
lease = leases6[0];
EXPECT_NO_THROW(lease_mgr_->addRelayId6(lease_addr, relay_id));
EXPECT_NO_THROW(lease_mgr_->addRemoteId6(lease_addr, remote_id));
- EXPECT_EQ(1, lease_mgr_->relay_id6_.size());
- EXPECT_EQ(1, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(1U, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(1U, lease_mgr_->remote_id6_.size());
// Delete the first lease: tables are no longer cleared.
Lease6Ptr lease = leases6[0];
EXPECT_NO_THROW(ret = lease_mgr_->deleteLease(lease));
EXPECT_TRUE(ret);
EXPECT_EQ(Lease6::ACTION_IGNORE, lease->extended_info_action_);
- EXPECT_EQ(1, lease_mgr_->relay_id6_.size());
- EXPECT_EQ(1, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(1U, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(1U, lease_mgr_->remote_id6_.size());
}
/// @brief Verifies that v6 addLease adds references to extended info tables.
EXPECT_EQ(Lease6::ACTION_IGNORE, lease->extended_info_action_);
// Check extended info tables.
- ASSERT_EQ(1, lease_mgr_->relay_id6_.size());
+ ASSERT_EQ(1U, lease_mgr_->relay_id6_.size());
auto relay_id_it = lease_mgr_->relay_id6_.cbegin();
ASSERT_NE(relay_id_it, lease_mgr_->relay_id6_.cend());
Lease6ExtendedInfoPtr ex_info = *relay_id_it;
const vector<uint8_t>& exp_relay_id = vector<uint8_t>(8, 0x64);
EXPECT_EQ(exp_relay_id, relay_id);
- ASSERT_EQ(1, lease_mgr_->remote_id6_.size());
+ ASSERT_EQ(1U, lease_mgr_->remote_id6_.size());
auto remote_id_it = lease_mgr_->remote_id6_.cbegin();
ASSERT_NE(remote_id_it, lease_mgr_->remote_id6_.cend());
ex_info = *remote_id_it;
bool ret = false;
EXPECT_NO_THROW(ret = lease_mgr_->addLease(lease));
EXPECT_TRUE(ret);
- EXPECT_EQ(1, lease_mgr_->relay_id6_.size());
- EXPECT_EQ(1, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(1U, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(1U, lease_mgr_->remote_id6_.size());
// Set action and call updateLease6.
lease.reset(new Lease6(*lease));
bool ret = false;
EXPECT_NO_THROW(ret = lease_mgr_->addLease(lease));
EXPECT_TRUE(ret);
- EXPECT_EQ(1, lease_mgr_->relay_id6_.size());
- EXPECT_EQ(1, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(1U, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(1U, lease_mgr_->remote_id6_.size());
// Disable on the fly extended info tables.
// Note it is a priori an illegal operation so this could have to be
EXPECT_EQ(Lease6::ACTION_IGNORE, lease->extended_info_action_);
// Tables were not touched.
- EXPECT_EQ(1, lease_mgr_->relay_id6_.size());
- EXPECT_EQ(1, lease_mgr_->remote_id6_.size());
+ EXPECT_EQ(1U, lease_mgr_->relay_id6_.size());
+ EXPECT_EQ(1U, lease_mgr_->remote_id6_.size());
}
/// @brief Verifies that updateLease6 adds references to extended
EXPECT_EQ(Lease6::ACTION_IGNORE, lease->extended_info_action_);
// Tables were updated.
- ASSERT_EQ(1, lease_mgr_->relay_id6_.size());
+ ASSERT_EQ(1U, lease_mgr_->relay_id6_.size());
auto relay_id_it = lease_mgr_->relay_id6_.cbegin();
ASSERT_NE(relay_id_it, lease_mgr_->relay_id6_.cend());
Lease6ExtendedInfoPtr ex_info = *relay_id_it;
const vector<uint8_t>& exp_relay_id = vector<uint8_t>(8, 0x64);
EXPECT_EQ(exp_relay_id, relay_id);
- ASSERT_EQ(1, lease_mgr_->remote_id6_.size());
+ ASSERT_EQ(1U, lease_mgr_->remote_id6_.size());
auto remote_id_it = lease_mgr_->remote_id6_.cbegin();
ASSERT_NE(remote_id_it, lease_mgr_->remote_id6_.cend());
ex_info = *remote_id_it;
EXPECT_TRUE(ret);
// Verify updated extended info tables.
- ASSERT_EQ(1, lease_mgr_->relay_id6_.size());
+ ASSERT_EQ(1U, lease_mgr_->relay_id6_.size());
auto relay_id_it = lease_mgr_->relay_id6_.cbegin();
ASSERT_NE(relay_id_it, lease_mgr_->relay_id6_.cend());
Lease6ExtendedInfoPtr ex_info = *relay_id_it;
const vector<uint8_t>& exp_relay_id = vector<uint8_t>(8, 0x64);
EXPECT_EQ(exp_relay_id, relay_id);
- ASSERT_EQ(1, lease_mgr_->remote_id6_.size());
+ ASSERT_EQ(1U, lease_mgr_->remote_id6_.size());
auto remote_id_it = lease_mgr_->remote_id6_.cbegin();
ASSERT_NE(remote_id_it, lease_mgr_->remote_id6_.cend());
ex_info = *remote_id_it;
EXPECT_EQ(Lease6::ACTION_IGNORE, lease->extended_info_action_);
// Tables were updated.
- ASSERT_EQ(1, lease_mgr_->relay_id6_.size());
+ ASSERT_EQ(1U, lease_mgr_->relay_id6_.size());
relay_id_it = lease_mgr_->relay_id6_.cbegin();
ASSERT_NE(relay_id_it, lease_mgr_->relay_id6_.cend());
ex_info = *relay_id_it;
EXPECT_NE(exp_relay_id, relay_id2);
EXPECT_EQ(exp_relay_id2, relay_id2);
- ASSERT_EQ(1, lease_mgr_->remote_id6_.size());
+ ASSERT_EQ(1U, lease_mgr_->remote_id6_.size());
remote_id_it = lease_mgr_->remote_id6_.cbegin();
ASSERT_NE(remote_id_it, lease_mgr_->remote_id6_.cend());
ex_info = *remote_id_it;
// Add a lease with no classes. Should create no counts.
ASSERT_NO_THROW_LOG(clc_.addLease(lease));
- EXPECT_EQ(0, clc_.size(ltype));
+ EXPECT_EQ(0U, clc_.size(ltype));
// Remove the lease with no classes. Should create no counts.
ASSERT_NO_THROW_LOG(clc_.removeLease(lease));
- EXPECT_EQ(0, clc_.size(ltype));
+ EXPECT_EQ(0U, clc_.size(ltype));
// Add user-context with class list to lease.
lease->setContext(ctx1_);
// Fetching the count for a non-existent class
// should return 0.
- ASSERT_EQ(0, clc_.size());
+ ASSERT_EQ(0U, clc_.size());
size_t count = 0;
ASSERT_NO_THROW(count = clc_.getClassCount(melon));
- EXPECT_EQ(0, count);
+ EXPECT_EQ(0U, count);
// Calling adjustClassCount() for non-existent class
// should result in an entry with the adjustment value.
- ASSERT_EQ(0, clc_.size());
+ ASSERT_EQ(0U, clc_.size());
ASSERT_NO_THROW(clc_.adjustClassCount(melon, 1));
- EXPECT_EQ(1, clc_.size());
+ EXPECT_EQ(1U, clc_.size());
ASSERT_NO_THROW_LOG(count = clc_.getClassCount(melon));
- EXPECT_EQ(1, count);
+ EXPECT_EQ(1U, count);
// Calling adjust() again to add 1 should work.
ASSERT_NO_THROW(clc_.adjustClassCount(melon, 1));
ASSERT_NO_THROW(count = clc_.getClassCount(melon));
- EXPECT_EQ(2, count);
+ EXPECT_EQ(2U, count);
// Calling adjust() to subtract 1 should work.
ASSERT_NO_THROW(clc_.adjustClassCount(melon, -1));
ASSERT_NO_THROW(count = clc_.getClassCount(melon));
- EXPECT_EQ(1, count);
+ EXPECT_EQ(1U, count);
// Calling adjust() to subtract 2 should not rollover.
ASSERT_NO_THROW(clc_.adjustClassCount(melon, -2));
ASSERT_NO_THROW(count = clc_.getClassCount(melon));
- EXPECT_EQ(0, count);
+ EXPECT_EQ(0U, count);
// Set class value for a new class.
ASSERT_NO_THROW(clc_.setClassCount(water, 40));
- EXPECT_EQ(2, clc_.size());
+ EXPECT_EQ(2U, clc_.size());
ASSERT_NO_THROW(count = clc_.getClassCount(water));
- EXPECT_EQ(40, count);
+ EXPECT_EQ(40U, count);
// Should be able to adjust the new class entry.
ASSERT_NO_THROW(clc_.adjustClassCount(water, -1));
ASSERT_NO_THROW(count = clc_.getClassCount(water));
- EXPECT_EQ(39, count);
+ EXPECT_EQ(39U, count);
}
// Tests getting and adjusting basic class counts for
// Fetching the count for a non-existent class
// should return 0.
- ASSERT_EQ(0, clc_.size(Lease::TYPE_NA));
+ ASSERT_EQ(0U, clc_.size(Lease::TYPE_NA));
size_t count = 0;
ASSERT_NO_THROW(count = clc_.getClassCount(melon, Lease::TYPE_NA));
- EXPECT_EQ(0, count);
+ EXPECT_EQ(0U, count);
// Calling adjustClassCount() for non-existent class
// should result in an entry with the adjustment value.
ASSERT_NO_THROW(clc_.adjustClassCount(melon, 1, Lease::TYPE_NA));
- EXPECT_EQ(1, clc_.size(Lease::TYPE_NA));
+ EXPECT_EQ(1U, clc_.size(Lease::TYPE_NA));
ASSERT_NO_THROW_LOG(count = clc_.getClassCount(melon, Lease::TYPE_NA));
- EXPECT_EQ(1, count);
+ EXPECT_EQ(1U, count);
// Calling adjust() again to add 1 should work.
ASSERT_NO_THROW(clc_.adjustClassCount(melon, 1, Lease::TYPE_NA));
ASSERT_NO_THROW(count = clc_.getClassCount(melon, Lease::TYPE_NA));
- EXPECT_EQ(2, count);
+ EXPECT_EQ(2U, count);
// Calling adjust() to subtract 1 should work.
ASSERT_NO_THROW(clc_.adjustClassCount(melon, -1, Lease::TYPE_NA));
ASSERT_NO_THROW(count = clc_.getClassCount(melon, Lease::TYPE_NA));
- EXPECT_EQ(1, count);
+ EXPECT_EQ(1U, count);
// Calling adjust() to subtract 2 should not rollover.
ASSERT_NO_THROW(clc_.adjustClassCount(melon, -2, Lease::TYPE_NA));
ASSERT_NO_THROW(count = clc_.getClassCount(melon, Lease::TYPE_NA));
- EXPECT_EQ(0, count);
+ EXPECT_EQ(0U, count);
// Set class value for a new class.
ASSERT_NO_THROW(clc_.setClassCount(water, 40, Lease::TYPE_NA));
- EXPECT_EQ(2, clc_.size(Lease::TYPE_NA));
+ EXPECT_EQ(2U, clc_.size(Lease::TYPE_NA));
ASSERT_NO_THROW(count = clc_.getClassCount(water, Lease::TYPE_NA));
- EXPECT_EQ(40, count);
+ EXPECT_EQ(40U, count);
// Should be able to adjust the new class entry.
ASSERT_NO_THROW(clc_.adjustClassCount(water, -1, Lease::TYPE_NA));
ASSERT_NO_THROW(count = clc_.getClassCount(water, Lease::TYPE_NA));
- EXPECT_EQ(39, count);
+ EXPECT_EQ(39U, count);
// Existing class should be able to count prefixes independently.
ASSERT_NO_THROW(clc_.adjustClassCount(melon, 5, Lease::TYPE_PD));
- EXPECT_EQ(1, clc_.size(Lease::TYPE_PD));
+ EXPECT_EQ(1U, clc_.size(Lease::TYPE_PD));
ASSERT_NO_THROW(count = clc_.getClassCount(melon, Lease::TYPE_PD));
- EXPECT_EQ(5, count);
+ EXPECT_EQ(5U, count);
// Should be able to adjust the new class prefix entry.
ASSERT_NO_THROW(clc_.adjustClassCount(melon, -2, Lease::TYPE_PD));
ASSERT_NO_THROW(count = clc_.getClassCount(melon, Lease::TYPE_PD));
- EXPECT_EQ(3, count);
+ EXPECT_EQ(3U, count);
// Calling adjust() to subtract 4 should not rollover.
ASSERT_NO_THROW(clc_.adjustClassCount(melon, -4, Lease::TYPE_PD));
ASSERT_NO_THROW(count = clc_.getClassCount(melon, Lease::TYPE_PD));
- EXPECT_EQ(0, count);
+ EXPECT_EQ(0U, count);
}
// Exercises ClassLeaseCounter::getLeaseClientClasses()
auto recon = lease_mgr->reconnectCtl();
ASSERT_TRUE(recon);
EXPECT_EQ(recon->onFailAction(), OnFailAction::STOP_RETRY_EXIT);
- EXPECT_EQ(recon->maxRetries(), 0);
- EXPECT_EQ(recon->retryInterval(), 0);
+ EXPECT_EQ(recon->maxRetries(), 0U);
+ EXPECT_EQ(recon->retryInterval(), 0U);
pmap["on-fail"] = "stop-retry-exit";
ASSERT_NO_THROW(lease_mgr.reset(new Memfile_LeaseMgr(pmap)));
recon = lease_mgr->reconnectCtl();
ASSERT_TRUE(recon);
EXPECT_EQ(recon->onFailAction(), OnFailAction::STOP_RETRY_EXIT);
- EXPECT_EQ(recon->maxRetries(), 0);
- EXPECT_EQ(recon->retryInterval(), 0);
+ EXPECT_EQ(recon->maxRetries(), 0U);
+ EXPECT_EQ(recon->retryInterval(), 0U);
pmap["on-fail"] = "serve-retry-exit";
ASSERT_NO_THROW(lease_mgr.reset(new Memfile_LeaseMgr(pmap)));
recon = lease_mgr->reconnectCtl();
ASSERT_TRUE(recon);
EXPECT_EQ(recon->onFailAction(), OnFailAction::SERVE_RETRY_EXIT);
- EXPECT_EQ(recon->maxRetries(), 0);
- EXPECT_EQ(recon->retryInterval(), 0);
+ EXPECT_EQ(recon->maxRetries(), 0U);
+ EXPECT_EQ(recon->retryInterval(), 0U);
pmap["on-fail"] = "serve-retry-continue";
ASSERT_NO_THROW(lease_mgr.reset(new Memfile_LeaseMgr(pmap)));
recon = lease_mgr->reconnectCtl();
ASSERT_TRUE(recon);
EXPECT_EQ(recon->onFailAction(), OnFailAction::SERVE_RETRY_CONTINUE);
- EXPECT_EQ(recon->maxRetries(), 0);
- EXPECT_EQ(recon->retryInterval(), 0);
+ EXPECT_EQ(recon->maxRetries(), 0U);
+ EXPECT_EQ(recon->retryInterval(), 0U);
pmap["max-reconnect-tries"] = "5";
EXPECT_THROW_MSG(lease_mgr.reset(new Memfile_LeaseMgr(pmap)), BadValue,
recon = lease_mgr->reconnectCtl();
ASSERT_TRUE(recon);
- EXPECT_EQ(recon->maxRetries(), 0);
- EXPECT_EQ(recon->retryInterval(), 0);
+ EXPECT_EQ(recon->maxRetries(), 0U);
+ EXPECT_EQ(recon->retryInterval(), 0U);
pmap["reconnect-wait-time"] = "5";
EXPECT_THROW_MSG(lease_mgr.reset(new Memfile_LeaseMgr(pmap)), BadValue,
recon = lease_mgr->reconnectCtl();
ASSERT_TRUE(recon);
- EXPECT_EQ(recon->maxRetries(), 0);
- EXPECT_EQ(recon->retryInterval(), 0);
+ EXPECT_EQ(recon->maxRetries(), 0U);
+ EXPECT_EQ(recon->retryInterval(), 0U);
}
/// @brief Verifies that the supported path is the enforced.
// Retrieve lease by HW address.
Lease4Collection leases_by_hwaddr = lmptr_->getLease4(*tested->hwaddr_);
- ASSERT_EQ(1, leases_by_hwaddr.size());
+ ASSERT_EQ(1U, leases_by_hwaddr.size());
detailCompareLease(tested, leases_by_hwaddr[0]);
// Retrieve lease by client identifier.
Lease4Collection leases_by_client_id = lmptr_->getLease4(*tested->client_id_);
- ASSERT_EQ(1, leases_by_client_id.size());
+ ASSERT_EQ(1U, leases_by_client_id.size());
detailCompareLease(tested, leases_by_client_id[0]);
}
}
Lease6Collection leases_by_duid_iaid = lmptr_->getLeases6(tested->type_,
*tested->duid_,
tested->iaid_);
- ASSERT_EQ(1, leases_by_duid_iaid.size());
+ ASSERT_EQ(1U, leases_by_duid_iaid.size());
ASSERT_TRUE(leases_by_duid_iaid[0])
<< "Lease " << tested->addr_.toText()
<< " not found by getLease6(type, duid, iaid)"
Lease6Collection leases_by_duid_iaid_subnet =
lmptr_->getLeases6(tested->type_, *tested->duid_,
tested->iaid_, tested->subnet_id_);
- ASSERT_EQ(1, leases_by_duid_iaid_subnet.size());
+ ASSERT_EQ(1U, leases_by_duid_iaid_subnet.size());
ASSERT_TRUE(leases_by_duid_iaid_subnet[0])
<< "Lease " << tested->addr_.toText()
<< " not found by getLease6(type, duid, iaid, subnet_id)"
ASSERT_TRUE(memfile_mgr);
// Verify class lease counts are zero.
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("water"));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("melon"));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("slice"));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("water"));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("melon"));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("slice"));
// Structure that describes a recipe for a lease.
struct Recipe {
}
// Verify counts are as expected.
- EXPECT_EQ(1, memfile_mgr->getClassLeaseCount("water"));
- EXPECT_EQ(2, memfile_mgr->getClassLeaseCount("melon"));
- EXPECT_EQ(2, memfile_mgr->getClassLeaseCount("slice"));
+ EXPECT_EQ(1U, memfile_mgr->getClassLeaseCount("water"));
+ EXPECT_EQ(2U, memfile_mgr->getClassLeaseCount("melon"));
+ EXPECT_EQ(2U, memfile_mgr->getClassLeaseCount("slice"));
// Clear counts
ASSERT_NO_THROW_LOG(memfile_mgr->clearClassLeaseCounts());
// Verify counts are zero.
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("water"));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("melon"));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("slice"));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("water"));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("melon"));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("slice"));
// Recount
ASSERT_NO_THROW_LOG(memfile_mgr->recountClassLeases4());
// Verify counts are recounted correctly.
- EXPECT_EQ(1, memfile_mgr->getClassLeaseCount("water"));
- EXPECT_EQ(2, memfile_mgr->getClassLeaseCount("melon"));
- EXPECT_EQ(2, memfile_mgr->getClassLeaseCount("slice"));
+ EXPECT_EQ(1U, memfile_mgr->getClassLeaseCount("water"));
+ EXPECT_EQ(2U, memfile_mgr->getClassLeaseCount("melon"));
+ EXPECT_EQ(2U, memfile_mgr->getClassLeaseCount("slice"));
}
// Verifies that v6 class lease counts can be recounted.
ASSERT_TRUE(memfile_mgr);
// Verify class lease counts are zero.
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("water", Lease::TYPE_NA));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("melon", Lease::TYPE_NA));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_NA));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("water", Lease::TYPE_NA));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("melon", Lease::TYPE_NA));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_NA));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("grapes", Lease::TYPE_PD));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("wrath", Lease::TYPE_PD));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_PD));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("grapes", Lease::TYPE_PD));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("wrath", Lease::TYPE_PD));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_PD));
// Structure that describes a recipe for a lease.
struct Recipe {
}
// Verify counts are as expected.
- EXPECT_EQ(1, memfile_mgr->getClassLeaseCount("water", Lease::TYPE_NA));
- EXPECT_EQ(2, memfile_mgr->getClassLeaseCount("melon", Lease::TYPE_NA));
- EXPECT_EQ(2, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_NA));
+ EXPECT_EQ(1U, memfile_mgr->getClassLeaseCount("water", Lease::TYPE_NA));
+ EXPECT_EQ(2U, memfile_mgr->getClassLeaseCount("melon", Lease::TYPE_NA));
+ EXPECT_EQ(2U, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_NA));
- EXPECT_EQ(1, memfile_mgr->getClassLeaseCount("grapes", Lease::TYPE_PD));
- EXPECT_EQ(2, memfile_mgr->getClassLeaseCount("wrath", Lease::TYPE_PD));
- EXPECT_EQ(2, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_PD));
+ EXPECT_EQ(1U, memfile_mgr->getClassLeaseCount("grapes", Lease::TYPE_PD));
+ EXPECT_EQ(2U, memfile_mgr->getClassLeaseCount("wrath", Lease::TYPE_PD));
+ EXPECT_EQ(2U, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_PD));
// Clear counts
ASSERT_NO_THROW_LOG(memfile_mgr->clearClassLeaseCounts());
// Verify counts are zero.
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("water", Lease::TYPE_NA));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("melon", Lease::TYPE_NA));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_NA));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("water", Lease::TYPE_NA));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("melon", Lease::TYPE_NA));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_NA));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("grapes", Lease::TYPE_PD));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("wrath", Lease::TYPE_PD));
- EXPECT_EQ(0, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_PD));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("grapes", Lease::TYPE_PD));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("wrath", Lease::TYPE_PD));
+ EXPECT_EQ(0U, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_PD));
// Recount
ASSERT_NO_THROW_LOG(memfile_mgr->recountClassLeases6());
// Verify counts are recounted correctly.
- EXPECT_EQ(1, memfile_mgr->getClassLeaseCount("water", Lease::TYPE_NA));
- EXPECT_EQ(2, memfile_mgr->getClassLeaseCount("melon", Lease::TYPE_NA));
- EXPECT_EQ(2, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_NA));
+ EXPECT_EQ(1U, memfile_mgr->getClassLeaseCount("water", Lease::TYPE_NA));
+ EXPECT_EQ(2U, memfile_mgr->getClassLeaseCount("melon", Lease::TYPE_NA));
+ EXPECT_EQ(2U, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_NA));
- EXPECT_EQ(1, memfile_mgr->getClassLeaseCount("grapes", Lease::TYPE_PD));
- EXPECT_EQ(2, memfile_mgr->getClassLeaseCount("wrath", Lease::TYPE_PD));
- EXPECT_EQ(2, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_PD));
+ EXPECT_EQ(1U, memfile_mgr->getClassLeaseCount("grapes", Lease::TYPE_PD));
+ EXPECT_EQ(2U, memfile_mgr->getClassLeaseCount("wrath", Lease::TYPE_PD));
+ EXPECT_EQ(2U, memfile_mgr->getClassLeaseCount("slice", Lease::TYPE_PD));
}
/// @brief Class derived from @c Memfile_LeaseMgr to test write to file.
ConstElementPtr rai = isc->get("relay-agent-info");
ASSERT_TRUE(rai);
ASSERT_EQ(Element::map, rai->getType());
- EXPECT_EQ(3, rai->size());
+ EXPECT_EQ(3U, rai->size());
ConstElementPtr sub_options = rai->get("sub-options");
ASSERT_TRUE(sub_options);
EXPECT_EQ("\"0x02030102030C03AABBCC\"", sub_options->str());
EXPECT_NO_THROW(leases = lease_mgr->getLeases4ByRelayId(relay,
zero,
LeasePageSize(100)));
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_EQ(*lease, *leases[0]);
EXPECT_NO_THROW(leases = lease_mgr->getLeases4ByRemoteId(remote,
zero,
LeasePageSize(100)));
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_EQ(*lease, *leases[0]);
}
// Now run extractExtendedInfo4 with update set to true.
size_t updated = 0;
EXPECT_NO_THROW(updated = lease_mgr->extractExtendedInfo4(true, true));
- EXPECT_EQ(2, updated);
+ EXPECT_EQ(2U, updated);
// Check the lease with empty user context was updated.
lease = lease_mgr->getLease4(IOAddress("192.0.2.2"));
rai = isc->get("relay-agent-info");
ASSERT_TRUE(rai);
ASSERT_EQ(Element::map, rai->getType());
- EXPECT_EQ(3, rai->size());
+ EXPECT_EQ(3U, rai->size());
ConstElementPtr sub_options = rai->get("sub-options");
ASSERT_TRUE(sub_options);
EXPECT_EQ("\"0x02030102030C03AABBCC\"", sub_options->str());
EXPECT_NO_THROW(leases = lease_mgr->getLeases4ByRelayId(relay,
zero,
LeasePageSize(100)));
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_EQ(*lease, *leases[0]);
EXPECT_NO_THROW(leases = lease_mgr->getLeases4ByRemoteId(remote,
zero,
LeasePageSize(100)));
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
EXPECT_EQ(*lease, *leases[0]);
// Check the lease file was updated.
string new_content =
EXPECT_TRUE(isc->contains("relay-info"));
// Check that extended info tables were updated.
- ASSERT_EQ(1, lease_mgr->relay_id6_.size());
+ ASSERT_EQ(1U, lease_mgr->relay_id6_.size());
auto relay_id_it = lease_mgr->relay_id6_.cbegin();
ASSERT_NE(relay_id_it, lease_mgr->relay_id6_.cend());
Lease6ExtendedInfoPtr ex_info = *relay_id_it;
const vector<uint8_t>& exp_relay_id = vector<uint8_t>(8, 0x64);
EXPECT_EQ(exp_relay_id, ex_info->id_);
- ASSERT_EQ(1, lease_mgr->remote_id6_.size());
+ ASSERT_EQ(1U, lease_mgr->remote_id6_.size());
auto remote_id_it = lease_mgr->remote_id6_.cbegin();
ASSERT_NE(remote_id_it, lease_mgr->remote_id6_.cend());
ex_info = *remote_id_it;
EXPECT_TRUE(user_context->empty());
// Check that extended info tables were updated.
- ASSERT_EQ(1, lease_mgr->relay_id6_.size());
+ ASSERT_EQ(1U, lease_mgr->relay_id6_.size());
auto relay_id_it = lease_mgr->relay_id6_.cbegin();
ASSERT_NE(relay_id_it, lease_mgr->relay_id6_.cend());
Lease6ExtendedInfoPtr ex_info = *relay_id_it;
const vector<uint8_t>& exp_relay_id = vector<uint8_t>(8, 0x64);
EXPECT_EQ(exp_relay_id, ex_info->id_);
- ASSERT_EQ(1, lease_mgr->remote_id6_.size());
+ ASSERT_EQ(1U, lease_mgr->remote_id6_.size());
auto remote_id_it = lease_mgr->remote_id6_.cbegin();
ASSERT_NE(remote_id_it, lease_mgr->remote_id6_.cend());
ex_info = *remote_id_it;
EXPECT_NO_THROW(lease_mgr.reset(new NakedMemfileLeaseMgr(pmap)));
// Check that extended info tables were updated.
- EXPECT_EQ(1, lease_mgr->relay_id6_.size());
- EXPECT_EQ(1, lease_mgr->remote_id6_.size());
+ EXPECT_EQ(1U, lease_mgr->relay_id6_.size());
+ EXPECT_EQ(1U, lease_mgr->remote_id6_.size());
// Add a junk entry in each table.
IOAddress lease_addr("2001:db8:1::10");
lease_mgr->remote_id6_.insert(remote);
// Check that tables grown.
- EXPECT_EQ(2, lease_mgr->relay_id6_.size());
- EXPECT_EQ(2, lease_mgr->remote_id6_.size());
+ EXPECT_EQ(2U, lease_mgr->relay_id6_.size());
+ EXPECT_EQ(2U, lease_mgr->remote_id6_.size());
// Rebuild the tables.
EXPECT_NO_THROW(lease_mgr->buildExtendedInfoTables6());
// Check tables.
- ASSERT_EQ(1, lease_mgr->relay_id6_.size());
+ ASSERT_EQ(1U, lease_mgr->relay_id6_.size());
auto relay_id_it = lease_mgr->relay_id6_.cbegin();
ASSERT_NE(relay_id_it, lease_mgr->relay_id6_.cend());
Lease6ExtendedInfoPtr ex_info = *relay_id_it;
const vector<uint8_t>& exp_relay_id = vector<uint8_t>(8, 0x64);
EXPECT_EQ(exp_relay_id, ex_info->id_);
- ASSERT_EQ(1, lease_mgr->remote_id6_.size());
+ ASSERT_EQ(1U, lease_mgr->remote_id6_.size());
auto remote_id_it = lease_mgr->remote_id6_.cbegin();
ASSERT_NE(remote_id_it, lease_mgr->remote_id6_.cend());
ex_info = *remote_id_it;
<< " invalid path specified: '/tmp', supported path is '"
<< CfgMgr::instance().getDataDir() << "'";
- EXPECT_EQ(1, countFile(oss.str()));
+ EXPECT_EQ(1U, countFile(oss.str()));
}
/// @brief Verifies that lfcStartHandler requires persist true.
// Verify that LFC reschedule was not logged.
string msg = "DHCPSRV_MEMFILE_LFC_RESCHEDULED ";
msg += "rescheduled Lease File Cleanup";
- EXPECT_EQ(0, countFile(msg));
+ EXPECT_EQ(0U, countFile(msg));
// Verify that LFC start was not logged.
msg = "DHCPSRV_MEMFILE_LFC_START ";
msg += "starting Lease File Cleanup";
- EXPECT_EQ(0, countFile(msg));
+ EXPECT_EQ(0U, countFile(msg));
}
/// @brief Verifies that lfcStartHandler does not requires lfc-interval > 0.
// Verify that LFC reschedule was not logged.
string msg = "DHCPSRV_MEMFILE_LFC_RESCHEDULED ";
msg += "rescheduled Lease File Cleanup";
- EXPECT_EQ(0, countFile(msg));
+ EXPECT_EQ(0U, countFile(msg));
// Verify that LFC start was logged.
msg = "DHCPSRV_MEMFILE_LFC_START ";
msg += "starting Lease File Cleanup";
- EXPECT_EQ(1, countFile(msg));
+ EXPECT_EQ(1U, countFile(msg));
}
/// @brief Verifies that lfcStartHandler reschedules and starts LFC.
// Verify that LFC reschedule was logged.
string msg = "DHCPSRV_MEMFILE_LFC_RESCHEDULED ";
msg += "rescheduled Lease File Cleanup";
- EXPECT_EQ(1, countFile(msg));
+ EXPECT_EQ(1U, countFile(msg));
// Verify that LFC start was logged.
msg = "DHCPSRV_MEMFILE_LFC_START ";
msg += "starting Lease File Cleanup";
- EXPECT_EQ(1, countFile(msg));
+ EXPECT_EQ(1U, countFile(msg));
}
/// @brief Verifies that lfcStartHandler reschedules and but does not start
// Verify that LFC reschedule was logged.
string msg = "DHCPSRV_MEMFILE_LFC_RESCHEDULED ";
msg += "rescheduled Lease File Cleanup";
- EXPECT_EQ(1, countFile(msg));
+ EXPECT_EQ(1U, countFile(msg));
// Verify that LFC start was logged.
msg = "DHCPSRV_MEMFILE_LFC_START ";
msg += "starting Lease File Cleanup";
- EXPECT_EQ(1, countFile(msg));
+ EXPECT_EQ(1U, countFile(msg));
// Locked: verify that LFC running was logged.
msg = "DHCPSRV_MEMFILE_LFC_RUNNING ";
msg += "Lease File Cleanup instance already running";
- EXPECT_EQ(1, countFile(msg));
+ EXPECT_EQ(1U, countFile(msg));
}
/// @brief Verifies that lfcStartHandler reschedules and but does not start
// Verify that LFC reschedule was logged.
string msg = "DHCPSRV_MEMFILE_LFC_RESCHEDULED ";
msg += "rescheduled Lease File Cleanup";
- EXPECT_EQ(1, countFile(msg));
+ EXPECT_EQ(1U, countFile(msg));
// Verify that LFC start was logged.
msg = "DHCPSRV_MEMFILE_LFC_START ";
msg += "starting Lease File Cleanup";
- EXPECT_EQ(1, countFile(msg));
+ EXPECT_EQ(1U, countFile(msg));
// Verify that LFC running was logged.
msg = "DHCPSRV_MEMFILE_LFC_RUNNING ";
msg += "Lease File Cleanup instance already running";
- EXPECT_EQ(1, countFile(msg));
+ EXPECT_EQ(1U, countFile(msg));
}
/// @brief Verifies that lfcStartHandler reschedules and but does not start
// Verify that LFC reschedule was logged.
string msg = "DHCPSRV_MEMFILE_LFC_RESCHEDULED ";
msg += "rescheduled Lease File Cleanup";
- EXPECT_EQ(1, countFile(msg));
+ EXPECT_EQ(1U, countFile(msg));
// Verify that LFC start was logged.
msg = "DHCPSRV_MEMFILE_LFC_START ";
msg += "starting Lease File Cleanup";
- EXPECT_EQ(1, countFile(msg));
+ EXPECT_EQ(1U, countFile(msg));
// PID file is not writable: verify that PID create failure was logged.
msg = "DHCPSRV_MEMFILE_LFC_FAIL_PID_CREATE ";
msg += "Unable to open PID file '";
msg += pid_file_->getFilename();
msg += "' for write";
- EXPECT_EQ(1, countFile(msg));
+ EXPECT_EQ(1U, countFile(msg));
}
/// Check ProcessSpawnError (no known way to trigger it).
void testNoUpdate(const NameChangeType chg_type, const bool fwd, const bool rev,
const std::string& fqdn) {
ASSERT_NO_FATAL_FAILURE(sendNCR(chg_type, fwd, rev, fqdn));
- ASSERT_EQ(0, d2_mgr_.getQueueSize());
+ ASSERT_EQ(0U, d2_mgr_.getQueueSize());
}
/// @brief Test that sending an NCR while DNS updates would not throw.
// Queue NCR.
ASSERT_NO_FATAL_FAILURE(sendNCR(chg_type, fwd, rev, fqdn));
// Expecting one NCR be generated.
- ASSERT_EQ(1, d2_mgr_.getQueueSize());
+ ASSERT_EQ(1U, d2_mgr_.getQueueSize());
// Calculate expected ttl.
uint32_t ttl = calculateDdnsTtl(lease_->valid_lft_, ddns_ttl_percent,
void testNullLease(const NameChangeType chg_type) {
lease_.reset();
ASSERT_NO_FATAL_FAILURE(queueNCR(chg_type, lease_));
- EXPECT_EQ(0, d2_mgr_.getQueueSize());
+ EXPECT_EQ(0U, d2_mgr_.getQueueSize());
}
};
lease_->client_id_ = ClientId::fromText("01:01:01:01");
ASSERT_NO_FATAL_FAILURE(queueRemovalNCR(true, true, "myhost.example.com."));
- ASSERT_EQ(1, d2_mgr_.getQueueSize());
+ ASSERT_EQ(1U, d2_mgr_.getQueueSize());
uint32_t ttl = calculateDdnsTtl(lease_->valid_lft_);
verifyNameChangeRequest(isc::dhcp_ddns::CHG_REMOVE, true, true,
EXPECT_TRUE(net_child->getValid(Network::Inheritance::PARENT_NETWORK).unspecified());
EXPECT_TRUE(net_child->getValid(Network::Inheritance::GLOBAL).unspecified());
- EXPECT_EQ(12345, net_child->getValid(Network::Inheritance::NONE).get());
- EXPECT_EQ(12345, net_child->getValid().get());
+ EXPECT_EQ(12345U, net_child->getValid(Network::Inheritance::NONE).get());
+ EXPECT_EQ(12345U, net_child->getValid().get());
}
// Test that parent specific value is returned when the value
TestNetworkPtr net_parent(new TestNetwork());
net_parent->setValid(23456);
- EXPECT_EQ(23456, net_parent->getValid().get());
+ EXPECT_EQ(23456U, net_parent->getValid().get());
ASSERT_NO_THROW(net_child->setParent(net_parent));
EXPECT_FALSE(net_child->getValid(Network::Inheritance::PARENT_NETWORK).unspecified());
EXPECT_TRUE(net_child->getValid(Network::Inheritance::GLOBAL).unspecified());
- EXPECT_EQ(23456, net_child->getValid().get());
+ EXPECT_EQ(23456U, net_child->getValid().get());
}
// Test that value specified for the child network takes
TEST_F(NetworkTest, getPropertyParentChild) {
TestNetworkPtr net_child(new TestNetwork());
net_child->setValid(12345);
- EXPECT_EQ(12345, net_child->getValid().get());
+ EXPECT_EQ(12345U, net_child->getValid().get());
TestNetworkPtr net_parent(new TestNetwork());
net_parent->setValid(23456);
- EXPECT_EQ(23456, net_parent->getValid().get());
+ EXPECT_EQ(23456U, net_parent->getValid().get());
ASSERT_NO_THROW(net_child->setParent(net_parent));
EXPECT_FALSE(net_child->getValid(Network::Inheritance::PARENT_NETWORK).unspecified());
EXPECT_TRUE(net_child->getValid(Network::Inheritance::GLOBAL).unspecified());
- EXPECT_EQ(12345, net_child->getValid().get());
+ EXPECT_EQ(12345U, net_child->getValid().get());
}
// Test that global value is inherited if there is no network
EXPECT_TRUE(net_child->getValid(Network::Inheritance::PARENT_NETWORK).unspecified());
EXPECT_FALSE(net_child->getValid(Network::Inheritance::GLOBAL).unspecified());
- EXPECT_EQ(34567, net_child->getValid().get());
+ EXPECT_EQ(34567U, net_child->getValid().get());
}
// Test that getSiaddr() never fails.
EXPECT_FALSE(net->getValid().unspecified());
EXPECT_FALSE(net->getValid(Network::Inheritance::ALL).unspecified());
EXPECT_FALSE(net->getValid(Network::Inheritance::GLOBAL).unspecified());
- EXPECT_EQ(200, net->getValid().get());
- EXPECT_EQ(200, net->getValid(Network::Inheritance::ALL).get());
- EXPECT_EQ(200, net->getValid(Network::Inheritance::GLOBAL).get());
- EXPECT_EQ(200, net->getValid().getMin());
- EXPECT_EQ(200, net->getValid(Network::Inheritance::ALL).getMin());
- EXPECT_EQ(200, net->getValid(Network::Inheritance::GLOBAL).getMin());
- EXPECT_EQ(200, net->getValid().getMax());
- EXPECT_EQ(200, net->getValid(Network::Inheritance::ALL).getMax());
- EXPECT_EQ(200, net->getValid(Network::Inheritance::GLOBAL).getMax());
+ EXPECT_EQ(200U, net->getValid().get());
+ EXPECT_EQ(200U, net->getValid(Network::Inheritance::ALL).get());
+ EXPECT_EQ(200U, net->getValid(Network::Inheritance::GLOBAL).get());
+ EXPECT_EQ(200U, net->getValid().getMin());
+ EXPECT_EQ(200U, net->getValid(Network::Inheritance::ALL).getMin());
+ EXPECT_EQ(200U, net->getValid(Network::Inheritance::GLOBAL).getMin());
+ EXPECT_EQ(200U, net->getValid().getMax());
+ EXPECT_EQ(200U, net->getValid(Network::Inheritance::ALL).getMax());
+ EXPECT_EQ(200U, net->getValid(Network::Inheritance::GLOBAL).getMax());
// Set all valid lifetime global parameters.
globals_->set("min-valid-lifetime", Element::create(100));
EXPECT_FALSE(net->getValid().unspecified());
EXPECT_FALSE(net->getValid(Network::Inheritance::ALL).unspecified());
EXPECT_FALSE(net->getValid(Network::Inheritance::GLOBAL).unspecified());
- EXPECT_EQ(200, net->getValid().get());
- EXPECT_EQ(200, net->getValid(Network::Inheritance::ALL).get());
- EXPECT_EQ(200, net->getValid(Network::Inheritance::GLOBAL).get());
- EXPECT_EQ(100, net->getValid().getMin());
- EXPECT_EQ(100, net->getValid(Network::Inheritance::ALL).getMin());
- EXPECT_EQ(100, net->getValid(Network::Inheritance::GLOBAL).getMin());
- EXPECT_EQ(300, net->getValid().getMax());
- EXPECT_EQ(300, net->getValid(Network::Inheritance::ALL).getMax());
- EXPECT_EQ(300, net->getValid(Network::Inheritance::GLOBAL).getMax());
+ EXPECT_EQ(200U, net->getValid().get());
+ EXPECT_EQ(200U, net->getValid(Network::Inheritance::ALL).get());
+ EXPECT_EQ(200U, net->getValid(Network::Inheritance::GLOBAL).get());
+ EXPECT_EQ(100U, net->getValid().getMin());
+ EXPECT_EQ(100U, net->getValid(Network::Inheritance::ALL).getMin());
+ EXPECT_EQ(100U, net->getValid(Network::Inheritance::GLOBAL).getMin());
+ EXPECT_EQ(300U, net->getValid().getMax());
+ EXPECT_EQ(300U, net->getValid(Network::Inheritance::ALL).getMax());
+ EXPECT_EQ(300U, net->getValid(Network::Inheritance::GLOBAL).getMax());
}
}
// Checks if the number of possible leases in range is reported correctly.
TEST(Pool4Test, leasesCount) {
Pool4 pool1(IOAddress("192.0.2.10"), IOAddress("192.0.2.20"));
- EXPECT_EQ(11, pool1.getCapacity());
+ EXPECT_EQ(11U, pool1.getCapacity());
Pool4 pool2(IOAddress("192.0.2.0"), IOAddress("192.0.2.255"));
- EXPECT_EQ(256, pool2.getCapacity());
+ EXPECT_EQ(256U, pool2.getCapacity());
Pool4 pool3(IOAddress("192.168.0.0"), IOAddress("192.168.255.255"));
- EXPECT_EQ(65536, pool3.getCapacity());
+ EXPECT_EQ(65536U, pool3.getCapacity());
Pool4 pool4(IOAddress("10.0.0.0"), IOAddress("10.255.255.255"));
- EXPECT_EQ(16777216, pool4.getCapacity());
+ EXPECT_EQ(16777216U, pool4.getCapacity());
}
// Simple check if toText returns reasonable values
// Get options from the pool and check if all 10 are there.
OptionContainerPtr options = pool->getCfgOption()->getAll("dhcp4");
ASSERT_TRUE(options);
- ASSERT_EQ(10, options->size());
+ ASSERT_EQ(10U, options->size());
// Validate codes of options added to dhcp4 option space.
uint16_t expected_code = 100;
options = pool->getCfgOption()->getAll("isc");
ASSERT_TRUE(options);
- ASSERT_EQ(7, options->size());
+ ASSERT_EQ(7U, options->size());
// Validate codes of options added to isc option space.
expected_code = 105;
// Add the first class
pool->addAdditionalClass("router");
- EXPECT_EQ(1, pool->getAdditionalClasses().size());
+ EXPECT_EQ(1U, pool->getAdditionalClasses().size());
// Add a second class
pool->addAdditionalClass("modem");
- EXPECT_EQ(2, pool->getAdditionalClasses().size());
+ EXPECT_EQ(2U, pool->getAdditionalClasses().size());
EXPECT_TRUE(pool->getAdditionalClasses().contains("router"));
EXPECT_TRUE(pool->getAdditionalClasses().contains("modem"));
EXPECT_FALSE(pool->getAdditionalClasses().contains("foo"));
Pool6 pool1(Lease::TYPE_PD, IOAddress("2001:db8:1::"), 96, 112);
EXPECT_EQ(Lease::TYPE_PD, pool1.getType());
- EXPECT_EQ(112, pool1.getLength());
+ EXPECT_EQ(112U, pool1.getLength());
EXPECT_EQ("2001:db8:1::", pool1.getFirstAddress().toText());
EXPECT_EQ("2001:db8:1::ffff:ffff", pool1.getLastAddress().toText());
// Verify pool properties.
EXPECT_EQ(Lease::TYPE_PD, pool->getType());
- EXPECT_EQ(112, pool->getLength());
+ EXPECT_EQ(112U, pool->getLength());
EXPECT_EQ("2001:db8:1::", pool->getFirstAddress().toText());
EXPECT_EQ("2001:db8:1::ffff:ffff", pool->getLastAddress().toText());
ASSERT_TRUE(pd_exclude_option);
EXPECT_EQ("2001:db8:1::2:2000", pd_exclude_option->
getExcludedPrefix(IOAddress("2001:db8:1:0:0:0:2::"), 112).toText());
- EXPECT_EQ(120, static_cast<unsigned>(pd_exclude_option->getExcludedPrefixLength()));
+ EXPECT_EQ(120U,
+ static_cast<unsigned>(pd_exclude_option->getExcludedPrefixLength()));
// Create another pool instance, but with the excluded prefix being
// "unspecified".
IOAddress::IPV6_ZERO_ADDRESS(), 0)));
EXPECT_EQ(Lease::TYPE_PD, pool->getType());
- EXPECT_EQ(112, pool->getLength());
+ EXPECT_EQ(112U, pool->getLength());
EXPECT_EQ("2001:db8:1::", pool->getFirstAddress().toText());
EXPECT_EQ("2001:db8:1::ffff:ffff", pool->getLastAddress().toText());
TEST(Pool6Test, leasesCount) {
Pool6 pool1(Lease::TYPE_NA, IOAddress("2001:db8::1"),
IOAddress("2001:db8::2"));
- EXPECT_EQ(2, pool1.getCapacity());
+ EXPECT_EQ(2U, pool1.getCapacity());
Pool6 pool2(Lease::TYPE_PD, IOAddress("2001:db8:1::"), 96, 112);
- EXPECT_EQ(65536, pool2.getCapacity());
+ EXPECT_EQ(65536U, pool2.getCapacity());
}
// This test checks that it is possible to specify pool specific options.
// Get options from the pool and check if all 10 are there.
OptionContainerPtr options = pool->getCfgOption()->getAll("dhcp6");
ASSERT_TRUE(options);
- ASSERT_EQ(10, options->size());
+ ASSERT_EQ(10U, options->size());
// Validate codes of options added to dhcp6 option space.
uint16_t expected_code = 100;
options = pool->getCfgOption()->getAll("isc");
ASSERT_TRUE(options);
- ASSERT_EQ(7, options->size());
+ ASSERT_EQ(7U, options->size());
// Validate codes of options added to isc option space.
expected_code = 105;
// Add the first class
pool.addAdditionalClass("router");
- EXPECT_EQ(1, pool.getAdditionalClasses().size());
+ EXPECT_EQ(1U, pool.getAdditionalClasses().size());
// Add a second class
pool.addAdditionalClass("modem");
- EXPECT_EQ(2, pool.getAdditionalClasses().size());
+ EXPECT_EQ(2U, pool.getAdditionalClasses().size());
EXPECT_TRUE(pool.getAdditionalClasses().contains("router"));
EXPECT_TRUE(pool.getAdditionalClasses().contains("modem"));
EXPECT_FALSE(pool.getAdditionalClasses().contains("foo"));
addresses.insert(next);
}
// Make sure that unique addresses were returned.
- EXPECT_EQ(10, addresses.size());
+ EXPECT_EQ(10U, addresses.size());
}
// Test creating the random allocation state for an IPv6 pool.
addresses.insert(next);
}
// Make sure that unique addresses were returned.
- EXPECT_EQ(10, addresses.size());
+ EXPECT_EQ(10U, addresses.size());
}
// Test creating the random allocation state for an IPv6 prefix pool.
prefixes.insert(next);
}
// Make sure that unique prefixes were returned.
- EXPECT_EQ(10, prefixes.size());
+ EXPECT_EQ(10U, prefixes.size());
}
} // end of anonymous namespace
EXPECT_TRUE(subnet_->inPool(Lease::TYPE_V4, candidate, cc_));
}
// The pool comprises 10 addresses. All should be returned.
- EXPECT_EQ(10, addresses.size());
+ EXPECT_EQ(10U, addresses.size());
}
// Test allocating IPv4 addresses from multiple pools.
}
// There are ten pools with 10 addresses each.
- int total = 100;
+ size_t total = 100;
// Repeat allocation of all addresses several times. Make sure that
// the same addresses are returned when all pools are exhausted.
// Pick random addresses the number of times equal to the
// subnet capacity to ensure that all addresses are returned.
- for (auto i = 0; i < total; ++i) {
+ for (size_t i = 0; i < total; ++i) {
IOAddress candidate = alloc.pickAddress(cc_, clientid_, IOAddress("0.0.0.0"));
addresses_set.insert(candidate);
addresses_vector.push_back(candidate);
addresses_set.insert(candidate);
EXPECT_TRUE(pool1->inRange(candidate) || pool3->inRange(candidate));
}
- EXPECT_EQ(20, addresses_set.size());
+ EXPECT_EQ(20U, addresses_set.size());
addresses_set.clear();
addresses_set.insert(candidate);
EXPECT_TRUE(subnet_->inRange(candidate));
}
- EXPECT_EQ(40, addresses_set.size());
+ EXPECT_EQ(40U, addresses_set.size());
// When the client does not belong to any client class the allocator
// can't offer any address to the client.
EXPECT_TRUE(subnet_->inPool(Lease::TYPE_NA, candidate, cc_));
}
// The pool comprises 17 addresses. All should be returned.
- EXPECT_EQ(17, addresses.size());
+ EXPECT_EQ(17U, addresses.size());
}
// Test allocating IPv6 addresses from multiple pools.
// First pool (::10 - ::20) has 17 addresses.
// There are 8 extra pools with 16 addresses in each.
- int total = 17 + 8 * 16;
+ size_t total = 17 + 8 * 16;
// Repeat allocation of all addresses several times. Make sure that
// the same addresses are returned when all pools are exhausted.
// Pick random addresses the number of times equal to the
// subnet capacity to ensure that all addresses are returned.
- for (auto i = 0; i < total; ++i) {
+ for (size_t i = 0; i < total; ++i) {
IOAddress candidate = alloc.pickAddress(cc_, duid_, IOAddress("::"));
addresses_set.insert(candidate);
addresses_vector.push_back(candidate);
addresses_set.insert(candidate);
EXPECT_TRUE(pool1->inRange(candidate) || pool3->inRange(candidate));
}
- EXPECT_EQ(20, addresses_set.size());
+ EXPECT_EQ(20U, addresses_set.size());
addresses_set.clear();
addresses_set.insert(candidate);
EXPECT_TRUE(subnet_->inRange(candidate));
}
- EXPECT_EQ(47, addresses_set.size());
+ EXPECT_EQ(47U, addresses_set.size());
// When the client does not belong to any client class the allocator
// can't offer any address to the client.
EXPECT_TRUE(subnet_->inPool(Lease::TYPE_PD, candidate, cc_));
}
// The pool comprises 65536 prefixes. All should be returned.
- EXPECT_EQ(65536, prefixes.size());
+ EXPECT_EQ(65536U, prefixes.size());
}
// Test that the allocator still works with a single pd pool of a single prefix.
picked.emplace(picked_address);
}
- ASSERT_EQ(picked.size(), 6);
+ ASSERT_EQ(picked.size(), 6U);
ASSERT_TRUE(picked.count(IOAddress("192.0.1.0")));
ASSERT_TRUE(picked.count(IOAddress("192.0.1.1")));
ASSERT_TRUE(picked.count(IOAddress("192.0.2.0")));
picked.emplace(picked_address);
}
- ASSERT_EQ(picked.size(), 2);
+ ASSERT_EQ(picked.size(), 2U);
ASSERT_TRUE(picked.count(IOAddress("192.0.2.0")));
ASSERT_TRUE(picked.count(IOAddress("192.0.2.1")));
picked.emplace(picked_address);
}
- ASSERT_EQ(picked.size(), 4);
+ ASSERT_EQ(picked.size(), 4U);
ASSERT_TRUE(picked.count(IOAddress("192.0.1.0")));
ASSERT_TRUE(picked.count(IOAddress("192.0.1.1")));
ASSERT_TRUE(picked.count(IOAddress("192.0.3.0")));
picked.emplace(picked_address);
}
- ASSERT_EQ(picked.size(), 6);
+ ASSERT_EQ(picked.size(), 6U);
ASSERT_TRUE(picked.count(IOAddress("3001::10")));
ASSERT_TRUE(picked.count(IOAddress("3001::11")));
ASSERT_TRUE(picked.count(IOAddress("3001::20")));
picked.emplace(picked_address);
}
- ASSERT_EQ(picked.size(), 2);
+ ASSERT_EQ(picked.size(), 2U);
ASSERT_TRUE(picked.count(IOAddress("3001::20")));
ASSERT_TRUE(picked.count(IOAddress("3001::21")));
picked.emplace(picked_address);
}
- ASSERT_EQ(picked.size(), 4);
+ ASSERT_EQ(picked.size(), 4U);
ASSERT_TRUE(picked.count(IOAddress("3001::10")));
ASSERT_TRUE(picked.count(IOAddress("3001::11")));
ASSERT_TRUE(picked.count(IOAddress("3001::30")));
picked.emplace(picked_address);
}
- ASSERT_EQ(picked.size(), 6);
+ ASSERT_EQ(picked.size(), 6U);
ASSERT_TRUE(picked.count(IOAddress("2001::10")));
ASSERT_TRUE(picked.count(IOAddress("2001::11")));
ASSERT_TRUE(picked.count(IOAddress("2001::20")));
picked.emplace(picked_address);
}
- ASSERT_EQ(picked.size(), 2);
+ ASSERT_EQ(picked.size(), 2U);
ASSERT_TRUE(picked.count(IOAddress("2001::20")));
ASSERT_TRUE(picked.count(IOAddress("2001::21")));
picked.emplace(picked_address);
}
- ASSERT_EQ(picked.size(), 4);
+ ASSERT_EQ(picked.size(), 4U);
ASSERT_TRUE(picked.count(IOAddress("2001::10")));
ASSERT_TRUE(picked.count(IOAddress("2001::11")));
ASSERT_TRUE(picked.count(IOAddress("2001::30")));
EXPECT_EQ(network->getDdnsTtlPercent().unspecified(), (scenario.ddns_ttl_percent_ == 0.0));
EXPECT_EQ(network->getDdnsTtlPercent(), scenario.ddns_ttl_percent_);
- EXPECT_EQ(network->getDdnsTtl().unspecified(), (scenario.ddns_ttl_ == 0));
+ EXPECT_EQ(network->getDdnsTtl().unspecified(), (scenario.ddns_ttl_ == 0U));
EXPECT_EQ(network->getDdnsTtl(), scenario.ddns_ttl_);
- EXPECT_EQ(network->getDdnsTtlMin().unspecified(), (scenario.ddns_ttl_min_ == 0));
+ EXPECT_EQ(network->getDdnsTtlMin().unspecified(), (scenario.ddns_ttl_min_ == 0U));
EXPECT_EQ(network->getDdnsTtlMin(), scenario.ddns_ttl_min_);
- EXPECT_EQ(network->getDdnsTtlMax().unspecified(), (scenario.ddns_ttl_max_ == 0));
+ EXPECT_EQ(network->getDdnsTtlMax().unspecified(), (scenario.ddns_ttl_max_ == 0U));
EXPECT_EQ(network->getDdnsTtlMax(), scenario.ddns_ttl_max_);
}
}
EXPECT_TRUE(network->getClientClasses().contains("srv1"));
EXPECT_EQ("bird", network->getName());
EXPECT_EQ("eth1961", network->getIface().get());
- EXPECT_EQ(99, network->getT1().get());
- EXPECT_EQ(199, network->getT2().get());
- EXPECT_EQ(399, network->getValid().get());
- EXPECT_EQ(299, network->getValid().getMin());
- EXPECT_EQ(499, network->getValid().getMax());
+ EXPECT_EQ(99U, network->getT1().get());
+ EXPECT_EQ(199U, network->getT2().get());
+ EXPECT_EQ(399U, network->getValid().get());
+ EXPECT_EQ(299U, network->getValid().getMin());
+ EXPECT_EQ(499U, network->getValid().getMax());
EXPECT_TRUE(network->getCalculateTeeTimes());
EXPECT_EQ(0.345, network->getT1Percent());
EXPECT_EQ(0.721, network->getT2Percent());
EXPECT_EQ("x", network->getHostnameCharReplacement().get());
EXPECT_TRUE(network->getStoreExtendedInfo().get());
EXPECT_EQ(0.123, network->getCacheThreshold());
- EXPECT_EQ(123, network->getCacheMaxAge().get());
- EXPECT_EQ(777, network->getOfferLft().get());
+ EXPECT_EQ(123U, network->getCacheMaxAge().get());
+ EXPECT_EQ(777U, network->getOfferLft().get());
EXPECT_TRUE(network->getDdnsUpdateOnRenew().get());
EXPECT_EQ("iterative", network->getAllocatorType().get());
EXPECT_EQ(.90, network->getAdaptiveLeaseTimeThreshold().get());
// Relay information.
auto relay_info = network->getRelayInfo();
- EXPECT_EQ(1, relay_info.getAddresses().size());
+ EXPECT_EQ(1U, relay_info.getAddresses().size());
EXPECT_TRUE(relay_info.containsAddress(IOAddress("10.1.1.1")));
// Additional client classes.
auto additional = network->getAdditionalClasses();
- ASSERT_EQ(1, additional.size());
+ ASSERT_EQ(1U, additional.size());
EXPECT_EQ("runner", *additional.cbegin());
// Check user context.
Subnet4Ptr subnet = network->getSubnet(SubnetID(1));
ASSERT_TRUE(subnet);
EXPECT_EQ("10.1.2.0", subnet->get().first.toText());
- EXPECT_EQ(300, subnet->getValid().get());
- EXPECT_EQ(200, subnet->getValid().getMin());
- EXPECT_EQ(400, subnet->getValid().getMax());
+ EXPECT_EQ(300U, subnet->getValid().get());
+ EXPECT_EQ(200U, subnet->getValid().getMin());
+ EXPECT_EQ(400U, subnet->getValid().getMax());
EXPECT_FALSE(subnet->getHostnameCharSet().unspecified());
EXPECT_EQ("", subnet->getHostnameCharSet().get());
EXPECT_EQ("random", subnet->getAllocatorType().get());
subnet = network->getSubnet(SubnetID(2));
ASSERT_TRUE(subnet);
EXPECT_EQ("192.0.2.0", subnet->get().first.toText());
- EXPECT_EQ(30, subnet->getValid().get());
- EXPECT_EQ(30, subnet->getValid().getMin());
- EXPECT_EQ(30, subnet->getValid().getMax());
+ EXPECT_EQ(30U, subnet->getValid().get());
+ EXPECT_EQ(30U, subnet->getValid().getMin());
+ EXPECT_EQ(30U, subnet->getValid().getMax());
EXPECT_EQ("[^A-Z]", subnet->getHostnameCharSet().get());
EXPECT_EQ("x", subnet->getHostnameCharReplacement().get());
EXPECT_EQ("iterative", subnet->getAllocatorType().get());
Option4AddrLst>(opt_dns_servers.option_);
ASSERT_TRUE(dns_servers);
Option4AddrLst::AddressContainer addresses = dns_servers->getAddresses();
- ASSERT_EQ(1, addresses.size());
+ ASSERT_EQ(1U, addresses.size());
EXPECT_EQ("192.0.2.3", addresses[0].toText());
}
EXPECT_TRUE(network->getClientClasses().contains("srv1"));
EXPECT_EQ("bird", network->getName());
EXPECT_EQ("eth1961", network->getIface().get());
- EXPECT_EQ(211, network->getPreferred().get());
- EXPECT_EQ(111, network->getPreferred().getMin());
- EXPECT_EQ(311, network->getPreferred().getMax());
+ EXPECT_EQ(211U, network->getPreferred().get());
+ EXPECT_EQ(111U, network->getPreferred().getMin());
+ EXPECT_EQ(311U, network->getPreferred().getMax());
EXPECT_TRUE(network->getRapidCommit());
- EXPECT_EQ(99, network->getT1().get());
- EXPECT_EQ(199, network->getT2().get());
- EXPECT_EQ(399, network->getValid().get());
- EXPECT_EQ(299, network->getValid().getMin());
- EXPECT_EQ(499, network->getValid().getMax());
+ EXPECT_EQ(99U, network->getT1().get());
+ EXPECT_EQ(199U, network->getT2().get());
+ EXPECT_EQ(399U, network->getValid().get());
+ EXPECT_EQ(299U, network->getValid().getMin());
+ EXPECT_EQ(499U, network->getValid().getMax());
EXPECT_TRUE(network->getCalculateTeeTimes());
EXPECT_EQ(0.345, network->getT1Percent());
EXPECT_EQ(0.721, network->getT2Percent());
EXPECT_EQ("x", network->getHostnameCharReplacement().get());
EXPECT_TRUE(network->getStoreExtendedInfo().get());
EXPECT_EQ(0.123, network->getCacheThreshold());
- EXPECT_EQ(123, network->getCacheMaxAge().get());
+ EXPECT_EQ(123U, network->getCacheMaxAge().get());
EXPECT_TRUE(network->getDdnsUpdateOnRenew().get());
EXPECT_EQ("random", network->getAllocatorType().get());
EXPECT_EQ("iterative", network->getPdAllocatorType().get());
// Relay information.
auto relay_info = network->getRelayInfo();
- EXPECT_EQ(1, relay_info.getAddresses().size());
+ EXPECT_EQ(1U, relay_info.getAddresses().size());
EXPECT_TRUE(relay_info.containsAddress(IOAddress("2001:db8:1::1")));
// Additional client classes.
auto additional = network->getAdditionalClasses();
- ASSERT_EQ(1, additional.size());
+ ASSERT_EQ(1U, additional.size());
EXPECT_EQ("runner", *additional.cbegin());
// Check user context.
ConstElementPtr context = network->getContext();
ASSERT_TRUE(context);
- EXPECT_EQ(0, context->size());
+ EXPECT_EQ(0U, context->size());
// Subnet with id 1
Subnet6Ptr subnet = network->getSubnet(SubnetID(1));
ASSERT_TRUE(subnet);
EXPECT_EQ("3000::", subnet->get().first.toText());
- EXPECT_EQ(300, subnet->getPreferred().get());
- EXPECT_EQ(200, subnet->getPreferred().getMin());
- EXPECT_EQ(400, subnet->getPreferred().getMax());
- EXPECT_EQ(400, subnet->getValid().get());
- EXPECT_EQ(300, subnet->getValid().getMin());
- EXPECT_EQ(500, subnet->getValid().getMax());
+ EXPECT_EQ(300U, subnet->getPreferred().get());
+ EXPECT_EQ(200U, subnet->getPreferred().getMin());
+ EXPECT_EQ(400U, subnet->getPreferred().getMax());
+ EXPECT_EQ(400U, subnet->getValid().get());
+ EXPECT_EQ(300U, subnet->getValid().getMin());
+ EXPECT_EQ(500U, subnet->getValid().getMax());
EXPECT_FALSE(subnet->getHostnameCharSet().unspecified());
EXPECT_EQ("", subnet->getHostnameCharSet().get());
EXPECT_EQ("iterative", subnet->getAllocatorType().get());
subnet = network->getSubnet(SubnetID(2));
ASSERT_TRUE(subnet);
EXPECT_EQ("2001:db8:1::", subnet->get().first.toText());
- EXPECT_EQ(30, subnet->getPreferred().get());
- EXPECT_EQ(30, subnet->getPreferred().getMin());
- EXPECT_EQ(30, subnet->getPreferred().getMax());
- EXPECT_EQ(40, subnet->getValid().get());
- EXPECT_EQ(40, subnet->getValid().getMin());
- EXPECT_EQ(40, subnet->getValid().getMax());
+ EXPECT_EQ(30U, subnet->getPreferred().get());
+ EXPECT_EQ(30U, subnet->getPreferred().getMin());
+ EXPECT_EQ(30U, subnet->getPreferred().getMax());
+ EXPECT_EQ(40U, subnet->getValid().get());
+ EXPECT_EQ(40U, subnet->getValid().getMin());
+ EXPECT_EQ(40U, subnet->getValid().getMax());
EXPECT_EQ("[^A-Z]", subnet->getHostnameCharSet().get());
EXPECT_EQ("x", subnet->getHostnameCharReplacement().get());
EXPECT_EQ("random", subnet->getAllocatorType().get());
Option6AddrLst>(opt_dns_servers.option_);
ASSERT_TRUE(dns_servers);
Option6AddrLst::AddressContainer addresses = dns_servers->getAddresses();
- ASSERT_EQ(1, addresses.size());
+ ASSERT_EQ(1U, addresses.size());
EXPECT_EQ("2001:db8:1::cafe", addresses[0].toText());
}
ASSERT_TRUE(network);
const ClientClasses& classes = network->getAdditionalClasses();
- EXPECT_EQ(2, classes.size());
+ EXPECT_EQ(2U, classes.size());
EXPECT_EQ("alpha, beta", classes.toText());
}
ASSERT_TRUE(network);
const auto cclasses = network->getAdditionalClasses();
- EXPECT_EQ(cclasses.size(), 2);
+ EXPECT_EQ(cclasses.size(), 2U);
auto cclass = cclasses.begin();
EXPECT_EQ(*cclass, "one");
++cclass;
ASSERT_TRUE(network);
const auto cclasses = network->getAdditionalClasses();
- EXPECT_EQ(cclasses.size(), 2);
+ EXPECT_EQ(cclasses.size(), 2U);
auto cclass = cclasses.begin();
EXPECT_EQ(*cclass, "one");
++cclass;
ASSERT_TRUE(network);
const auto cclasses = network->getClientClasses();
- EXPECT_EQ(cclasses.size(), 1);
+ EXPECT_EQ(cclasses.size(), 1U);
auto cclass = cclasses.begin();
EXPECT_EQ(*cclass, "one");
ASSERT_TRUE(network);
const auto cclasses = network->getClientClasses();
- EXPECT_EQ(cclasses.size(), 1);
+ EXPECT_EQ(cclasses.size(), 1U);
auto cclass = cclasses.begin();
EXPECT_EQ(*cclass, "one");
EXPECT_TRUE(network->getClientClasses().empty());
EXPECT_TRUE(network->getValid().unspecified());
- EXPECT_EQ(0, network->getValid().get());
+ EXPECT_EQ(0U, network->getValid().get());
EXPECT_TRUE(network->getT1().unspecified());
- EXPECT_EQ(0, network->getT1().get());
+ EXPECT_EQ(0U, network->getT1().get());
EXPECT_TRUE(network->getT2().unspecified());
- EXPECT_EQ(0, network->getT2().get());
+ EXPECT_EQ(0U, network->getT2().get());
EXPECT_TRUE(network->getReservationsGlobal().unspecified());
EXPECT_FALSE(network->getReservationsGlobal().get());
subnet.reset(new Subnet4(IOAddress("10.0.0.0"), 8, 10, 20, 30,
SubnetID(15)));
ASSERT_NO_THROW(network->add(subnet));
- ASSERT_EQ(1, network->getAllSubnets()->size());
+ ASSERT_EQ(1U, network->getAllSubnets()->size());
// Retrieve the subnet from the network and make sure it is returned
// as expected.
subnet.reset(new Subnet4(IOAddress("192.168.1.0"), 24, 10, 20, 30,
SubnetID(10)));
ASSERT_NO_THROW(network->add(subnet));
- ASSERT_EQ(3, network->getAllSubnets()->size());
+ ASSERT_EQ(3U, network->getAllSubnets()->size());
// Create another subnet with another ID. Replace should return false.
subnet.reset(new Subnet4(IOAddress("192.168.2.0"), 24, 10, 20, 30,
EXPECT_FALSE(network->replace(subnet));
// Subnets did not change.
- ASSERT_EQ(3, network->getAllSubnets()->size());
+ ASSERT_EQ(3U, network->getAllSubnets()->size());
auto returned_it = network->getAllSubnets()->begin();
Subnet4Ptr returned_subnet = *returned_it;
ASSERT_TRUE(returned_subnet);
- EXPECT_EQ(1, returned_subnet->getID());
+ EXPECT_EQ(1U, returned_subnet->getID());
++returned_it;
returned_subnet = *returned_it;
ASSERT_TRUE(returned_subnet);
- EXPECT_EQ(10, returned_subnet->getID());
+ EXPECT_EQ(10U, returned_subnet->getID());
++returned_it;
returned_subnet = *returned_it;
ASSERT_TRUE(returned_subnet);
- EXPECT_EQ(15, returned_subnet->getID());
+ EXPECT_EQ(15U, returned_subnet->getID());
// Reset the returned subnet to the subnet with subnet id 1.
returned_subnet = *network->getAllSubnets()->begin();
ASSERT_TRUE(returned_subnet);
- ASSERT_EQ(1, returned_subnet->getID());
+ ASSERT_EQ(1U, returned_subnet->getID());
// Create another subnet with the same ID than the second subnet.
subnet.reset(new Subnet4(IOAddress("192.168.0.0"), 24, 100, 200, 300,
EXPECT_TRUE(network->replace(subnet));
// Second subnet was updated.
- EXPECT_EQ(10, returned_subnet->getT1().get());
- EXPECT_EQ(20, returned_subnet->getT2().get());
- EXPECT_EQ(30, returned_subnet->getValid().get());
+ EXPECT_EQ(10U, returned_subnet->getT1().get());
+ EXPECT_EQ(20U, returned_subnet->getT2().get());
+ EXPECT_EQ(30U, returned_subnet->getValid().get());
SharedNetwork4Ptr network1;
returned_subnet->getSharedNetwork(network1);
EXPECT_FALSE(network1);
- ASSERT_EQ(3, network->getAllSubnets()->size());
+ ASSERT_EQ(3U, network->getAllSubnets()->size());
returned_subnet = *network->getAllSubnets()->begin();
ASSERT_TRUE(returned_subnet);
- ASSERT_EQ(1, returned_subnet->getID());
- EXPECT_EQ(100, returned_subnet->getT1().get());
- EXPECT_EQ(200, returned_subnet->getT2().get());
- EXPECT_EQ(300, returned_subnet->getValid().get());
+ ASSERT_EQ(1U, returned_subnet->getID());
+ EXPECT_EQ(100U, returned_subnet->getT1().get());
+ EXPECT_EQ(200U, returned_subnet->getT2().get());
+ EXPECT_EQ(300U, returned_subnet->getValid().get());
returned_subnet->getSharedNetwork(network1);
EXPECT_TRUE(network1);
EXPECT_TRUE(network == network1);
returned_it = network->getAllSubnets()->begin();
returned_subnet = *++returned_it;
ASSERT_TRUE(returned_subnet);
- EXPECT_EQ(10, returned_subnet->getID());
+ EXPECT_EQ(10U, returned_subnet->getID());
returned_subnet = *++returned_it;
ASSERT_TRUE(returned_subnet);
- EXPECT_EQ(15, returned_subnet->getID());
+ EXPECT_EQ(15U, returned_subnet->getID());
// Create another network and try to replace a subnet to it. It should fail
// because the subnet is already associated with the first network.
subnet.reset(new Subnet4(IOAddress("192.168.10.0"), 24, 100, 200, 300,
SubnetID(1)));
EXPECT_TRUE(network->replace(subnet));
- ASSERT_EQ(3, network->getAllSubnets()->size());
+ ASSERT_EQ(3U, network->getAllSubnets()->size());
returned_subnet = *network->getAllSubnets()->begin();
ASSERT_TRUE(returned_subnet);
- ASSERT_EQ(1, returned_subnet->getID());
+ ASSERT_EQ(1U, returned_subnet->getID());
EXPECT_EQ("192.168.10.0/24", returned_subnet->toText());
// but not if the prefix already exists for another subnet.
subnet.reset(new Subnet4(IOAddress("192.168.1.0"), 24, 100, 200, 300,
SubnetID(1)));
EXPECT_FALSE(network->replace(subnet));
- ASSERT_EQ(3, network->getAllSubnets()->size());
+ ASSERT_EQ(3U, network->getAllSubnets()->size());
returned_subnet = *network->getAllSubnets()->begin();
ASSERT_TRUE(returned_subnet);
- ASSERT_EQ(1, returned_subnet->getID());
+ ASSERT_EQ(1U, returned_subnet->getID());
EXPECT_EQ("192.168.10.0/24", returned_subnet->toText());
}
ASSERT_NO_THROW(network->add(subnet2));
// Make sure they have been added successfully.
- ASSERT_EQ(2, network->getAllSubnets()->size());
+ ASSERT_EQ(2U, network->getAllSubnets()->size());
// Try to remove a subnet that doesn't exist in this shared network.
// It should cause an error.
// Now delete the subnet that exists.
ASSERT_NO_THROW(network->del(subnet1->getID()));
// We should be left with only one subnet.
- ASSERT_EQ(1, network->getAllSubnets()->size());
+ ASSERT_EQ(1U, network->getAllSubnets()->size());
Subnet4Ptr subnet_returned = *network->getAllSubnets()->begin();
ASSERT_TRUE(subnet_returned);
EXPECT_EQ(subnet2->getID(), subnet_returned->getID());
// Remove another subnet and make sure there are no subnets left.
ASSERT_NO_THROW(network->del(subnet2->getID()));
- EXPECT_EQ(0, network->getAllSubnets()->size());
+ EXPECT_EQ(0U, network->getAllSubnets()->size());
// The network pointer should be cleared for this second subnet too.
SharedNetwork4Ptr network2;
ASSERT_NO_THROW(network->add(subnet2));
// Make sure they have been added successfully.
- ASSERT_EQ(2, network->getAllSubnets()->size());
+ ASSERT_EQ(2U, network->getAllSubnets()->size());
ASSERT_NO_THROW(network->delAll());
// Now check that there are no subnets.
- ASSERT_EQ(0, network->getAllSubnets()->size());
+ ASSERT_EQ(0U, network->getAllSubnets()->size());
}
// This test verifies that the SharedNetwork6 factory function creates a
EXPECT_TRUE(network->getClientClasses().empty());
EXPECT_TRUE(network->getValid().unspecified());
- EXPECT_EQ(0, network->getValid().get());
+ EXPECT_EQ(0U, network->getValid().get());
EXPECT_TRUE(network->getT1().unspecified());
- EXPECT_EQ(0, network->getT1().get());
+ EXPECT_EQ(0U, network->getT1().get());
EXPECT_TRUE(network->getT2().unspecified());
- EXPECT_EQ(0, network->getT2().get());
+ EXPECT_EQ(0U, network->getT2().get());
EXPECT_TRUE(network->getReservationsGlobal().unspecified());
EXPECT_FALSE(network->getReservationsGlobal().get());
EXPECT_EQ(0.0, network->getT2Percent().get());
EXPECT_TRUE(network->getPreferred().unspecified());
- EXPECT_EQ(0, network->getPreferred().get());
+ EXPECT_EQ(0U, network->getPreferred().get());
EXPECT_TRUE(network->getRapidCommit().unspecified());
EXPECT_FALSE(network->getRapidCommit().get());
subnet.reset(new Subnet6(IOAddress("2001:db8:1::"), 64, 10, 20, 30, 40,
SubnetID(15)));
ASSERT_NO_THROW(network->add(subnet));
- ASSERT_EQ(1, network->getAllSubnets()->size());
+ ASSERT_EQ(1U, network->getAllSubnets()->size());
// Retrieve the subnet from the network and make sure it is returned
// as expected.
subnet.reset(new Subnet6(IOAddress("2001:db8:3::"), 64, 10, 20, 30, 40,
SubnetID(10)));
ASSERT_NO_THROW(network->add(subnet));
- ASSERT_EQ(3, network->getAllSubnets()->size());
+ ASSERT_EQ(3U, network->getAllSubnets()->size());
// Create another subnet with another ID. Replace should return false.
subnet.reset(new Subnet6(IOAddress("2001:db8:4::1"), 64, 10, 20, 30, 40,
EXPECT_FALSE(network->replace(subnet));
// Subnets did not change.
- ASSERT_EQ(3, network->getAllSubnets()->size());
+ ASSERT_EQ(3U, network->getAllSubnets()->size());
auto returned_it = network->getAllSubnets()->begin();
Subnet6Ptr returned_subnet = *returned_it;
ASSERT_TRUE(returned_subnet);
- EXPECT_EQ(1, returned_subnet->getID());
+ EXPECT_EQ(1U, returned_subnet->getID());
++returned_it;
returned_subnet = *returned_it;
ASSERT_TRUE(returned_subnet);
- EXPECT_EQ(10, returned_subnet->getID());
+ EXPECT_EQ(10U, returned_subnet->getID());
++returned_it;
returned_subnet = *returned_it;
ASSERT_TRUE(returned_subnet);
- EXPECT_EQ(15, returned_subnet->getID());
+ EXPECT_EQ(15U, returned_subnet->getID());
// Reset the returned subnet to the subnet with subnet id 1.
returned_subnet = *network->getAllSubnets()->begin();
ASSERT_TRUE(returned_subnet);
- ASSERT_EQ(1, returned_subnet->getID());
+ ASSERT_EQ(1U, returned_subnet->getID());
// Create another subnet with the same ID than the second subnet.
subnet.reset(new Subnet6(IOAddress("2001:db8:2::"), 64, 100, 200, 300, 400,
EXPECT_TRUE(network->replace(subnet));
// Second subnet was updated.
- EXPECT_EQ(10, returned_subnet->getT1().get());
- EXPECT_EQ(20, returned_subnet->getT2().get());
- EXPECT_EQ(30, returned_subnet->getPreferred().get());
- EXPECT_EQ(40, returned_subnet->getValid().get());
+ EXPECT_EQ(10U, returned_subnet->getT1().get());
+ EXPECT_EQ(20U, returned_subnet->getT2().get());
+ EXPECT_EQ(30U, returned_subnet->getPreferred().get());
+ EXPECT_EQ(40U, returned_subnet->getValid().get());
SharedNetwork6Ptr network1;
returned_subnet->getSharedNetwork(network1);
EXPECT_FALSE(network1);
- ASSERT_EQ(3, network->getAllSubnets()->size());
+ ASSERT_EQ(3U, network->getAllSubnets()->size());
returned_subnet = *network->getAllSubnets()->begin();
ASSERT_TRUE(returned_subnet);
- ASSERT_EQ(1, returned_subnet->getID());
- EXPECT_EQ(100, returned_subnet->getT1().get());
- EXPECT_EQ(200, returned_subnet->getT2().get());
- EXPECT_EQ(300, returned_subnet->getPreferred().get());
- EXPECT_EQ(400, returned_subnet->getValid().get());
+ ASSERT_EQ(1U, returned_subnet->getID());
+ EXPECT_EQ(100U, returned_subnet->getT1().get());
+ EXPECT_EQ(200U, returned_subnet->getT2().get());
+ EXPECT_EQ(300U, returned_subnet->getPreferred().get());
+ EXPECT_EQ(400U, returned_subnet->getValid().get());
returned_subnet->getSharedNetwork(network1);
EXPECT_TRUE(network1);
EXPECT_TRUE(network == network1);
returned_it = network->getAllSubnets()->begin();
returned_subnet = *++returned_it;
ASSERT_TRUE(returned_subnet);
- EXPECT_EQ(10, returned_subnet->getID());
+ EXPECT_EQ(10U, returned_subnet->getID());
returned_subnet = *++returned_it;
ASSERT_TRUE(returned_subnet);
- EXPECT_EQ(15, returned_subnet->getID());
+ EXPECT_EQ(15U, returned_subnet->getID());
// Create another network and try to replace a subnet to it. It should fail
// because the subnet is already associated with the first network.
subnet.reset(new Subnet6(IOAddress("2001:db8:10::"), 64, 100, 200, 300,
400, SubnetID(1)));
EXPECT_TRUE(network->replace(subnet));
- ASSERT_EQ(3, network->getAllSubnets()->size());
+ ASSERT_EQ(3U, network->getAllSubnets()->size());
returned_subnet = *network->getAllSubnets()->begin();
ASSERT_TRUE(returned_subnet);
- ASSERT_EQ(1, returned_subnet->getID());
+ ASSERT_EQ(1U, returned_subnet->getID());
EXPECT_EQ("2001:db8:10::/64", returned_subnet->toText());
// but not if the prefix already exists for another subnet.
subnet.reset(new Subnet6(IOAddress("2001:db8:3::"), 64, 100, 200, 300, 400,
SubnetID(1)));
EXPECT_FALSE(network->replace(subnet));
- ASSERT_EQ(3, network->getAllSubnets()->size());
+ ASSERT_EQ(3U, network->getAllSubnets()->size());
returned_subnet = *network->getAllSubnets()->begin();
ASSERT_TRUE(returned_subnet);
- ASSERT_EQ(1, returned_subnet->getID());
+ ASSERT_EQ(1U, returned_subnet->getID());
EXPECT_EQ("2001:db8:10::/64", returned_subnet->toText());
}
ASSERT_NO_THROW(network->add(subnet2));
// Make sure they have been added successfully.
- ASSERT_EQ(2, network->getAllSubnets()->size());
+ ASSERT_EQ(2U, network->getAllSubnets()->size());
// Try to remove a subnet that doesn't exist in this shared network.
// It should cause an error.
// Now delete the subnet that exists.
ASSERT_NO_THROW(network->del(subnet1->getID()));
// We should be left with only one subnet.
- ASSERT_EQ(1, network->getAllSubnets()->size());
+ ASSERT_EQ(1U, network->getAllSubnets()->size());
Subnet6Ptr subnet_returned = *network->getAllSubnets()->begin();
ASSERT_TRUE(subnet_returned);
EXPECT_EQ(subnet2->getID(), subnet_returned->getID());
// Remove another subnet and make sure there are no subnets left.
ASSERT_NO_THROW(network->del(subnet2->getID()));
- EXPECT_EQ(0, network->getAllSubnets()->size());
+ EXPECT_EQ(0U, network->getAllSubnets()->size());
// The network pointer should be cleared for this second subnet too.
SharedNetwork6Ptr network2;
ASSERT_NO_THROW(network->add(subnet2));
// Make sure they have been added successfully.
- ASSERT_EQ(2, network->getAllSubnets()->size());
+ ASSERT_EQ(2U, network->getAllSubnets()->size());
ASSERT_NO_THROW(network->delAll());
// Now check that there are no subnets.
- ASSERT_EQ(0, network->getAllSubnets()->size());
+ ASSERT_EQ(0U, network->getAllSubnets()->size());
}
// This test verifies that the IPv4 shared network can be fetched by name.
EXPECT_EQ("monkey", network2->getName());
EXPECT_EQ("eth1", network2->getIface().get());
ASSERT_TRUE(network2->getContext());
- EXPECT_EQ(1, network2->getContext()->size());
+ EXPECT_EQ(1U, network2->getContext()->size());
EXPECT_TRUE(network2->getContext()->get("comment"));
}
EXPECT_EQ("some-logfile.txt", conf_.getLoggingInfo()[0].destinations_[0].output_);
EXPECT_EQ(5, conf_.getLoggingInfo()[0].destinations_[0].maxver_);
- EXPECT_EQ(2097152, conf_.getLoggingInfo()[0].destinations_[0].maxsize_);
+ EXPECT_EQ(2097152U, conf_.getLoggingInfo()[0].destinations_[0].maxsize_);
}
// Check that the configuration summary including information about the status
// Upon construction the dictionary should be empty.
ASSERT_TRUE(d1 = conf.getClientClassDictionary());
- EXPECT_EQ(0, d1->getClasses()->size());
+ EXPECT_EQ(0U, d1->getClasses()->size());
// Verify we can replace it with a new dictionary.
ASSERT_NO_THROW(conf.setClientClassDictionary(ref_dictionary_));
isc::hooks::HooksConfig& libraries = conf.getHooksConfig();
// Upon construction configured hooks libraries should be empty.
- EXPECT_EQ(0, libraries.get().size());
+ EXPECT_EQ(0U, libraries.get().size());
// Verify we can update it.
ConstElementPtr elem0;
std::string config = "{ \"library\": \"bar\" }";
ConstElementPtr elem1 = Element::fromJSON(config);
libraries.add("bar", elem1);
- EXPECT_EQ(2, libraries.get().size());
- EXPECT_EQ(2, conf.getHooksConfig().get().size());
+ EXPECT_EQ(2U, libraries.get().size());
+ EXPECT_EQ(2U, conf.getHooksConfig().get().size());
// Try to copy
SrvConfig copied(64);
ASSERT_TRUE(conf != copied);
ASSERT_NO_THROW(conf.copy(copied));
ASSERT_TRUE(conf == copied);
- EXPECT_EQ(2, copied.getHooksConfig().get().size());
+ EXPECT_EQ(2U, copied.getHooksConfig().get().size());
EXPECT_TRUE(copied.getHooksConfig().equal(conf.getHooksConfig()));
}
ASSERT_NO_THROW(check = dhcp4->get("reservations"));
ASSERT_TRUE(check);
ASSERT_EQ(Element::list, check->getType());
- EXPECT_EQ(1, check->size());
+ EXPECT_EQ(1U, check->size());
// Get the global host reservation
ASSERT_NO_THROW(check = check->get(0));
ASSERT_NO_THROW(check = dhcp4->get("subnet4"));
ASSERT_TRUE(check);
ASSERT_EQ(Element::list, check->getType());
- EXPECT_EQ(1, check->size());
+ EXPECT_EQ(1U, check->size());
// Get the plain subnet
ASSERT_NO_THROW(check = check->get(0));
ASSERT_NO_THROW(check = check->get("reservations"));
ASSERT_TRUE(check);
ASSERT_EQ(Element::list, check->getType());
- EXPECT_EQ(1, check->size());
+ EXPECT_EQ(1U, check->size());
// Get the plain host reservation
ASSERT_NO_THROW(check = check->get(0));
ASSERT_NO_THROW(check = dhcp4->get("shared-networks"));
ASSERT_TRUE(check);
ASSERT_EQ(Element::list, check->getType());
- EXPECT_EQ(1, check->size());
+ EXPECT_EQ(1U, check->size());
// Get the shared network
ASSERT_NO_THROW(check = check->get(0));
ASSERT_NO_THROW(check = check->get("subnet4"));
ASSERT_TRUE(check);
ASSERT_EQ(Element::list, check->getType());
- EXPECT_EQ(1, check->size());
+ EXPECT_EQ(1U, check->size());
// Get the shared subnet
ASSERT_NO_THROW(check = check->get(0));
ASSERT_NO_THROW(check = check->get("reservations"));
ASSERT_TRUE(check);
ASSERT_EQ(Element::list, check->getType());
- EXPECT_EQ(1, check->size());
+ EXPECT_EQ(1U, check->size());
// Get the shared host reservation
ASSERT_NO_THROW(check = check->get(0));
ASSERT_NO_THROW(check = dhcp6->get("reservations"));
ASSERT_TRUE(check);
ASSERT_EQ(Element::list, check->getType());
- EXPECT_EQ(1, check->size());
+ EXPECT_EQ(1U, check->size());
// Get the global host reservation
ASSERT_NO_THROW(check = check->get(0));
ASSERT_NO_THROW(check = dhcp6->get("subnet6"));
ASSERT_TRUE(check);
ASSERT_EQ(Element::list, check->getType());
- EXPECT_EQ(1, check->size());
+ EXPECT_EQ(1U, check->size());
// Get the plain subnet
ASSERT_NO_THROW(check = check->get(0));
ASSERT_NO_THROW(check = check->get("reservations"));
ASSERT_TRUE(check);
ASSERT_EQ(Element::list, check->getType());
- EXPECT_EQ(1, check->size());
+ EXPECT_EQ(1U, check->size());
// Get the plain host reservation
ASSERT_NO_THROW(check = check->get(0));
ASSERT_NO_THROW(check = dhcp6->get("shared-networks"));
ASSERT_TRUE(check);
ASSERT_EQ(Element::list, check->getType());
- EXPECT_EQ(1, check->size());
+ EXPECT_EQ(1U, check->size());
// Get the shared network
ASSERT_NO_THROW(check = check->get(0));
ASSERT_NO_THROW(check = check->get("subnet6"));
ASSERT_TRUE(check);
ASSERT_EQ(Element::list, check->getType());
- EXPECT_EQ(1, check->size());
+ EXPECT_EQ(1U, check->size());
// Get the shared subnet
ASSERT_NO_THROW(check = check->get(0));
ASSERT_NO_THROW(check = check->get("reservations"));
ASSERT_TRUE(check);
ASSERT_EQ(Element::list, check->getType());
- EXPECT_EQ(1, check->size());
+ EXPECT_EQ(1U, check->size());
// Get the shared host reservation
ASSERT_NO_THROW(check = check->get(0));
// Make sure the explicit values are set correctly.
// decline-probation-period should be the "to" configured value.
- EXPECT_EQ(300, cfg_to.getDeclinePeriod());
+ EXPECT_EQ(300U, cfg_to.getDeclinePeriod());
// echo-client-id should be the preserved "to" member value.
EXPECT_FALSE(cfg_to.getEchoClientId());
// dhcp4o6-port should be the "from" configured value.
- EXPECT_EQ(999, cfg_to.getDhcp4o6Port());
+ EXPECT_EQ(999U, cfg_to.getDhcp4o6Port());
// server-tag port should be the "from" configured value.
EXPECT_EQ("use_this_server", cfg_to.getServerTag().get());
// host-reservation-identifiers
auto const& ex_hr_i = cfg_to.getCfgHostOperations4()->getIdentifierTypes();
- EXPECT_EQ(ex_hr_i.size(), 2);
+ EXPECT_EQ(ex_hr_i.size(), 2U);
EXPECT_EQ(ex_hr_i.front(), Host::IDENT_HWADDR);
EXPECT_EQ(ex_hr_i.back(), Host::IDENT_FLEX);
// Make sure the explicit values are set correctly.
// decline-probation-period should be the "to" configured value.
- EXPECT_EQ(300, cfg_to.getDeclinePeriod());
+ EXPECT_EQ(300U, cfg_to.getDeclinePeriod());
// dhcp4o6-port should be the "from" configured value.
- EXPECT_EQ(999, cfg_to.getDhcp4o6Port());
+ EXPECT_EQ(999U, cfg_to.getDhcp4o6Port());
// server-tag port should be the "from" configured value.
EXPECT_EQ("use_this_server", cfg_to.getServerTag().get());
// host-reservation-identifiers
auto const& ex_hr_i = cfg_to.getCfgHostOperations6()->getIdentifierTypes();
- EXPECT_EQ(ex_hr_i.size(), 2);
+ EXPECT_EQ(ex_hr_i.size(), 2U);
EXPECT_EQ(ex_hr_i.front(), Host::IDENT_HWADDR);
EXPECT_EQ(ex_hr_i.back(), Host::IDENT_FLEX);
ASSERT_TRUE(subnet);
EXPECT_EQ("192.0.2.2/16", subnet->toText());
- EXPECT_EQ(1, subnet->getT1().get());
- EXPECT_EQ(2, subnet->getT2().get());
- EXPECT_EQ(3, subnet->getValid().get());
- EXPECT_EQ(10, subnet->getID());
+ EXPECT_EQ(1U, subnet->getT1().get());
+ EXPECT_EQ(2U, subnet->getT2().get());
+ EXPECT_EQ(3U, subnet->getValid().get());
+ EXPECT_EQ(10U, subnet->getID());
}
// This test verifies the default values set for the subnets and verifies
EXPECT_TRUE(subnet.getClientClasses().empty());
EXPECT_TRUE(subnet.getValid().unspecified());
- EXPECT_EQ(0, subnet.getValid().get());
+ EXPECT_EQ(0U, subnet.getValid().get());
EXPECT_TRUE(subnet.getT1().unspecified());
- EXPECT_EQ(0, subnet.getT1().get());
+ EXPECT_EQ(0U, subnet.getT1().get());
EXPECT_TRUE(subnet.getT2().unspecified());
- EXPECT_EQ(0, subnet.getT2().get());
+ EXPECT_EQ(0U, subnet.getT2().get());
EXPECT_TRUE(subnet.getReservationsGlobal().unspecified());
EXPECT_FALSE(subnet.getReservationsGlobal().get());
EXPECT_TRUE(subnet.get4o6().getSubnet4o6().unspecified());
EXPECT_TRUE(subnet.get4o6().getSubnet4o6().get().first.isV6Zero());
- EXPECT_EQ(128, subnet.get4o6().getSubnet4o6().get().second);
+ EXPECT_EQ(128U, subnet.get4o6().getSubnet4o6().get().second);
EXPECT_TRUE(subnet.getDdnsSendUpdates().unspecified());
EXPECT_FALSE(subnet.getDdnsSendUpdates().get());
EXPECT_FALSE(subnet.getDdnsUpdateOnRenew().get());
EXPECT_TRUE(subnet.getOfferLft().unspecified());
- EXPECT_EQ(0, subnet.getOfferLft().get());
+ EXPECT_EQ(0U, subnet.getOfferLft().get());
}
TEST(Subnet4Test, inRange) {
Subnet4 subnet(IOAddress("192.0.2.1"), 24, 1000, 2000, 3000, SubnetID(1));
- EXPECT_EQ(1000, subnet.getT1().get());
- EXPECT_EQ(2000, subnet.getT2().get());
- EXPECT_EQ(3000, subnet.getValid().get());
+ EXPECT_EQ(1000U, subnet.getT1().get());
+ EXPECT_EQ(2000U, subnet.getT2().get());
+ EXPECT_EQ(3000U, subnet.getValid().get());
EXPECT_FALSE(subnet.hasRelays());
// Should be empty.
EXPECT_FALSE(subnet.hasRelays());
- EXPECT_EQ(0, subnet.getRelayAddresses().size());
+ EXPECT_EQ(0U, subnet.getRelayAddresses().size());
// Matching should fail.
EXPECT_FALSE(subnet.hasRelayAddress(IOAddress("192.0.123.45")));
EXPECT_TRUE(subnet.hasRelays());
// Should be two in the list.
- EXPECT_EQ(2, subnet.getRelayAddresses().size());
+ EXPECT_EQ(2U, subnet.getRelayAddresses().size());
// Should be able to match them if they are there.
EXPECT_TRUE(subnet.hasRelayAddress(IOAddress("192.0.123.45")));
24, 1, 2, 3, SubnetID(1));
// There are no pools defined, so the total number of available addrs is 0.
- EXPECT_EQ(0, subnet->getPoolCapacity(Lease::TYPE_V4));
+ EXPECT_EQ(0U, subnet->getPoolCapacity(Lease::TYPE_V4));
// Let's add a /25 pool. That's 128 addresses.
PoolPtr pool1(new Pool4(IOAddress("192.1.2.0"), 25));
subnet->addPool(pool1);
- EXPECT_EQ(128, subnet->getPoolCapacity(Lease::TYPE_V4));
+ EXPECT_EQ(128U, subnet->getPoolCapacity(Lease::TYPE_V4));
// Let's add another /26 pool. That's extra 64 addresses.
PoolPtr pool2(new Pool4(IOAddress("192.1.2.128"), 26));
subnet->addPool(pool2);
- EXPECT_EQ(192, subnet->getPoolCapacity(Lease::TYPE_V4));
+ EXPECT_EQ(192U, subnet->getPoolCapacity(Lease::TYPE_V4));
// Let's add a third pool /30. This one has 4 addresses.
PoolPtr pool3(new Pool4(IOAddress("192.1.2.192"), 30));
subnet->addPool(pool3);
- EXPECT_EQ(196, subnet->getPoolCapacity(Lease::TYPE_V4));
+ EXPECT_EQ(196U, subnet->getPoolCapacity(Lease::TYPE_V4));
// Let's add a forth pool /30. This one has 4 addresses.
PoolPtr pool4(new Pool4(IOAddress("192.1.2.200"), 30));
subnet->addPool(pool4);
- EXPECT_EQ(200, subnet->getPoolCapacity(Lease::TYPE_V4));
+ EXPECT_EQ(200U, subnet->getPoolCapacity(Lease::TYPE_V4));
// Now play with classes
pool3->allowClientClass("bar");
// Pool3 requires a member of bar
- EXPECT_EQ(196, subnet->getPoolCapacity(Lease::TYPE_V4, no_class));
- EXPECT_EQ(196, subnet->getPoolCapacity(Lease::TYPE_V4, foo_class));
- EXPECT_EQ(200, subnet->getPoolCapacity(Lease::TYPE_V4, bar_class));
- EXPECT_EQ(200, subnet->getPoolCapacity(Lease::TYPE_V4, three_classes));
+ EXPECT_EQ(196U, subnet->getPoolCapacity(Lease::TYPE_V4, no_class));
+ EXPECT_EQ(196U, subnet->getPoolCapacity(Lease::TYPE_V4, foo_class));
+ EXPECT_EQ(200U, subnet->getPoolCapacity(Lease::TYPE_V4, bar_class));
+ EXPECT_EQ(200U, subnet->getPoolCapacity(Lease::TYPE_V4, three_classes));
}
// Checks that it is not allowed to add invalid pools.
auto subnet = Subnet4::create(IOAddress("192.0.2.0"),
28, 1, 2, 3, SubnetID(1));
EXPECT_EQ("192.0.2.0", subnet->get().first.toText());
- EXPECT_EQ(28, subnet->get().second);
+ EXPECT_EQ(28U, subnet->get().second);
}
// Checks if the V4 is the only allowed type for Pool4 and if getPool()
ASSERT_TRUE(subnet);
EXPECT_EQ("2001:db8:1::/64", subnet->toText());
- EXPECT_EQ(1, subnet->getT1().get());
- EXPECT_EQ(2, subnet->getT2().get());
- EXPECT_EQ(3, subnet->getPreferred().get());
- EXPECT_EQ(4, subnet->getValid().get());
- EXPECT_EQ(10, subnet->getID());
+ EXPECT_EQ(1U, subnet->getT1().get());
+ EXPECT_EQ(2U, subnet->getT2().get());
+ EXPECT_EQ(3U, subnet->getPreferred().get());
+ EXPECT_EQ(4U, subnet->getValid().get());
+ EXPECT_EQ(10U, subnet->getID());
}
// This test verifies the default values set for the shared
EXPECT_TRUE(subnet.getClientClasses().empty());
EXPECT_TRUE(subnet.getValid().unspecified());
- EXPECT_EQ(0, subnet.getValid().get());
+ EXPECT_EQ(0U, subnet.getValid().get());
EXPECT_TRUE(subnet.getT1().unspecified());
- EXPECT_EQ(0, subnet.getT1().get());
+ EXPECT_EQ(0U, subnet.getT1().get());
EXPECT_TRUE(subnet.getT2().unspecified());
- EXPECT_EQ(0, subnet.getT2().get());
+ EXPECT_EQ(0U, subnet.getT2().get());
EXPECT_TRUE(subnet.getReservationsGlobal().unspecified());
EXPECT_FALSE(subnet.getReservationsGlobal().get());
EXPECT_EQ(0.0, subnet.getT2Percent().get());
EXPECT_TRUE(subnet.getPreferred().unspecified());
- EXPECT_EQ(0, subnet.getPreferred().get());
+ EXPECT_EQ(0U, subnet.getPreferred().get());
EXPECT_TRUE(subnet.getRapidCommit().unspecified());
EXPECT_FALSE(subnet.getRapidCommit().get());
Subnet6 subnet(IOAddress("2001:db8:1::"),
64, 1000, 2000, 3000, 4000, SubnetID(1));
- EXPECT_EQ(1000, subnet.getT1().get());
- EXPECT_EQ(2000, subnet.getT2().get());
- EXPECT_EQ(3000, subnet.getPreferred().get());
- EXPECT_EQ(4000, subnet.getValid().get());
+ EXPECT_EQ(1000U, subnet.getT1().get());
+ EXPECT_EQ(2000U, subnet.getT2().get());
+ EXPECT_EQ(3000U, subnet.getPreferred().get());
+ EXPECT_EQ(4000U, subnet.getValid().get());
EXPECT_FALSE(subnet.inRange(IOAddress("2001:db8:0:ffff:ffff:ffff:ffff:ffff")));
EXPECT_TRUE(subnet.inRange(IOAddress("2001:db8:1::")));
// Should be empty.
EXPECT_FALSE(subnet.hasRelays());
- EXPECT_EQ(0, subnet.getRelayAddresses().size());
+ EXPECT_EQ(0U, subnet.getRelayAddresses().size());
// Matching should fail.
EXPECT_FALSE(subnet.hasRelayAddress(IOAddress("2001:ffff::45")));
EXPECT_TRUE(subnet.hasRelays());
// Should be two in the list.
- EXPECT_EQ(2, subnet.getRelayAddresses().size());
+ EXPECT_EQ(2U, subnet.getRelayAddresses().size());
// Should be able to match them if they are there.
EXPECT_TRUE(subnet.hasRelayAddress(IOAddress("2001:ffff::45")));
EXPECT_EQ(0, subnet->getPoolCapacity(Lease::TYPE_PD));
subnet->addPool(pool1);
- EXPECT_EQ(65536, subnet->getPoolCapacity(Lease::TYPE_NA));
+ EXPECT_EQ(65536U, subnet->getPoolCapacity(Lease::TYPE_NA));
subnet->addPool(pool2);
EXPECT_EQ(uint64_t(4294967296ull + 65536), subnet->getPoolCapacity(Lease::TYPE_NA));
EXPECT_EQ(0, subnet->getPoolCapacity(Lease::TYPE_PD));
subnet->addPool(pool1);
- EXPECT_EQ(65536, subnet->getPoolCapacity(Lease::TYPE_PD));
+ EXPECT_EQ(65536U, subnet->getPoolCapacity(Lease::TYPE_PD));
subnet->addPool(pool2);
EXPECT_EQ(uint64_t(4294967296ull + 65536), subnet->getPoolCapacity(Lease::TYPE_PD));
// Get options from the Subnet and check if all 10 are there.
OptionContainerPtr options = subnet->getCfgOption()->getAll(DHCP6_OPTION_SPACE);
ASSERT_TRUE(options);
- ASSERT_EQ(10, options->size());
+ ASSERT_EQ(10U, options->size());
// Validate codes of options added to dhcp6 option space.
uint16_t expected_code = 100;
options = subnet->getCfgOption()->getAll("isc");
ASSERT_TRUE(options);
- ASSERT_EQ(7, options->size());
+ ASSERT_EQ(7U, options->size());
// Validate codes of options added to isc option space.
expected_code = 105;
// Sanity check that all options are there.
OptionContainerPtr options = subnet->getCfgOption()->getAll(DHCP6_OPTION_SPACE);
- ASSERT_EQ(20, options->size());
+ ASSERT_EQ(20U, options->size());
// Use container index #1 to get the options by their codes.
OptionContainerTypeIndex& idx = options->get<1>();
// Get options from the Subnet and check if all 10 are there.
OptionContainerPtr options = subnet->getCfgOption()->getAll(12345678);
ASSERT_TRUE(options);
- ASSERT_EQ(10, options->size());
+ ASSERT_EQ(10U, options->size());
// Validate codes of options added to dhcp6 option space.
uint16_t expected_code = 100;
options = subnet->getCfgOption()->getAll(87654321);
ASSERT_TRUE(options);
- ASSERT_EQ(7, options->size());
+ ASSERT_EQ(7U, options->size());
// Validate codes of options added to isc option space.
expected_code = 105;
TEST(Subnet6Test, get) {
Subnet6 subnet(IOAddress("2001:db8::"), 32, 1, 2, 3, 4, SubnetID(1));
EXPECT_EQ("2001:db8::", subnet.get().first.toText());
- EXPECT_EQ(32, subnet.get().second);
+ EXPECT_EQ(32U, subnet.get().second);
}
// This trivial test checks if interface name is stored properly
subnet = SubnetFetcher4::get(collection, SubnetID(1024));
ASSERT_TRUE(subnet);
- EXPECT_EQ(1024, subnet->getID());
+ EXPECT_EQ(1024U, subnet->getID());
EXPECT_EQ("192.0.2.0/24", subnet->toText());
subnet = SubnetFetcher4::get(collection, SubnetID(2048));
ASSERT_TRUE(subnet);
- EXPECT_EQ(2048, subnet->getID());
+ EXPECT_EQ(2048U, subnet->getID());
EXPECT_EQ("192.0.3.0/24", subnet->toText());
}
subnet = SubnetFetcher6::get(collection, SubnetID(1024));
ASSERT_TRUE(subnet);
- EXPECT_EQ(1024, subnet->getID());
+ EXPECT_EQ(1024U, subnet->getID());
EXPECT_EQ("2001:db8:1::/64", subnet->toText());
subnet = SubnetFetcher6::get(collection, SubnetID(2048));
ASSERT_TRUE(subnet);
- EXPECT_EQ(2048, subnet->getID());
+ EXPECT_EQ(2048U, subnet->getID());
EXPECT_EQ("2001:db8:2::/64", subnet->toText());
}
TimerMgrTest::testUnregisterTimer() {
// Register a timer and start it.
ASSERT_NO_FATAL_FAILURE(registerTimer("timer1", 1));
- ASSERT_EQ(1, timer_mgr_->timersCount());
+ ASSERT_EQ(1U, timer_mgr_->timersCount());
ASSERT_NO_THROW(timer_mgr_->setup("timer1"));
// Wait for the timer to execute several times.
// Remember how many times the timer's callback was executed.
const unsigned int calls_count = calls_count_["timer1"];
- ASSERT_GT(calls_count, 0);
+ ASSERT_GT(calls_count, 0U);
// Check that an attempt to unregister a non-existing timer would
// result in exception.
ASSERT_THROW(timer_mgr_->unregisterTimer("timer2"), BadValue);
// Number of timers shouldn't have changed.
- ASSERT_EQ(1, timer_mgr_->timersCount());
+ ASSERT_EQ(1U, timer_mgr_->timersCount());
// Now unregister the correct one.
ASSERT_NO_THROW(timer_mgr_->unregisterTimer("timer1"));
- ASSERT_EQ(0, timer_mgr_->timersCount());
+ ASSERT_EQ(0U, timer_mgr_->timersCount());
EXPECT_FALSE(timer_mgr_->isTimerRegistered("timer1"));
doWait(100);
void
TimerMgrTest::testUnregisterTimers() {
// Register 10 timers.
- for (int i = 1; i <= 20; ++i) {
+ for (size_t i = 1; i <= 20; ++i) {
std::ostringstream s;
s << "timer" << i;
ASSERT_NO_FATAL_FAILURE(registerTimer(s.str(), 1))
size_t count = 0;
for (auto const& it : calls_count_) {
unsigned int calls_count = it.second;
- ASSERT_GT(calls_count, 0)
+ ASSERT_GT(calls_count, 0U)
<< "expected calls counter for timer "
<< ++count
<< " greater than 0";
ASSERT_NO_THROW(timer_mgr_->unregisterTimers());
// Make sure there are no timers registered.
- ASSERT_EQ(0, timer_mgr_->timersCount());
+ ASSERT_EQ(0U, timer_mgr_->timersCount());
doWait(500);
// So, the real number differs significantly. We don't know
// exactly how many have been executed. It should be more
// than 10 for sure. But we really made up the numbers here.
- EXPECT_GT(calls_count_["timer1"], 10);
+ EXPECT_GT(calls_count_["timer1"], 10U);
// For the second timer it should be more than 5.
- EXPECT_GT(calls_count_["timer2"], 5);
+ EXPECT_GT(calls_count_["timer2"], 5U);
// Because the interval of the 'timer1' is lower than the
// interval of the 'timer2' the number of calls should
// This call should trigger the lease add callbacks for subnet id 0 and 1.
EXPECT_NO_THROW(mgr.trackAddLease(initializeLease(1, "192.0.2.1")));
- EXPECT_EQ(2, logs_.size());
+ EXPECT_EQ(2U, logs_.size());
EXPECT_EQ(1, countLogs(TrackingLeaseMgr::TRACK_ADD_LEASE, SUBNET_ID_GLOBAL, Lease::TYPE_V4));
EXPECT_EQ(1, countLogs(TrackingLeaseMgr::TRACK_ADD_LEASE, 1, Lease::TYPE_V4));
// This call should trigger the lease add callback for subnet id 0 only. That's
// because we have no callback for the subnet id 3.
EXPECT_NO_THROW(mgr.trackAddLease(initializeLease(3, "192.0.2.1")));
- EXPECT_EQ(3, logs_.size());
+ EXPECT_EQ(3U, logs_.size());
EXPECT_EQ(2, countLogs(TrackingLeaseMgr::TRACK_ADD_LEASE, SUBNET_ID_GLOBAL, Lease::TYPE_V4));
}
SUBNET_ID_GLOBAL, ph::_1)));
EXPECT_NO_THROW(mgr.trackAddLease(initializeLease(1, "192.0.2.1")));
- EXPECT_EQ(1, logs_.size());
+ EXPECT_EQ(1U, logs_.size());
EXPECT_EQ(1, countLogs(TrackingLeaseMgr::TRACK_ADD_LEASE, SUBNET_ID_GLOBAL, Lease::TYPE_V4));
EXPECT_NO_THROW(mgr.trackAddLease(initializeLease(1, Lease::TYPE_NA, "2001:db8:1::1")));
- EXPECT_EQ(2, logs_.size());
+ EXPECT_EQ(2U, logs_.size());
EXPECT_EQ(1, countLogs(TrackingLeaseMgr::TRACK_ADD_LEASE, SUBNET_ID_GLOBAL, Lease::TYPE_NA));
EXPECT_NO_THROW(mgr.trackAddLease(initializeLease(1, Lease::TYPE_PD, "3000::")));
- EXPECT_EQ(3, logs_.size());
+ EXPECT_EQ(3U, logs_.size());
EXPECT_EQ(1, countLogs(TrackingLeaseMgr::TRACK_ADD_LEASE, SUBNET_ID_GLOBAL, Lease::TYPE_PD));
}
TrackingLeaseMgr::TRACK_DELETE_LEASE,
SUBNET_ID_GLOBAL, ph::_1)));
EXPECT_NO_THROW(mgr.trackUpdateLease(initializeLease(1, "192.0.2.1")));
- EXPECT_EQ(1, logs_.size());
+ EXPECT_EQ(1U, logs_.size());
EXPECT_EQ(1, countLogs(TrackingLeaseMgr::TRACK_UPDATE_LEASE, 0, Lease::TYPE_V4));
}
TrackingLeaseMgr::TRACK_DELETE_LEASE,
SUBNET_ID_GLOBAL, ph::_1)));
EXPECT_NO_THROW(mgr.trackDeleteLease(initializeLease(1, "192.0.2.1")));
- EXPECT_EQ(1, logs_.size());
+ EXPECT_EQ(1U, logs_.size());
EXPECT_EQ(1, countLogs(TrackingLeaseMgr::TRACK_DELETE_LEASE, SUBNET_ID_GLOBAL, Lease::TYPE_V4));
}
// It should only run the callback for the global subnet id that is still
// registered.
- EXPECT_EQ(1, logs_.size());
+ EXPECT_EQ(1U, logs_.size());
EXPECT_EQ(1, countLogs(TrackingLeaseMgr::TRACK_ADD_LEASE, SUBNET_ID_GLOBAL, Lease::TYPE_V4));
// Unregister this callback.
// Make sure it is no longer invoked.
EXPECT_NO_THROW(mgr.trackAddLease(initializeLease(1, "192.0.2.1")));
- EXPECT_EQ(1, logs_.size());
+ EXPECT_EQ(1U, logs_.size());
// Unregistering it again should be no-op.
EXPECT_NO_THROW(mgr.unregisterCallbacks(SUBNET_ID_GLOBAL, Lease::TYPE_V4));
switch (exp_result) {
case SHOULD_PASS:
ASSERT_FALSE(leases.empty());
- ASSERT_EQ(1, leases.size());
+ ASSERT_EQ(1U, leases.size());
result = leases[0];
checkLease6(duid_, result, Lease::TYPE_NA, 128);
EXPECT_EQ(fqdn_rev_, lease->fqdn_rev_);
EXPECT_EQ(hostname_, lease->hostname_);
EXPECT_TRUE(*lease->duid_ == *duid);
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
/// @todo: check cltt
}
EXPECT_TRUE(*lease->client_id_ == *clientid_);
}
EXPECT_TRUE(*lease->hwaddr_ == *hwaddr_);
- EXPECT_EQ(0, lease->reuseable_valid_lft_);
+ EXPECT_EQ(0U, lease->reuseable_valid_lft_);
/// @todo: check cltt
}
// Try to delete non-existing server.
ASSERT_NO_THROW_LOG(servers_deleted = cbptr_->deleteServer4(ServerTag("server2")));
- EXPECT_EQ(0, servers_deleted);
+ EXPECT_EQ(0U, servers_deleted);
// Make sure that the server1 wasn't deleted.
ASSERT_NO_THROW_LOG(returned_server = cbptr_->getServer4(ServerTag("server1")));
// Delete the existing server.
ASSERT_NO_THROW_LOG(servers_deleted = cbptr_->deleteServer4(ServerTag("server1")));
- EXPECT_EQ(1, servers_deleted);
+ EXPECT_EQ(1U, servers_deleted);
{
SCOPED_TRACE("DELETE audit entry for server");
// inserted servers. The logical 'all' server should be excluded.
EXPECT_EQ(test_servers_.size() - 1, deleted_servers);
- EXPECT_EQ(1, countRows("dhcp4_server"));
+ EXPECT_EQ(1U, countRows("dhcp4_server"));
}
void
EXPECT_EQ("whale", returned_global_parameter->getValue());
EXPECT_TRUE(returned_global_parameter->getModificationTime() ==
global_parameter->getModificationTime());
- ASSERT_EQ(1, returned_global_parameter->getServerTags().size());
+ ASSERT_EQ(1U, returned_global_parameter->getServerTags().size());
EXPECT_EQ("all", returned_global_parameter->getServerTags().begin()->get());
// Because we have added the global parameter for all servers, it
EXPECT_EQ("whale", returned_global_parameter->getValue());
EXPECT_TRUE(returned_global_parameter->getModificationTime() ==
global_parameter->getModificationTime());
- ASSERT_EQ(1, returned_global_parameter->getServerTags().size());
+ ASSERT_EQ(1U, returned_global_parameter->getServerTags().size());
EXPECT_EQ("all", returned_global_parameter->getServerTags().begin()->get());
// Check that the parameter is updated when selector is specified correctly.
EXPECT_EQ("fish", returned_global_parameter->getValue());
EXPECT_TRUE(returned_global_parameter->getModificationTime() ==
global_parameter->getModificationTime());
- ASSERT_EQ(1, returned_global_parameter->getServerTags().size());
+ ASSERT_EQ(1U, returned_global_parameter->getServerTags().size());
EXPECT_EQ("all", returned_global_parameter->getServerTags().begin()->get());
{
// Should not delete parameter specified for all servers if explicit
// server name is provided.
- EXPECT_EQ(0, cbptr_->deleteGlobalParameter4(ServerSelector::ONE("server1"),
- "global"));
+ EXPECT_EQ(0U,
+ cbptr_->deleteGlobalParameter4(ServerSelector::ONE("server1"),
+ "global"));
// Delete parameter and make sure it is gone.
cbptr_->deleteGlobalParameter4(ServerSelector::ALL(), "global");
);
ASSERT_TRUE(returned_global);
EXPECT_EQ(global_parameter3->getValue(), returned_global->getValue());
- ASSERT_EQ(1, returned_global->getServerTags().size());
+ ASSERT_EQ(1U, returned_global->getServerTags().size());
EXPECT_EQ("all", returned_global->getServerTags().begin()->get());
// Try to fetch the value specified for the server1. This should override the
ASSERT_TRUE(returned_global);
EXPECT_EQ(global_parameter1->getValue(), returned_global->getValue());
- ASSERT_EQ(1, returned_global->getServerTags().size());
+ ASSERT_EQ(1U, returned_global->getServerTags().size());
EXPECT_EQ("server1", returned_global->getServerTags().begin()->get());
// The same in case of the server2.
);
ASSERT_TRUE(returned_global);
EXPECT_EQ(global_parameter2->getValue(), returned_global->getValue());
- ASSERT_EQ(1, returned_global->getServerTags().size());
+ ASSERT_EQ(1U, returned_global->getServerTags().size());
EXPECT_EQ("server2", returned_global->getServerTags().begin()->get());
StampedValueCollection returned_globals;
MULTIPLE({ "server1", "server2",
"server3" }));
);
- ASSERT_EQ(3, returned_globals.size());
+ ASSERT_EQ(3U, returned_globals.size());
// Capture the returned values into the map so as we can check the
// values against the servers.
std::map<std::string, std::string> values;
for (auto const& g : returned_globals) {
- ASSERT_EQ(1, g->getServerTags().size());
+ ASSERT_EQ(1U, g->getServerTags().size());
values[g->getServerTags().begin()->get()] = g->getValue();
}
- ASSERT_EQ(3, values.size());
+ ASSERT_EQ(3U, values.size());
EXPECT_EQ(global_parameter1->getValue(), values["server1"]);
EXPECT_EQ(global_parameter2->getValue(), values["server2"]);
EXPECT_EQ(global_parameter3->getValue(), values["all"]);
ASSERT_NO_THROW_LOG(
returned_globals = cbptr_->getAllGlobalParameters4(ServerSelector::ALL())
);
- ASSERT_EQ(1, returned_globals.size());
+ ASSERT_EQ(1U, returned_globals.size());
returned_global = *returned_globals.begin();
EXPECT_EQ(global_parameter3->getValue(), returned_global->getValue());
- ASSERT_EQ(1, returned_global->getServerTags().size());
+ ASSERT_EQ(1U, returned_global->getServerTags().size());
EXPECT_EQ("all", returned_global->getServerTags().begin()->get());
// Delete the server1. It should remove associations of this server with the
ASSERT_NO_THROW_LOG(
returned_globals = cbptr_->getAllGlobalParameters4(ServerSelector::ONE("server1"))
);
- ASSERT_EQ(1, returned_globals.size());
+ ASSERT_EQ(1U, returned_globals.size());
returned_global = *returned_globals.begin();
// As a result, the value fetched for the server1 should be the one available for
// all servers, rather than the one dedicated for server1. The association of
// the server1 specific value with the server1 should be gone.
EXPECT_EQ(global_parameter3->getValue(), returned_global->getValue());
- ASSERT_EQ(1, returned_global->getServerTags().size());
+ ASSERT_EQ(1U, returned_global->getServerTags().size());
EXPECT_EQ("all", returned_global->getServerTags().begin()->get());
{
"global"));
// No parameters should be deleted. In particular, the parameter for the logical
// server 'all' should not be deleted.
- EXPECT_EQ(0, deleted_num);
+ EXPECT_EQ(0U, deleted_num);
// Deleting the existing value for server2 should succeed.
ASSERT_NO_THROW_LOG(deleted_num = cbptr_->deleteGlobalParameter4(ServerSelector::ONE("server2"),
"global"));
- EXPECT_EQ(1, deleted_num);
+ EXPECT_EQ(1U, deleted_num);
// Create it again to test that deletion of all server removes this too.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateGlobalParameter4(ServerSelector::ONE("server2"),
ASSERT_NO_THROW_LOG(
returned_globals = cbptr_->getAllGlobalParameters4(ServerSelector::ALL())
);
- EXPECT_EQ(1, deleted_num);
- ASSERT_EQ(1, returned_globals.size());
+ EXPECT_EQ(1U, deleted_num);
+ ASSERT_EQ(1U, returned_globals.size());
returned_global = *returned_globals.begin();
// The common value for all servers should still be available because 'all'
// logical server should not be deleted.
EXPECT_EQ(global_parameter3->getValue(), returned_global->getValue());
- ASSERT_EQ(1, returned_global->getServerTags().size());
+ ASSERT_EQ(1U, returned_global->getServerTags().size());
EXPECT_EQ("all", returned_global->getServerTags().begin()->get());
{
// Fetch all parameters.
auto parameters = cbptr_->getAllGlobalParameters4(ServerSelector::ALL());
- ASSERT_EQ(5, parameters.size());
+ ASSERT_EQ(5U, parameters.size());
auto const& parameters_index = parameters.get<StampedValueNameIndexTag>();
EXPECT_EQ(1.65, (*parameters_index.find("name5"))->getDoubleValue());
for (auto const& param : parameters_index) {
- ASSERT_EQ(1, param->getServerTags().size());
+ ASSERT_EQ(1U, param->getServerTags().size());
EXPECT_EQ("all", param->getServerTags().begin()->get());
}
// Should be able to fetch these parameters when explicitly providing
// the server tag.
parameters = cbptr_->getAllGlobalParameters4(ServerSelector::ONE("server1"));
- EXPECT_EQ(5, parameters.size());
+ EXPECT_EQ(5U, parameters.size());
// Deleting global parameters with non-matching server selector
// should fail.
- EXPECT_EQ(0, cbptr_->deleteAllGlobalParameters4(ServerSelector::ONE("server1")));
+ EXPECT_EQ(0U,
+ cbptr_->deleteAllGlobalParameters4(ServerSelector::ONE("server1")));
// Delete all parameters and make sure they are gone.
- EXPECT_EQ(5, cbptr_->deleteAllGlobalParameters4(ServerSelector::ALL()));
+ EXPECT_EQ(5U, cbptr_->deleteAllGlobalParameters4(ServerSelector::ALL()));
parameters = cbptr_->getAllGlobalParameters4(ServerSelector::ALL());
EXPECT_TRUE(parameters.empty());
}
auto const& parameters_index = parameters.get<StampedValueNameIndexTag>();
// It should be the one modified "tomorrow".
- ASSERT_EQ(1, parameters_index.size());
+ ASSERT_EQ(1U, parameters_index.size());
auto parameter = parameters_index.find("name3");
ASSERT_FALSE(parameter == parameters_index.end());
// the server tag.
parameters = cbptr_->getModifiedGlobalParameters4(ServerSelector::ONE("server1"),
timestamps_["after today"]);
- EXPECT_EQ(1, parameters.size());
+ EXPECT_EQ(1U, parameters.size());
}
void
returned_subnet_2 = cbptr_->getSubnet4(server_selector, subnet->getID()));
ASSERT_TRUE(returned_subnet_2);
- ASSERT_EQ(1, returned_subnet_2->getServerTags().size());
+ ASSERT_EQ(1U, returned_subnet_2->getServerTags().size());
EXPECT_TRUE(returned_subnet_2->hasServerTag(ServerTag(expected_tag)));
ASSERT_EQ(subnet->toElement()->str(), returned_subnet_2->toElement()->str());
returned_subnet_2 = cbptr_->getSubnet4(server_selector, subnet->toText()));
ASSERT_TRUE(returned_subnet_2);
- ASSERT_EQ(1, returned_subnet_2->getServerTags().size());
+ ASSERT_EQ(1U, returned_subnet_2->getServerTags().size());
EXPECT_TRUE(returned_subnet_2->hasServerTag(ServerTag(expected_tag)));
EXPECT_EQ(subnet->toElement()->str(), returned_subnet_2->toElement()->str());
EXPECT_TRUE(returned_subnet->getClientClasses().empty());
EXPECT_TRUE(returned_subnet->getValid().unspecified());
- EXPECT_EQ(0, returned_subnet->getValid().get());
+ EXPECT_EQ(0U, returned_subnet->getValid().get());
EXPECT_TRUE(returned_subnet->getT1().unspecified());
- EXPECT_EQ(0, returned_subnet->getT1().get());
+ EXPECT_EQ(0U, returned_subnet->getT1().get());
EXPECT_TRUE(returned_subnet->getT2().unspecified());
- EXPECT_EQ(0, returned_subnet->getT2().get());
+ EXPECT_EQ(0U, returned_subnet->getT2().get());
EXPECT_TRUE(returned_subnet->getReservationsGlobal().unspecified());
EXPECT_FALSE(returned_subnet->getReservationsGlobal().get());
Subnet4Ptr returned_subnet = cbptr_->getSubnet4(ServerSelector::ALL(),
test_subnets_[0]->getID());
ASSERT_TRUE(returned_subnet);
- ASSERT_EQ(1, returned_subnet->getServerTags().size());
+ ASSERT_EQ(1U, returned_subnet->getServerTags().size());
EXPECT_EQ("all", returned_subnet->getServerTags().begin()->get());
// The easiest way to verify whether the returned subnet matches the inserted
Subnet4Ptr returned_subnet = cbptr_->getSubnet4(ServerSelector::ALL(),
"192.0.2.0/24");
ASSERT_TRUE(returned_subnet);
- ASSERT_EQ(1, returned_subnet->getServerTags().size());
+ ASSERT_EQ(1U, returned_subnet->getServerTags().size());
EXPECT_EQ("all", returned_subnet->getServerTags().begin()->get());
// Verify subnet contents.
// See if the subnets are returned ok.
auto subnet_it = subnets.begin();
for (unsigned i = 0; i < subnets.size(); ++i, ++subnet_it) {
- ASSERT_EQ(1, (*subnet_it)->getServerTags().size());
+ ASSERT_EQ(1U, (*subnet_it)->getServerTags().size());
EXPECT_EQ("all", (*subnet_it)->getServerTags().begin()->get());
EXPECT_EQ(test_subnets_[i + 1]->toElement()->str(),
(*subnet_it)->toElement()->str());
}
// Attempt to remove the non existing subnet should return 0.
- EXPECT_EQ(0, cbptr_->deleteSubnet4(ServerSelector::ALL(), 22));
- EXPECT_EQ(0, cbptr_->deleteSubnet4(ServerSelector::ALL(),
- "155.0.3.0/24"));
+ EXPECT_EQ(0U, cbptr_->deleteSubnet4(ServerSelector::ALL(), 22));
+ EXPECT_EQ(0U, cbptr_->deleteSubnet4(ServerSelector::ALL(),
+ "155.0.3.0/24"));
// All subnets should be still there.
ASSERT_EQ(test_subnets_.size() - 1, subnets.size());
// Should not delete the subnet for explicit server tag because
// our subnet is for all servers.
- EXPECT_EQ(0, cbptr_->deleteSubnet4(ServerSelector::ONE("server1"),
- test_subnets_[1]->getID()));
+ EXPECT_EQ(0U, cbptr_->deleteSubnet4(ServerSelector::ONE("server1"),
+ test_subnets_[1]->getID()));
// Also, verify that behavior when deleting by prefix.
- EXPECT_EQ(0, cbptr_->deleteSubnet4(ServerSelector::ONE("server1"),
- test_subnets_[2]->toText()));
+ EXPECT_EQ(0U, cbptr_->deleteSubnet4(ServerSelector::ONE("server1"),
+ test_subnets_[2]->toText()));
// Same for all subnets.
- EXPECT_EQ(0, cbptr_->deleteAllSubnets4(ServerSelector::ONE("server1")));
+ EXPECT_EQ(0U, cbptr_->deleteAllSubnets4(ServerSelector::ONE("server1")));
// Delete first subnet by id and verify that it is gone.
- EXPECT_EQ(1, cbptr_->deleteSubnet4(ServerSelector::ALL(),
- test_subnets_[1]->getID()));
+ EXPECT_EQ(1U, cbptr_->deleteSubnet4(ServerSelector::ALL(),
+ test_subnets_[1]->getID()));
{
SCOPED_TRACE("DELETE first subnet audit entry");
ASSERT_EQ(test_subnets_.size() - 2, subnets.size());
// Delete second subnet by prefix and verify it is gone.
- EXPECT_EQ(1, cbptr_->deleteSubnet4(ServerSelector::ALL(),
- test_subnets_[2]->toText()));
+ EXPECT_EQ(1U, cbptr_->deleteSubnet4(ServerSelector::ALL(),
+ test_subnets_[2]->toText()));
subnets = cbptr_->getAllSubnets4(ServerSelector::ALL());
ASSERT_EQ(test_subnets_.size() - 3, subnets.size());
}
// Delete all.
- EXPECT_EQ(1, cbptr_->deleteAllSubnets4(ServerSelector::ALL()));
+ EXPECT_EQ(1U, cbptr_->deleteAllSubnets4(ServerSelector::ALL()));
subnets = cbptr_->getAllSubnets4(ServerSelector::ALL());
ASSERT_TRUE(subnets.empty());
// All three subnets are associated with the server1.
ASSERT_NO_THROW_LOG(subnets = cbptr_->getAllSubnets4(ServerSelector::ONE("server1")));
- EXPECT_EQ(3, subnets.size());
+ EXPECT_EQ(3U, subnets.size());
// First subnet is associated with all servers.
auto returned_subnet = SubnetFetcher4::get(subnets, SubnetID(1024));
// For server2 we should only get two subnets, i.e. first and last.
ASSERT_NO_THROW_LOG(subnets = cbptr_->getAllSubnets4(ServerSelector::ONE("server2")));
- EXPECT_EQ(2, subnets.size());
+ EXPECT_EQ(2U, subnets.size());
// First subnet is associated with all servers.
returned_subnet = SubnetFetcher4::get(subnets, SubnetID(1024));
// Only the first subnet is associated with all servers.
ASSERT_NO_THROW_LOG(subnets = cbptr_->getAllSubnets4(ServerSelector::ALL()));
- EXPECT_EQ(1, subnets.size());
+ EXPECT_EQ(1U, subnets.size());
returned_subnet = SubnetFetcher4::get(subnets, SubnetID(1024));
ASSERT_TRUE(returned_subnet);
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteSubnet4(server_selector, subnet->getID())
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
deleted_count = 0;
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteSubnet4(server_selector, subnet->toText())
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
};
{
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteSubnet4(server_selector, subnet->getID())
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
EXPECT_FALSE(cbptr_->getSubnet4(server_selector, subnet->getID()));
};
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteSubnet4(server_selector, subnet->toText())
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
EXPECT_FALSE(cbptr_->getSubnet4(server_selector, subnet->toText()));
};
// i.e. do not belong to any server.
uint64_t deleted_count = 0;
ASSERT_NO_THROW_LOG(deleted_count = cbptr_->deleteServer4(ServerTag("server1")));
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
// Trying to fetch the subnet by server tag should return no result.
Subnet4Ptr returned_subnet;
// Also if we ask for all unassigned subnets it should be returned.
ASSERT_NO_THROW_LOG(returned_subnets = cbptr_->getAllSubnets4(ServerSelector::UNASSIGNED()));
- ASSERT_EQ(2, returned_subnets.size());
+ ASSERT_EQ(2U, returned_subnets.size());
// Same for modified subnets.
ASSERT_NO_THROW_LOG(
returned_subnets = cbptr_->getModifiedSubnets4(ServerSelector::UNASSIGNED(),
timestamps_["two days ago"])
);
- ASSERT_EQ(2, returned_subnets.size());
+ ASSERT_EQ(2U, returned_subnets.size());
// If we ask for any subnet by subnet id, it should be returned too.
ASSERT_NO_THROW_LOG(returned_subnet = cbptr_->getSubnet4(ServerSelector::ANY(),
deleted_count = cbptr_->deleteSubnet4(ServerSelector::ONE("server1"),
subnet->getID())
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
// Also, if we delete all subnets for server1.
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteAllSubnets4(ServerSelector::ONE("server1"))
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
// We can delete this subnet when we specify ANY and the matching id.
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteSubnet4(ServerSelector::ANY(), subnet->getID())
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
// We can delete all subnets using UNASSIGNED selector.
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteAllSubnets4(ServerSelector::UNASSIGNED());
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
}
void
Subnet4Collection
subnets = cbptr_->getModifiedSubnets4(ServerSelector::ALL(),
timestamps_["after today"]);
- ASSERT_EQ(1, subnets.size());
+ ASSERT_EQ(1U, subnets.size());
// All subnets should also be returned for explicitly specified server tag.
subnets = cbptr_->getModifiedSubnets4(ServerSelector::ONE("server1"),
timestamps_["after today"]);
- ASSERT_EQ(1, subnets.size());
+ ASSERT_EQ(1U, subnets.size());
// Fetch subnets with timestamp later than yesterday. We should get
// two subnets.
subnets = cbptr_->getModifiedSubnets4(ServerSelector::ALL(),
timestamps_["after yesterday"]);
- ASSERT_EQ(2, subnets.size());
+ ASSERT_EQ(2U, subnets.size());
// Fetch subnets with timestamp later than tomorrow. Nothing should
// be returned.
// Fetch all subnets belonging to shared network level1.
Subnet4Collection subnets = cbptr_->getSharedNetworkSubnets4(ServerSelector::ALL(),
"level1");
- ASSERT_EQ(1, subnets.size());
+ ASSERT_EQ(1U, subnets.size());
// Returned subnet should match test subnet #1.
EXPECT_TRUE(isEquivalent(test_subnets_[1]->toElement(),
// All subnets should also be returned for ANY server.
subnets = cbptr_->getSharedNetworkSubnets4(ServerSelector::ANY(), "level1");
- ASSERT_EQ(1, subnets.size());
+ ASSERT_EQ(1U, subnets.size());
// Returned subnet should match test subnet #1.
EXPECT_TRUE(isEquivalent(test_subnets_[1]->toElement(),
(*subnets.begin())->toElement()));
// Check server tag
- ASSERT_EQ(1, (*subnets.begin())->getServerTags().size());
+ ASSERT_EQ(1U, (*subnets.begin())->getServerTags().size());
EXPECT_EQ("all", (*subnets.begin())->getServerTags().begin()->get());
// Fetch all subnets belonging to shared network level2.
subnets = cbptr_->getSharedNetworkSubnets4(ServerSelector::ALL(), "level2");
- ASSERT_EQ(2, subnets.size());
+ ASSERT_EQ(2U, subnets.size());
ElementPtr test_list = Element::createList();
test_list->add(test_subnets_[2]->toElement());
// All subnets should also be returned for explicitly specified server tag.
subnets = cbptr_->getSharedNetworkSubnets4(ServerSelector::ONE("server1"), "level2");
- ASSERT_EQ(2, subnets.size());
+ ASSERT_EQ(2U, subnets.size());
returned_list = Element::createList();
subnet = subnets.begin();
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet4(ServerSelector::ALL(),
test_subnets_[0]));
// Make sure that the pools have been added to the database.
- EXPECT_EQ(2, countRows("dhcp4_pool"));
+ EXPECT_EQ(2U, countRows("dhcp4_pool"));
// Create the subnet without options which updates the existing
// subnet.
subnet_id));
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet4(ServerSelector::ALL(), subnet));
// Check that options are gone.
- EXPECT_EQ(0, countRows("dhcp4_pool"));
+ EXPECT_EQ(0U, countRows("dhcp4_pool"));
};
{
GenericConfigBackendDHCPv4Test::subnetOptionsTest() {
// Add the subnet with two pools and three options.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet4(ServerSelector::ALL(), test_subnets_[0]));
- EXPECT_EQ(2, countRows("dhcp4_pool"));
- EXPECT_EQ(3, countRows("dhcp4_options"));
+ EXPECT_EQ(2U, countRows("dhcp4_pool"));
+ EXPECT_EQ(3U, countRows("dhcp4_options"));
// The second subnet uses the same subnet id, so this operation should replace
// the existing subnet and its options. The new instance has two pools, each
// including one option, so we should end up with two options.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet4(ServerSelector::ALL(), test_subnets_[1]));
- EXPECT_EQ(2, countRows("dhcp4_pool"));
- EXPECT_EQ(2, countRows("dhcp4_options"));
+ EXPECT_EQ(2U, countRows("dhcp4_pool"));
+ EXPECT_EQ(2U, countRows("dhcp4_options"));
// Add third subnet with a single option. The number of options in the database
// should now be 3.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet4(ServerSelector::ALL(), test_subnets_[2]));
- EXPECT_EQ(2, countRows("dhcp4_pool"));
- EXPECT_EQ(3, countRows("dhcp4_options"));
+ EXPECT_EQ(2U, countRows("dhcp4_pool"));
+ EXPECT_EQ(3U, countRows("dhcp4_options"));
// Delete the subnet. All options and pools it contains should also be removed, leaving
// the last added subnet and its sole option.
ASSERT_NO_THROW_LOG(cbptr_->deleteSubnet4(ServerSelector::ALL(), test_subnets_[1]->getID()));
- EXPECT_EQ(1, countRows("dhcp4_subnet"));
- EXPECT_EQ(0, countRows("dhcp4_pool"));
- EXPECT_EQ(1, countRows("dhcp4_options"));
+ EXPECT_EQ(1U, countRows("dhcp4_subnet"));
+ EXPECT_EQ(0U, countRows("dhcp4_pool"));
+ EXPECT_EQ(1U, countRows("dhcp4_options"));
// Add the first subnet again. We should now have 4 options: 3 options from the
// newly added subnet and one option from the existing subnet.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet4(ServerSelector::ALL(), test_subnets_[0]));
- EXPECT_EQ(2, countRows("dhcp4_pool"));
- EXPECT_EQ(4, countRows("dhcp4_options"));
+ EXPECT_EQ(2U, countRows("dhcp4_pool"));
+ EXPECT_EQ(4U, countRows("dhcp4_options"));
// Delete the subnet including 3 options. The option from the other subnet should not
// be affected.
ASSERT_NO_THROW_LOG(cbptr_->deleteSubnet4(ServerSelector::ALL(), test_subnets_[0]->getID()));
- EXPECT_EQ(1, countRows("dhcp4_subnet"));
- EXPECT_EQ(0, countRows("dhcp4_pool"));
- EXPECT_EQ(1, countRows("dhcp4_options"));
+ EXPECT_EQ(1U, countRows("dhcp4_subnet"));
+ EXPECT_EQ(0U, countRows("dhcp4_pool"));
+ EXPECT_EQ(1U, countRows("dhcp4_options"));
}
void
shared_network->getName()));
ASSERT_TRUE(network);
- EXPECT_GT(network->getId(), 0);
- ASSERT_EQ(1, network->getServerTags().size());
+ EXPECT_GT(network->getId(), 0U);
+ ASSERT_EQ(1U, network->getServerTags().size());
EXPECT_EQ(expected_tag, network->getServerTags().begin()->get());
// The easiest way to verify whether the returned shared network matches the
EXPECT_TRUE(returned_network->getClientClasses().empty());
EXPECT_TRUE(returned_network->getValid().unspecified());
- EXPECT_EQ(0, returned_network->getValid().get());
+ EXPECT_EQ(0U, returned_network->getValid().get());
EXPECT_TRUE(returned_network->getT1().unspecified());
- EXPECT_EQ(0, returned_network->getT1().get());
+ EXPECT_EQ(0U, returned_network->getT1().get());
EXPECT_TRUE(returned_network->getT2().unspecified());
- EXPECT_EQ(0, returned_network->getT2().get());
+ EXPECT_EQ(0U, returned_network->getT2().get());
EXPECT_TRUE(returned_network->getReservationsGlobal().unspecified());
EXPECT_FALSE(returned_network->getReservationsGlobal().get());
for (unsigned i = 0; i < networks.size(); ++i) {
EXPECT_EQ(test_networks_[i + 1]->toElement()->str(),
networks[i]->toElement()->str());
- ASSERT_EQ(1, networks[i]->getServerTags().size());
+ ASSERT_EQ(1U, networks[i]->getServerTags().size());
EXPECT_EQ("all", networks[i]->getServerTags().begin()->get());
}
}
// Deleting non-existing shared network should return 0.
- EXPECT_EQ(0, cbptr_->deleteSharedNetwork4(ServerSelector::ALL(),
- "big-fish"));
+ EXPECT_EQ(0U, cbptr_->deleteSharedNetwork4(ServerSelector::ALL(),
+ "big-fish"));
// All shared networks should be still there.
ASSERT_EQ(test_networks_.size() - 1, networks.size());
// Should not delete the shared network for explicit server tag
// because our shared network is for all servers.
- EXPECT_EQ(0, cbptr_->deleteSharedNetwork4(ServerSelector::ONE("server1"),
- test_networks_[1]->getName()));
+ EXPECT_EQ(0U, cbptr_->deleteSharedNetwork4(ServerSelector::ONE("server1"),
+ test_networks_[1]->getName()));
// Same for all shared networks.
- EXPECT_EQ(0, cbptr_->deleteAllSharedNetworks4(ServerSelector::ONE("server1")));
+ EXPECT_EQ(0U, cbptr_->deleteAllSharedNetworks4(ServerSelector::ONE("server1")));
// Delete first shared network with it subnets and verify it is gone.
// Begin by its subnet.
- EXPECT_EQ(1, cbptr_->deleteSharedNetworkSubnets4(ServerSelector::ANY(),
- test_networks_[1]->getName()));
+ EXPECT_EQ(1U, cbptr_->deleteSharedNetworkSubnets4(ServerSelector::ANY(),
+ test_networks_[1]->getName()));
{
SCOPED_TRACE("DELETE audit entry for subnets of the first shared network");
EXPECT_FALSE(subnet);
// And after the shared network itself.
- EXPECT_EQ(1, cbptr_->deleteSharedNetwork4(ServerSelector::ALL(),
- test_networks_[1]->getName()));
+ EXPECT_EQ(1U, cbptr_->deleteSharedNetwork4(ServerSelector::ALL(),
+ test_networks_[1]->getName()));
networks = cbptr_->getAllSharedNetworks4(ServerSelector::ALL());
ASSERT_EQ(test_networks_.size() - 2, networks.size());
}
// Delete all.
- EXPECT_EQ(2, cbptr_->deleteAllSharedNetworks4(ServerSelector::ALL()));
+ EXPECT_EQ(2U, cbptr_->deleteAllSharedNetworks4(ServerSelector::ALL()));
networks = cbptr_->getAllSharedNetworks4(ServerSelector::ALL());
ASSERT_TRUE(networks.empty());
// All three networks are associated with the server1.
ASSERT_NO_THROW_LOG(networks = cbptr_->getAllSharedNetworks4(ServerSelector::ONE("server1")));
- EXPECT_EQ(3, networks.size());
+ EXPECT_EQ(3U, networks.size());
// First network is associated with all servers.
auto returned_network = SharedNetworkFetcher4::get(networks, "level1");
// For server2 we should only get two shared networks, i.e. first and last.
ASSERT_NO_THROW_LOG(networks = cbptr_->getAllSharedNetworks4(ServerSelector::ONE("server2")));
- EXPECT_EQ(2, networks.size());
+ EXPECT_EQ(2U, networks.size());
// First shared network is associated with all servers.
returned_network = SharedNetworkFetcher4::get(networks, "level1");
// Only the first shared network is associated with all servers.
ASSERT_NO_THROW_LOG(networks = cbptr_->getAllSharedNetworks4(ServerSelector::ALL()));
- EXPECT_EQ(1, networks.size());
+ EXPECT_EQ(1U, networks.size());
returned_network = SharedNetworkFetcher4::get(networks, "level1");
ASSERT_TRUE(returned_network);
SharedNetwork4Collection
networks = cbptr_->getModifiedSharedNetworks4(ServerSelector::ALL(),
timestamps_["after today"]);
- ASSERT_EQ(1, networks.size());
+ ASSERT_EQ(1U, networks.size());
// Fetch shared networks with timestamp later than yesterday. We
// should get two shared networks.
networks = cbptr_->getModifiedSharedNetworks4(ServerSelector::ALL(),
timestamps_["after yesterday"]);
- ASSERT_EQ(2, networks.size());
+ ASSERT_EQ(2U, networks.size());
// Fetch shared networks with timestamp later than tomorrow. Nothing
// should be returned.
deleted_count = cbptr_->deleteSharedNetwork4(server_selector,
shared_network->getName())
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
};
{
deleted_count = cbptr_->deleteSharedNetwork4(server_selector,
shared_network->getName())
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
EXPECT_FALSE(cbptr_->getSharedNetwork4(server_selector,
shared_network->getName()));
// considered orphaned, i.e. do not belong to any server.
uint64_t deleted_count = 0;
ASSERT_NO_THROW_LOG(deleted_count = cbptr_->deleteServer4(ServerTag("server1")));
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
// Trying to fetch this shared network by server tag should return no result.
SharedNetwork4Ptr returned_network;
// Also if we ask for all unassigned networks it should be returned.
ASSERT_NO_THROW_LOG(returned_networks = cbptr_->getAllSharedNetworks4(ServerSelector::UNASSIGNED()));
- ASSERT_EQ(2, returned_networks.size());
+ ASSERT_EQ(2U, returned_networks.size());
// And all modified.
ASSERT_NO_THROW_LOG(
returned_networks = cbptr_->getModifiedSharedNetworks4(ServerSelector::UNASSIGNED(),
timestamps_["two days ago"])
);
- ASSERT_EQ(2, returned_networks.size());
+ ASSERT_EQ(2U, returned_networks.size());
// If we ask for any network by name, it should be returned too.
ASSERT_NO_THROW_LOG(returned_network = cbptr_->getSharedNetwork4(ServerSelector::ANY(),
deleted_count = cbptr_->deleteSharedNetwork4(ServerSelector::ONE("server1"),
"level1")
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
// Also, if we delete all shared networks for server1.
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteAllSharedNetworks4(ServerSelector::ONE("server1"))
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
// We can delete this shared network when we specify ANY and the matching name.
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteSharedNetwork4(ServerSelector::ANY(), "level1")
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
// We can delete all networks using UNASSIGNED selector.
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteAllSharedNetworks4(ServerSelector::UNASSIGNED());
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
}
void
GenericConfigBackendDHCPv4Test::sharedNetworkOptionsTest() {
// Add shared network with three options.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSharedNetwork4(ServerSelector::ALL(), test_networks_[0]));
- EXPECT_EQ(3, countRows("dhcp4_options"));
+ EXPECT_EQ(3U, countRows("dhcp4_options"));
// Add another shared network with a single option. The numnber of options in the
// database should now be 4.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSharedNetwork4(ServerSelector::ALL(), test_networks_[2]));
- EXPECT_EQ(4, countRows("dhcp4_options"));
+ EXPECT_EQ(4U, countRows("dhcp4_options"));
// The second shared network uses the same name as the first shared network, so
// this operation should replace the existing shared network and its options.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSharedNetwork4(ServerSelector::ALL(), test_networks_[1]));
- EXPECT_EQ(1, countRows("dhcp4_options"));
+ EXPECT_EQ(1U, countRows("dhcp4_options"));
// Remove the shared network. This should not affect options assigned to the
// other shared network.
ASSERT_NO_THROW_LOG(cbptr_->deleteSharedNetwork4(ServerSelector::ALL(),
test_networks_[1]->getName()));
- EXPECT_EQ(1, countRows("dhcp4_shared_network"));
- EXPECT_EQ(1, countRows("dhcp4_options"));
+ EXPECT_EQ(1U, countRows("dhcp4_shared_network"));
+ EXPECT_EQ(1U, countRows("dhcp4_options"));
// Create the first option again. The number of options should be equal to the
// sum of options associated with both shared networks.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSharedNetwork4(ServerSelector::ALL(), test_networks_[0]));
- EXPECT_EQ(4, countRows("dhcp4_options"));
+ EXPECT_EQ(4U, countRows("dhcp4_options"));
// Delete this shared network. This should not affect the option associated
// with the remaining shared network.
ASSERT_NO_THROW_LOG(cbptr_->deleteSharedNetwork4(ServerSelector::ALL(),
test_networks_[0]->getName()));
- EXPECT_EQ(1, countRows("dhcp4_shared_network"));
- EXPECT_EQ(1, countRows("dhcp4_options"));
+ EXPECT_EQ(1U, countRows("dhcp4_shared_network"));
+ EXPECT_EQ(1U, countRows("dhcp4_options"));
}
void
test_option_defs_[0]->getCode(),
test_option_defs_[0]->getOptionSpaceName());
ASSERT_TRUE(returned_option_def);
- EXPECT_GT(returned_option_def->getId(), 0);
- ASSERT_EQ(1, returned_option_def->getServerTags().size());
+ EXPECT_GT(returned_option_def->getId(), 0U);
+ ASSERT_EQ(1U, returned_option_def->getServerTags().size());
EXPECT_EQ("all", returned_option_def->getServerTags().begin()->get());
EXPECT_TRUE(returned_option_def->equals(*option_def));
MULTIPLE({ "server1", "server2",
"server3" }));
);
- ASSERT_EQ(3, returned_option_defs.size());
+ ASSERT_EQ(3U, returned_option_defs.size());
// Check that expected option definitions have been returned.
auto current_option = returned_option_defs.begin();
returned_option_defs = cbptr_->getAllOptionDefs4(ServerSelector::ALL());
);
- ASSERT_EQ(1, returned_option_defs.size());
+ ASSERT_EQ(1U, returned_option_defs.size());
EXPECT_TRUE((*returned_option_defs.begin())->equals(*option3));
// Delete the server1. It should remove associations of this server with the
returned_option_defs = cbptr_->getAllOptionDefs4(ServerSelector::ONE("server1"));
);
- ASSERT_EQ(1, returned_option_defs.size());
+ ASSERT_EQ(1U, returned_option_defs.size());
EXPECT_TRUE((*returned_option_defs.begin())->equals(*option3));
{
ASSERT_NO_THROW_LOG(deleted_num = cbptr_->deleteOptionDef4(ServerSelector::ONE("server1"),
option1->getCode(),
option1->getOptionSpaceName()));
- EXPECT_EQ(0, deleted_num);
+ EXPECT_EQ(0U, deleted_num);
// Deleting the existing option definition for server2 should succeed.
ASSERT_NO_THROW_LOG(deleted_num = cbptr_->deleteOptionDef4(ServerSelector::ONE("server2"),
option2->getCode(),
option2->getOptionSpaceName()));
- EXPECT_EQ(1, deleted_num);
+ EXPECT_EQ(1U, deleted_num);
// Create this option definition again to test that deletion of all servers
// removes it too.
ASSERT_NO_THROW_LOG(
returned_option_defs = cbptr_->getAllOptionDefs4(ServerSelector::ALL());
);
- EXPECT_EQ(1, deleted_num);
- EXPECT_EQ(1, returned_option_defs.size());
+ EXPECT_EQ(1U, deleted_num);
+ EXPECT_EQ(1U, returned_option_defs.size());
EXPECT_TRUE((*returned_option_defs.begin())->equals(*option3));
{
ASSERT_NO_THROW_LOG(parser.parse(storage, defs_elem));
auto test_defs = storage->getAll("dhcp4");
- ASSERT_EQ(test_defs->size(), 18);
+ ASSERT_EQ(test_defs->size(), 18U);
// Insert each option definition into the database.
for (auto const& test_def : *test_defs) {
// See if option definitions are returned ok.
for (auto const& def : option_defs) {
- ASSERT_EQ(1, def->getServerTags().size());
+ ASSERT_EQ(1U, def->getServerTags().size());
EXPECT_EQ("all", def->getServerTags().begin()->get());
bool success = false;
for (unsigned i = 1; i < test_option_defs_.size(); ++i) {
}
// Deleting non-existing option definition should return 0.
- EXPECT_EQ(0, cbptr_->deleteOptionDef4(ServerSelector::ALL(),
- 99, "non-exiting-space"));
+ EXPECT_EQ(0U, cbptr_->deleteOptionDef4(ServerSelector::ALL(),
+ 99, "non-exiting-space"));
// All option definitions should be still there.
ASSERT_EQ(test_option_defs_.size() - updates_num, option_defs.size());
// Should not delete option definition for explicit server tag
// because our option definition is for all servers.
- EXPECT_EQ(0, cbptr_->deleteOptionDef4(ServerSelector::ONE("server1"),
- test_option_defs_[1]->getCode(),
- test_option_defs_[1]->getOptionSpaceName()));
+ EXPECT_EQ(0U, cbptr_->deleteOptionDef4(ServerSelector::ONE("server1"),
+ test_option_defs_[1]->getCode(),
+ test_option_defs_[1]->getOptionSpaceName()));
// Same for all option definitions.
- EXPECT_EQ(0, cbptr_->deleteAllOptionDefs4(ServerSelector::ONE("server1")));
+ EXPECT_EQ(0U, cbptr_->deleteAllOptionDefs4(ServerSelector::ONE("server1")));
// Delete one of the option definitions and see if it is gone.
- EXPECT_EQ(1, cbptr_->deleteOptionDef4(ServerSelector::ALL(),
- test_option_defs_[2]->getCode(),
- test_option_defs_[2]->getOptionSpaceName()));
+ EXPECT_EQ(1U, cbptr_->deleteOptionDef4(ServerSelector::ALL(),
+ test_option_defs_[2]->getCode(),
+ test_option_defs_[2]->getOptionSpaceName()));
ASSERT_FALSE(cbptr_->getOptionDef4(ServerSelector::ALL(),
test_option_defs_[2]->getCode(),
test_option_defs_[2]->getOptionSpaceName()));
}
// Delete all remaining option definitions.
- EXPECT_EQ(2, cbptr_->deleteAllOptionDefs4(ServerSelector::ALL()));
+ EXPECT_EQ(2U, cbptr_->deleteAllOptionDefs4(ServerSelector::ALL()));
option_defs = cbptr_->getAllOptionDefs4(ServerSelector::ALL());
ASSERT_TRUE(option_defs.empty());
OptionDefContainer
option_defs = cbptr_->getModifiedOptionDefs4(ServerSelector::ALL(),
timestamps_["after today"]);
- ASSERT_EQ(1, option_defs.size());
+ ASSERT_EQ(1U, option_defs.size());
// Fetch option definitions with timestamp later than yesterday. We
// should get two option definitions.
option_defs = cbptr_->getModifiedOptionDefs4(ServerSelector::ALL(),
timestamps_["after yesterday"]);
- ASSERT_EQ(2, option_defs.size());
+ ASSERT_EQ(2U, option_defs.size());
// Fetch option definitions with timestamp later than tomorrow. Nothing
// should be returned.
}
// Deleting an option with explicitly specified server tag should fail.
- EXPECT_EQ(0, cbptr_->deleteOption4(ServerSelector::ONE("server1"),
- opt_boot_file_name->option_->getType(),
- opt_boot_file_name->space_name_));
+ EXPECT_EQ(0U, cbptr_->deleteOption4(ServerSelector::ONE("server1"),
+ opt_boot_file_name->option_->getType(),
+ opt_boot_file_name->space_name_));
// Deleting option for all servers should succeed.
- EXPECT_EQ(1, cbptr_->deleteOption4(ServerSelector::ALL(),
- opt_boot_file_name->option_->getType(),
- opt_boot_file_name->space_name_));
+ EXPECT_EQ(1U, cbptr_->deleteOption4(ServerSelector::ALL(),
+ opt_boot_file_name->option_->getType(),
+ opt_boot_file_name->space_name_));
EXPECT_FALSE(cbptr_->getOption4(ServerSelector::ALL(),
opt_boot_file_name->option_->getType(),
MULTIPLE({ "server1", "server2",
"server3" }));
);
- ASSERT_EQ(3, returned_options.size());
+ ASSERT_EQ(3U, returned_options.size());
// Check that expected options have been returned.
auto current_option = returned_options.begin();
ASSERT_NO_THROW_LOG(
returned_options = cbptr_->getAllOptions4(ServerSelector::ALL());
);
- ASSERT_EQ(1, returned_options.size());
+ ASSERT_EQ(1U, returned_options.size());
testOptionsEquivalent(*opt_boot_file_name3, *returned_options.begin());
// Delete the server1. It should remove associations of this server with the
ASSERT_NO_THROW_LOG(
returned_options = cbptr_->getAllOptions4(ServerSelector::ONE("server1"));
);
- ASSERT_EQ(1, returned_options.size());
+ ASSERT_EQ(1U, returned_options.size());
testOptionsEquivalent(*opt_boot_file_name3, *returned_options.begin());
{
ASSERT_NO_THROW_LOG(deleted_num = cbptr_->deleteOption4(ServerSelector::ONE("server1"),
opt_boot_file_name1->option_->getType(),
opt_boot_file_name1->space_name_));
- EXPECT_EQ(0, deleted_num);
+ EXPECT_EQ(0U, deleted_num);
// Deleting the existing option for server2 should succeed.
ASSERT_NO_THROW_LOG(deleted_num = cbptr_->deleteOption4(ServerSelector::ONE("server2"),
opt_boot_file_name2->option_->getType(),
opt_boot_file_name2->space_name_));
- EXPECT_EQ(1, deleted_num);
+ EXPECT_EQ(1U, deleted_num);
// Create this option again to test that deletion of all servers removes it too.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateOption4(ServerSelector::ONE("server2"),
ASSERT_NO_THROW_LOG(
returned_options = cbptr_->getAllOptions4(ServerSelector::ALL());
);
- EXPECT_EQ(1, deleted_num);
- ASSERT_EQ(1, returned_options.size());
+ EXPECT_EQ(1U, deleted_num);
+ ASSERT_EQ(1U, returned_options.size());
testOptionsEquivalent(*opt_boot_file_name3, *returned_options.begin());
{
// Retrieve all these options.
OptionContainer returned_options = cbptr_->getAllOptions4(ServerSelector::ALL());
- ASSERT_EQ(3, returned_options.size());
+ ASSERT_EQ(3U, returned_options.size());
// Fetching global options with explicitly specified server tag should return
// the same result.
returned_options = cbptr_->getAllOptions4(ServerSelector::ONE("server1"));
- ASSERT_EQ(3, returned_options.size());
+ ASSERT_EQ(3U, returned_options.size());
// Get the container index used to search options by option code.
const OptionContainerTypeIndex& index = returned_options.get<1>();
auto option0 = index.find(test_options_[0]->option_->getType());
ASSERT_FALSE(option0 == index.end());
testOptionsEquivalent(*test_options_[0], *option0);
- EXPECT_GT(option0->getId(), 0);
- ASSERT_EQ(1, option0->getServerTags().size());
+ EXPECT_GT(option0->getId(), 0U);
+ ASSERT_EQ(1U, option0->getServerTags().size());
EXPECT_EQ("all", option0->getServerTags().begin()->get());
}
auto option1 = index.find(test_options_[1]->option_->getType());
ASSERT_FALSE(option1 == index.end());
testOptionsEquivalent(*test_options_[1], *option1);
- EXPECT_GT(option1->getId(), 0);
- ASSERT_EQ(1, option1->getServerTags().size());
+ EXPECT_GT(option1->getId(), 0U);
+ ASSERT_EQ(1U, option1->getServerTags().size());
EXPECT_EQ("all", option1->getServerTags().begin()->get());
}
auto option5 = index.find(test_options_[5]->option_->getType());
ASSERT_FALSE(option5 == index.end());
testOptionsEquivalent(*test_options_[5], *option5);
- EXPECT_GT(option5->getId(), 0);
- ASSERT_EQ(1, option5->getServerTags().size());
+ EXPECT_GT(option5->getId(), 0U);
+ ASSERT_EQ(1U, option5->getServerTags().size());
EXPECT_EQ("all", option5->getServerTags().begin()->get());
}
}
OptionContainer returned_options =
cbptr_->getModifiedOptions4(ServerSelector::ALL(),
timestamps_["after today"]);
- ASSERT_EQ(1, returned_options.size());
+ ASSERT_EQ(1U, returned_options.size());
// Fetching modified options with explicitly specified server selector
// should return the same result.
returned_options = cbptr_->getModifiedOptions4(ServerSelector::ONE("server1"),
timestamps_["after today"]);
- ASSERT_EQ(1, returned_options.size());
+ ASSERT_EQ(1U, returned_options.size());
// The returned option should be the one with the timestamp
// set to tomorrow.
ClientClassesPtr cclasses = ref_option->copyClientClasses();
// Delete the option by code and client_classes.
- ASSERT_EQ(1, cbptr_->deleteOption4(ServerSelector::ALL(),
- ref_option->option_->getType(),
- DHCP4_OPTION_SPACE,
- cclasses));
+ ASSERT_EQ(1U, cbptr_->deleteOption4(ServerSelector::ALL(),
+ ref_option->option_->getType(),
+ DHCP4_OPTION_SPACE,
+ cclasses));
// Finding the option by code and client_classes should fail.
found_option = cbptr_->getOption4(ServerSelector::ALL(),
}
// The inserted subnet contains two options.
- ASSERT_EQ(2, countRows("dhcp4_options"));
+ ASSERT_EQ(2U, countRows("dhcp4_options"));
OptionDescriptorPtr opt_boot_file_name = test_options_[0];
cbptr_->createUpdateOption4(ServerSelector::ANY(), subnet->getID(),
{
SCOPED_TRACE("verify returned option");
testOptionsEquivalent(*opt_boot_file_name, returned_opt_boot_file_name);
- EXPECT_GT(returned_opt_boot_file_name.getId(), 0);
+ EXPECT_GT(returned_opt_boot_file_name.getId(), 0U);
}
{
// We have added one option to the existing subnet. We should now have
// three options.
- ASSERT_EQ(3, countRows("dhcp4_options"));
+ ASSERT_EQ(3U, countRows("dhcp4_options"));
opt_boot_file_name->persistent_ = !opt_boot_file_name->persistent_;
opt_boot_file_name->cancelled_ = !opt_boot_file_name->cancelled_;
// Updating the option should replace the existing instance with the new
// instance. Therefore, we should still have three options.
- ASSERT_EQ(3, countRows("dhcp4_options"));
+ ASSERT_EQ(3U, countRows("dhcp4_options"));
// It should succeed for any server.
- EXPECT_EQ(1, cbptr_->deleteOption4(ServerSelector::ANY(), subnet->getID(),
- opt_boot_file_name->option_->getType(),
- opt_boot_file_name->space_name_));
+ EXPECT_EQ(1U, cbptr_->deleteOption4(ServerSelector::ANY(), subnet->getID(),
+ opt_boot_file_name->option_->getType(),
+ opt_boot_file_name->space_name_));
returned_subnet = cbptr_->getSubnet4(ServerSelector::ALL(),
subnet->getID());
}
// We should have only two options after deleting one of them.
- ASSERT_EQ(2, countRows("dhcp4_options"));
+ ASSERT_EQ(2U, countRows("dhcp4_options"));
}
void
}
// Inserted subnet has two options.
- ASSERT_EQ(2, countRows("dhcp4_options"));
+ ASSERT_EQ(2U, countRows("dhcp4_options"));
// Add an option into the pool.
const PoolPtr pool = subnet->getPool(Lease::TYPE_V4,
{
SCOPED_TRACE("verify returned pool option");
testOptionsEquivalent(*opt_boot_file_name, returned_opt_boot_file_name);
- EXPECT_GT(returned_opt_boot_file_name.getId(), 0);
+ EXPECT_GT(returned_opt_boot_file_name.getId(), 0U);
}
{
}
// With the newly inserted option we should now have three options.
- ASSERT_EQ(3, countRows("dhcp4_options"));
+ ASSERT_EQ(3U, countRows("dhcp4_options"));
// Modify the option and update it in the database.
opt_boot_file_name->persistent_ = !opt_boot_file_name->persistent_;
// The new option instance should replace the existing one, so we should
// still have three options.
- ASSERT_EQ(3, countRows("dhcp4_options"));
+ ASSERT_EQ(3U, countRows("dhcp4_options"));
// Delete option for any server should succeed.
- EXPECT_EQ(1, cbptr_->deleteOption4(ServerSelector::ANY(),
- pool->getFirstAddress(),
- pool->getLastAddress(),
- opt_boot_file_name->option_->getType(),
- opt_boot_file_name->space_name_));
+ EXPECT_EQ(1U, cbptr_->deleteOption4(ServerSelector::ANY(),
+ pool->getFirstAddress(),
+ pool->getLastAddress(),
+ opt_boot_file_name->option_->getType(),
+ opt_boot_file_name->space_name_));
// Fetch the subnet and the pool from the database again to make sure
// that the option is really gone.
// The option has been deleted so the number of options should now
// be down to 2.
- EXPECT_EQ(2, countRows("dhcp4_options"));
+ EXPECT_EQ(2U, countRows("dhcp4_options"));
}
void
}
// The inserted shared network has no options.
- ASSERT_EQ(0, countRows("dhcp4_options"));
+ ASSERT_EQ(0U, countRows("dhcp4_options"));
OptionDescriptorPtr opt_boot_file_name = test_options_[0];
cbptr_->createUpdateOption4(ServerSelector::ANY(),
{
SCOPED_TRACE("verify returned option");
testOptionsEquivalent(*opt_boot_file_name, returned_opt_boot_file_name);
- EXPECT_GT(returned_opt_boot_file_name.getId(), 0);
+ EXPECT_GT(returned_opt_boot_file_name.getId(), 0U);
}
{
}
// One option should now be stored in the database.
- ASSERT_EQ(1, countRows("dhcp4_options"));
+ ASSERT_EQ(1U, countRows("dhcp4_options"));
opt_boot_file_name->persistent_ = !opt_boot_file_name->persistent_;
opt_boot_file_name->cancelled_ = !opt_boot_file_name->cancelled_;
// The new option instance should replace the existing option instance,
// so we should still have one option.
- ASSERT_EQ(1, countRows("dhcp4_options"));
+ ASSERT_EQ(1U, countRows("dhcp4_options"));
// Deleting an option for any server should succeed.
- EXPECT_EQ(1, cbptr_->deleteOption4(ServerSelector::ANY(),
- shared_network->getName(),
- opt_boot_file_name->option_->getType(),
- opt_boot_file_name->space_name_,
- opt_boot_file_name->copyClientClasses()));
+ EXPECT_EQ(1U, cbptr_->deleteOption4(ServerSelector::ANY(),
+ shared_network->getName(),
+ opt_boot_file_name->option_->getType(),
+ opt_boot_file_name->space_name_,
+ opt_boot_file_name->copyClientClasses()));
returned_network = cbptr_->getSharedNetwork4(ServerSelector::ALL(),
shared_network->getName());
ASSERT_TRUE(returned_network);
}
// After deleting the option we should be back to 0.
- EXPECT_EQ(0, countRows("dhcp4_options"));
+ EXPECT_EQ(0U, countRows("dhcp4_options"));
}
void
// Add a subnet with two pools with one option each.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet4(ServerSelector::ALL(), test_subnets_[1]));
- EXPECT_EQ(2, countRows("dhcp4_pool"));
- EXPECT_EQ(2, countRows("dhcp4_options"));
+ EXPECT_EQ(2U, countRows("dhcp4_pool"));
+ EXPECT_EQ(2U, countRows("dhcp4_options"));
// Add a second subnet with a single option. The number of options in the database
// should now be 3.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet4(ServerSelector::ALL(), test_subnets_[2]));
- EXPECT_EQ(2, countRows("dhcp4_pool"));
- EXPECT_EQ(3, countRows("dhcp4_options"));
+ EXPECT_EQ(2U, countRows("dhcp4_pool"));
+ EXPECT_EQ(3U, countRows("dhcp4_options"));
// Now replace the first subnet with three options and two pools. This will cause
// the option id values for this subnet to be larger than those in the second
// subnet.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet4(ServerSelector::ALL(), test_subnets_[0]));
- EXPECT_EQ(2, countRows("dhcp4_pool"));
- EXPECT_EQ(4, countRows("dhcp4_options"));
+ EXPECT_EQ(2U, countRows("dhcp4_pool"));
+ EXPECT_EQ(4U, countRows("dhcp4_options"));
// Now fetch all subnets.
Subnet4Collection subnets;
ASSERT_NO_THROW_LOG(subnets = cbptr_->getAllSubnets4(ServerSelector::ALL()));
- ASSERT_EQ(2, subnets.size());
+ ASSERT_EQ(2U, subnets.size());
// Verify that the subnets returned are as expected.
for (auto const& subnet : subnets) {
- ASSERT_EQ(1, subnet->getServerTags().size());
+ ASSERT_EQ(1U, subnet->getServerTags().size());
EXPECT_EQ("all", subnet->getServerTags().begin()->get());
if (subnet->getID() == 1024) {
EXPECT_EQ(test_subnets_[0]->toElement()->str(), subnet->toElement()->str());
SharedNetwork4Collection networks =
cbptr_->getAllSharedNetworks4(ServerSelector::ALL());
- ASSERT_EQ(2, networks.size());
+ ASSERT_EQ(2U, networks.size());
// See if shared networks are returned ok.
for (unsigned i = 0; i < networks.size(); ++i) {
// Fetch all shared networks.
networks = cbptr_->getAllSharedNetworks4(ServerSelector::ALL());
- ASSERT_EQ(2, networks.size());
+ ASSERT_EQ(2U, networks.size());
// See if shared networks are returned ok.
for (unsigned i = 0; i < networks.size(); ++i) {
// Only the first class should be returned for the server selector ALL.
auto client_classes = cbptr_->getAllClientClasses4(ServerSelector::ALL());
- ASSERT_EQ(1, client_classes.getClasses()->size());
+ ASSERT_EQ(1U, client_classes.getClasses()->size());
// All three classes should be returned for the server1.
client_classes = cbptr_->getAllClientClasses4(ServerSelector::ONE("server1"));
auto classes_list = client_classes.getClasses();
- ASSERT_EQ(3, classes_list->size());
+ ASSERT_EQ(3U, classes_list->size());
auto fetched_class = classes_list->begin();
ASSERT_EQ("foo", (*fetched_class)->getName());
// Ensure that the classes order has changed.
client_classes = cbptr_->getAllClientClasses4(ServerSelector::ONE("server1"));
classes_list = client_classes.getClasses();
- ASSERT_EQ(3, classes_list->size());
+ ASSERT_EQ(3U, classes_list->size());
EXPECT_EQ("foo", (*classes_list->begin())->getName());
EXPECT_FALSE((*classes_list->begin())->getMatchExpr());
EXPECT_EQ("foobar", (*(classes_list->begin() + 1))->getName());
client_classes = cbptr_->getAllClientClasses4(ServerSelector::ONE("server1"));
classes_list = client_classes.getClasses();
- ASSERT_EQ(3, classes_list->size());
+ ASSERT_EQ(3U, classes_list->size());
EXPECT_EQ("foo", (*classes_list->begin())->getName());
EXPECT_FALSE((*classes_list->begin())->getMatchExpr());
EXPECT_EQ("foobar", (*(classes_list->begin() + 1))->getName());
EXPECT_EQ("1.2.3.4", client_class->getNextServer().toText());
EXPECT_EQ("cool", client_class->getSname());
EXPECT_EQ("epc.cfg", client_class->getFilename());
- EXPECT_EQ(30, client_class->getValid().getMin());
- EXPECT_EQ(60, client_class->getValid().get());
- EXPECT_EQ(90, client_class->getValid().getMax());
+ EXPECT_EQ(30U, client_class->getValid().getMin());
+ EXPECT_EQ(60U, client_class->getValid().get());
+ EXPECT_EQ(90U, client_class->getValid().getMax());
// Validate options belonging to this class.
ASSERT_TRUE(client_class->getCfgOption());
ASSERT_TRUE(client_class);
// Verify lifetime values.
- EXPECT_EQ(30, client_class->getValid().getMin());
- EXPECT_EQ(60, client_class->getValid().get());
- EXPECT_EQ(90, client_class->getValid().getMax());
+ EXPECT_EQ(30U, client_class->getValid().getMin());
+ EXPECT_EQ(60U, client_class->getValid().get());
+ EXPECT_EQ(90U, client_class->getValid().getMax());
// Validate options belonging to the class.
ASSERT_TRUE(client_class->getCfgOption());
auto returned_def_foo = client_class->getCfgOptionDef()->get(test_option_defs_[0]->getOptionSpaceName(),
test_option_defs_[0]->getCode());
ASSERT_TRUE(returned_def_foo);
- EXPECT_EQ(234, returned_def_foo->getCode());
+ EXPECT_EQ(234U, returned_def_foo->getCode());
EXPECT_EQ("foo", returned_def_foo->getName());
EXPECT_EQ(DHCP4_OPTION_SPACE, returned_def_foo->getOptionSpaceName());
EXPECT_EQ("espace", returned_def_foo->getEncapsulatedSpace());
auto returned_def_fish = client_class->getCfgOptionDef()->get(test_option_defs_[2]->getOptionSpaceName(),
test_option_defs_[2]->getCode());
ASSERT_TRUE(returned_def_fish);
- EXPECT_EQ(235, returned_def_fish->getCode());
+ EXPECT_EQ(235U, returned_def_fish->getCode());
EXPECT_EQ("fish", returned_def_fish->getName());
EXPECT_EQ(DHCP4_OPTION_SPACE, returned_def_fish->getOptionSpaceName());
EXPECT_TRUE(returned_def_fish->getEncapsulatedSpace().empty());
ASSERT_TRUE(client_class);
// Re-check lifetime values. This ensure bindings line up.
- EXPECT_EQ(30, client_class->getValid().getMin());
- EXPECT_EQ(60, client_class->getValid().get());
- EXPECT_EQ(90, client_class->getValid().getMax());
+ EXPECT_EQ(30U, client_class->getValid().getMin());
+ EXPECT_EQ(60U, client_class->getValid().get());
+ EXPECT_EQ(90U, client_class->getValid().getMax());
// Ensure that the first option definition is gone.
ASSERT_TRUE(client_class->getCfgOptionDef());
// Get modified client classes configured for all servers.
auto client_classes = cbptr_->getModifiedClientClasses4(ServerSelector::ALL(),
timestamps_["two days ago"]);
- EXPECT_EQ(2, client_classes.getClasses()->size());
+ EXPECT_EQ(2U, client_classes.getClasses()->size());
// Get modified client classes appropriate for server1. It includes classes
// for all servers and for the server1.
client_classes = cbptr_->getModifiedClientClasses4(ServerSelector::ONE("server1"),
timestamps_["two days ago"]);
- EXPECT_EQ(3, client_classes.getClasses()->size());
+ EXPECT_EQ(3U, client_classes.getClasses()->size());
// Get the classes again but use the timestamp equal to the modification
// time of the first class.
client_classes = cbptr_->getModifiedClientClasses4(ServerSelector::ONE("server1"),
timestamps_["yesterday"]);
- EXPECT_EQ(3, client_classes.getClasses()->size());
+ EXPECT_EQ(3U, client_classes.getClasses()->size());
// Get modified classes starting from today. It should return only two.
client_classes = cbptr_->getModifiedClientClasses4(ServerSelector::ONE("server1"),
timestamps_["today"]);
- EXPECT_EQ(2, client_classes.getClasses()->size());
+ EXPECT_EQ(2U, client_classes.getClasses()->size());
// Get client classes modified in the future. It should return none.
client_classes = cbptr_->getModifiedClientClasses4(ServerSelector::ONE("server1"),
timestamps_["after tomorrow"]);
- EXPECT_EQ(0, client_classes.getClasses()->size());
+ EXPECT_EQ(0U, client_classes.getClasses()->size());
// Getting modified client classes for any server is unsupported.
ASSERT_THROW(cbptr_->getModifiedClientClasses4(ServerSelector::ANY(),
uint64_t result;
ASSERT_NO_THROW_LOG(result = cbptr_->deleteClientClass4(ServerSelector::ONE("server1"),
class2->getName()));
- EXPECT_EQ(1, result);
+ EXPECT_EQ(1U, result);
{
SCOPED_TRACE("client class bar is deleted");
testNewAuditEntry("dhcp4_client_class",
ASSERT_NO_THROW_LOG(result = cbptr_->deleteClientClass4(ServerSelector::ONE("server2"),
class3->getName()));
- EXPECT_EQ(1, result);
+ EXPECT_EQ(1U, result);
{
SCOPED_TRACE("client class foobar is deleted");
testNewAuditEntry("dhcp4_client_class",
ASSERT_NO_THROW_LOG(result = cbptr_->deleteClientClass4(ServerSelector::ANY(),
class1->getName()));
- EXPECT_EQ(1, result);
+ EXPECT_EQ(1U, result);
{
SCOPED_TRACE("client class foo is deleted and no longer available for the server1");
testNewAuditEntry("dhcp4_client_class",
uint64_t result;
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses4(ServerSelector::UNASSIGNED()));
- EXPECT_EQ(0, result);
+ EXPECT_EQ(0U, result);
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses4(ServerSelector::ONE("server2")));
- EXPECT_EQ(1, result);
+ EXPECT_EQ(1U, result);
{
SCOPED_TRACE("client classes for server2 deleted");
testNewAuditEntry("dhcp4_client_class",
}
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses4(ServerSelector::ONE("server2")));
- EXPECT_EQ(0, result);
+ EXPECT_EQ(0U, result);
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses4(ServerSelector::ONE("server1")));
- EXPECT_EQ(1, result);
+ EXPECT_EQ(1U, result);
{
SCOPED_TRACE("client classes for server1 deleted");
testNewAuditEntry("dhcp4_client_class",
}
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses4(ServerSelector::ONE("server1")));
- EXPECT_EQ(0, result);
+ EXPECT_EQ(0U, result);
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses4(ServerSelector::ALL()));
- EXPECT_EQ(1, result);
+ EXPECT_EQ(1U, result);
{
SCOPED_TRACE("client classes for all deleted");
testNewAuditEntry("dhcp4_client_class",
}
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses4(ServerSelector::ALL()));
- EXPECT_EQ(0, result);
+ EXPECT_EQ(0U, result);
// Deleting multiple objects using ANY server tag is unsupported.
ASSERT_THROW(cbptr_->deleteAllClientClasses4(ServerSelector::ANY()), InvalidOperation);
// Now make sure that we can delete the options individually.
for (auto const& ref_option : ref_options) {
- ASSERT_EQ(1, cbptr_->deleteOption4(ServerSelector::ANY(),
- network->getName(),
- ref_option->option_->getType(),
- DHCP4_OPTION_SPACE,
- ref_option->copyClientClasses()));
+ ASSERT_EQ(1U, cbptr_->deleteOption4(ServerSelector::ANY(),
+ network->getName(),
+ ref_option->option_->getType(),
+ DHCP4_OPTION_SPACE,
+ ref_option->copyClientClasses()));
}
// Re-fetch the network.
// Now make sure that we can delete the options individually.
for (auto const& ref_option : ref_options) {
- ASSERT_EQ(1, cbptr_->deleteOption4(ServerSelector::ANY(),
- subnet->getID(),
- ref_option->option_->getType(),
- DHCP4_OPTION_SPACE,
- ref_option->copyClientClasses()));
+ ASSERT_EQ(1U, cbptr_->deleteOption4(ServerSelector::ANY(),
+ subnet->getID(),
+ ref_option->option_->getType(),
+ DHCP4_OPTION_SPACE,
+ ref_option->copyClientClasses()));
}
// Re-fetch the subnet.
// Now make sure that we can delete the options individually.
for (auto const& ref_option : ref_options) {
- ASSERT_EQ(1, cbptr_->deleteOption4(ServerSelector::ANY(),
- pool->getFirstAddress(),
- pool->getLastAddress(),
- ref_option->option_->getType(),
- DHCP4_OPTION_SPACE,
- ref_option->copyClientClasses()));
+ ASSERT_EQ(1U, cbptr_->deleteOption4(ServerSelector::ANY(),
+ pool->getFirstAddress(),
+ pool->getLastAddress(),
+ ref_option->option_->getType(),
+ DHCP4_OPTION_SPACE,
+ ref_option->copyClientClasses()));
}
// Re-fetch the subnet.
ASSERT_THROW_MSG(deleted_num = cbptr_->deleteOptionDef4(ServerSelector::ALL(),
234, DHCP4_OPTION_SPACE),
InvalidOperation, "option exists for option definition: dhcp4.234");
- EXPECT_EQ(0, deleted_num);
+ EXPECT_EQ(0U, deleted_num);
ASSERT_THROW_MSG(deleted_num = cbptr_->deleteOptionDef4(ServerSelector::ALL(),
234, DHCP4_OPTION_SPACE, false),
InvalidOperation, "option exists for option definition: dhcp4.234");
- EXPECT_EQ(0, deleted_num);
+ EXPECT_EQ(0U, deleted_num);
ASSERT_NO_THROW_LOG(deleted_num = cbptr_->deleteOptionDef4(ServerSelector::ALL(),
234, DHCP4_OPTION_SPACE, true));
- EXPECT_EQ(1, deleted_num);
+ EXPECT_EQ(1U, deleted_num);
}
// Try to delete non-existing server.
ASSERT_NO_THROW_LOG(servers_deleted = cbptr_->deleteServer6(ServerTag("server2")));
- EXPECT_EQ(0, servers_deleted);
+ EXPECT_EQ(0U, servers_deleted);
// Make sure that the server1 wasn't deleted.
ASSERT_NO_THROW_LOG(returned_server = cbptr_->getServer6(ServerTag("server1")));
// Delete the existing server.
ASSERT_NO_THROW_LOG(servers_deleted = cbptr_->deleteServer6(ServerTag("server1")));
- EXPECT_EQ(1, servers_deleted);
+ EXPECT_EQ(1U, servers_deleted);
{
SCOPED_TRACE("DELETE audit entry for server");
// inserted servers. The logical 'all' server should be excluded.
EXPECT_EQ(test_servers_.size() - 1, deleted_servers);
- EXPECT_EQ(1, countRows("dhcp6_server"));
+ EXPECT_EQ(1U, countRows("dhcp6_server"));
}
void
EXPECT_EQ("whale", returned_global_parameter->getValue());
EXPECT_TRUE(returned_global_parameter->getModificationTime() ==
global_parameter->getModificationTime());
- ASSERT_EQ(1, returned_global_parameter->getServerTags().size());
+ ASSERT_EQ(1U, returned_global_parameter->getServerTags().size());
EXPECT_EQ("all", returned_global_parameter->getServerTags().begin()->get());
// Because we have added the global parameter for all servers, it
EXPECT_EQ("whale", returned_global_parameter->getValue());
EXPECT_TRUE(returned_global_parameter->getModificationTime() ==
global_parameter->getModificationTime());
- ASSERT_EQ(1, returned_global_parameter->getServerTags().size());
+ ASSERT_EQ(1U, returned_global_parameter->getServerTags().size());
EXPECT_EQ("all", returned_global_parameter->getServerTags().begin()->get());
// Check that the parameter is updated when selector is specified correctly.
EXPECT_EQ("fish", returned_global_parameter->getValue());
EXPECT_TRUE(returned_global_parameter->getModificationTime() ==
global_parameter->getModificationTime());
- ASSERT_EQ(1, returned_global_parameter->getServerTags().size());
+ ASSERT_EQ(1U, returned_global_parameter->getServerTags().size());
EXPECT_EQ("all", returned_global_parameter->getServerTags().begin()->get());
{
// Should not delete parameter specified for all servers if explicit
// server name is provided.
- EXPECT_EQ(0, cbptr_->deleteGlobalParameter6(ServerSelector::ONE("server1"),
- "global"));
+ EXPECT_EQ(0U,
+ cbptr_->deleteGlobalParameter6(ServerSelector::ONE("server1"),
+ "global"));
// Delete parameter and make sure it is gone.
cbptr_->deleteGlobalParameter6(ServerSelector::ALL(), "global");
);
ASSERT_TRUE(returned_global);
EXPECT_EQ(global_parameter3->getValue(), returned_global->getValue());
- ASSERT_EQ(1, returned_global->getServerTags().size());
+ ASSERT_EQ(1U, returned_global->getServerTags().size());
EXPECT_EQ("all", returned_global->getServerTags().begin()->get());
// Try to fetch the value specified for the server1. This should override the
ASSERT_TRUE(returned_global);
EXPECT_EQ(global_parameter1->getValue(), returned_global->getValue());
- ASSERT_EQ(1, returned_global->getServerTags().size());
+ ASSERT_EQ(1U, returned_global->getServerTags().size());
EXPECT_EQ("server1", returned_global->getServerTags().begin()->get());
// The same in case of the server2.
);
ASSERT_TRUE(returned_global);
EXPECT_EQ(global_parameter2->getValue(), returned_global->getValue());
- ASSERT_EQ(1, returned_global->getServerTags().size());
+ ASSERT_EQ(1U, returned_global->getServerTags().size());
EXPECT_EQ("server2", returned_global->getServerTags().begin()->get());
StampedValueCollection returned_globals;
MULTIPLE({ "server1", "server2",
"server3" }));
);
- ASSERT_EQ(3, returned_globals.size());
+ ASSERT_EQ(3U, returned_globals.size());
// Capture the returned values into the map so as we can check the
// values against the servers.
std::map<std::string, std::string> values;
for (auto const& g : returned_globals) {
- ASSERT_EQ(1, g->getServerTags().size());
+ ASSERT_EQ(1U, g->getServerTags().size());
values[g->getServerTags().begin()->get()] = g->getValue();
}
- ASSERT_EQ(3, values.size());
+ ASSERT_EQ(3U, values.size());
EXPECT_EQ(global_parameter1->getValue(), values["server1"]);
EXPECT_EQ(global_parameter2->getValue(), values["server2"]);
EXPECT_EQ(global_parameter3->getValue(), values["all"]);
ASSERT_NO_THROW_LOG(
returned_globals = cbptr_->getAllGlobalParameters6(ServerSelector::ALL())
);
- ASSERT_EQ(1, returned_globals.size());
+ ASSERT_EQ(1U, returned_globals.size());
returned_global = *returned_globals.begin();
EXPECT_EQ(global_parameter3->getValue(), returned_global->getValue());
- ASSERT_EQ(1, returned_global->getServerTags().size());
+ ASSERT_EQ(1U, returned_global->getServerTags().size());
EXPECT_EQ("all", returned_global->getServerTags().begin()->get());
// Delete the server1. It should remove associations of this server with the
ASSERT_NO_THROW_LOG(
returned_globals = cbptr_->getAllGlobalParameters6(ServerSelector::ONE("server1"))
);
- ASSERT_EQ(1, returned_globals.size());
+ ASSERT_EQ(1U, returned_globals.size());
returned_global = *returned_globals.begin();
// As a result, the value fetched for the server1 should be the one available for
// all servers, rather than the one dedicated for server1. The association of
// the server1 specific value with the server1 should be gone.
EXPECT_EQ(global_parameter3->getValue(), returned_global->getValue());
- ASSERT_EQ(1, returned_global->getServerTags().size());
+ ASSERT_EQ(1U, returned_global->getServerTags().size());
EXPECT_EQ("all", returned_global->getServerTags().begin()->get());
{
"global"));
// No parameters should be deleted. In particular, the parameter for the logical
// server 'all' should not be deleted.
- EXPECT_EQ(0, deleted_num);
+ EXPECT_EQ(0U, deleted_num);
// Deleting the existing value for server2 should succeed.
ASSERT_NO_THROW_LOG(deleted_num = cbptr_->deleteGlobalParameter6(ServerSelector::ONE("server2"),
"global"));
- EXPECT_EQ(1, deleted_num);
+ EXPECT_EQ(1U, deleted_num);
// Create it again to test that deletion of all server removes this too.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateGlobalParameter6(ServerSelector::ONE("server2"),
ASSERT_NO_THROW_LOG(
returned_globals = cbptr_->getAllGlobalParameters6(ServerSelector::ALL())
);
- EXPECT_EQ(1, deleted_num);
- ASSERT_EQ(1, returned_globals.size());
+ EXPECT_EQ(1U, deleted_num);
+ ASSERT_EQ(1U, returned_globals.size());
returned_global = *returned_globals.begin();
// The common value for all servers should still be available because 'all'
// logical server should not be deleted.
EXPECT_EQ(global_parameter3->getValue(), returned_global->getValue());
- ASSERT_EQ(1, returned_global->getServerTags().size());
+ ASSERT_EQ(1U, returned_global->getServerTags().size());
EXPECT_EQ("all", returned_global->getServerTags().begin()->get());
{
// Fetch all parameters.
auto parameters = cbptr_->getAllGlobalParameters6(ServerSelector::ALL());
- ASSERT_EQ(5, parameters.size());
+ ASSERT_EQ(5U, parameters.size());
auto const& parameters_index = parameters.get<StampedValueNameIndexTag>();
EXPECT_EQ(1.65, (*parameters_index.find("name5"))->getDoubleValue());
for (auto const& param : parameters_index) {
- ASSERT_EQ(1, param->getServerTags().size());
+ ASSERT_EQ(1U, param->getServerTags().size());
EXPECT_EQ("all", param->getServerTags().begin()->get());
}
// Should be able to fetch these parameters when explicitly providing
// the server tag.
parameters = cbptr_->getAllGlobalParameters6(ServerSelector::ONE("server1"));
- EXPECT_EQ(5, parameters.size());
+ EXPECT_EQ(5U, parameters.size());
// Deleting global parameters with non-matching server selector
// should fail.
- EXPECT_EQ(0, cbptr_->deleteAllGlobalParameters6(ServerSelector::ONE("server1")));
+ EXPECT_EQ(0U,
+ cbptr_->deleteAllGlobalParameters6(ServerSelector::ONE("server1")));
// Delete all parameters and make sure they are gone.
- EXPECT_EQ(5, cbptr_->deleteAllGlobalParameters6(ServerSelector::ALL()));
+ EXPECT_EQ(5U, cbptr_->deleteAllGlobalParameters6(ServerSelector::ALL()));
parameters = cbptr_->getAllGlobalParameters6(ServerSelector::ALL());
EXPECT_TRUE(parameters.empty());
}
auto const& parameters_index = parameters.get<StampedValueNameIndexTag>();
// It should be the one modified "tomorrow".
- ASSERT_EQ(1, parameters_index.size());
+ ASSERT_EQ(1U, parameters_index.size());
auto parameter = parameters_index.find("name3");
ASSERT_FALSE(parameter == parameters_index.end());
// the server tag.
parameters = cbptr_->getModifiedGlobalParameters6(ServerSelector::ONE("server1"),
timestamps_["after today"]);
- EXPECT_EQ(1, parameters.size());
+ EXPECT_EQ(1U, parameters.size());
}
void
returned_subnet_2 = cbptr_->getSubnet6(server_selector, subnet->getID()));
ASSERT_TRUE(returned_subnet_2);
- ASSERT_EQ(1, returned_subnet_2->getServerTags().size());
+ ASSERT_EQ(1U, returned_subnet_2->getServerTags().size());
EXPECT_TRUE(returned_subnet_2->hasServerTag(ServerTag(expected_tag)));
ASSERT_EQ(subnet->toElement()->str(), returned_subnet_2->toElement()->str());
returned_subnet_2 = cbptr_->getSubnet6(server_selector, subnet->toText()));
ASSERT_TRUE(returned_subnet_2);
- ASSERT_EQ(1, returned_subnet_2->getServerTags().size());
+ ASSERT_EQ(1U, returned_subnet_2->getServerTags().size());
EXPECT_TRUE(returned_subnet_2->hasServerTag(ServerTag(expected_tag)));
EXPECT_EQ(subnet->toElement()->str(), returned_subnet_2->toElement()->str());
EXPECT_TRUE(returned_subnet->getClientClasses().empty());
EXPECT_TRUE(returned_subnet->getValid().unspecified());
- EXPECT_EQ(0, returned_subnet->getValid().get());
+ EXPECT_EQ(0U, returned_subnet->getValid().get());
EXPECT_TRUE(returned_subnet->getPreferred().unspecified());
- EXPECT_EQ(0, returned_subnet->getPreferred().get());
+ EXPECT_EQ(0U, returned_subnet->getPreferred().get());
EXPECT_TRUE(returned_subnet->getT1().unspecified());
- EXPECT_EQ(0, returned_subnet->getT1().get());
+ EXPECT_EQ(0U, returned_subnet->getT1().get());
EXPECT_TRUE(returned_subnet->getT2().unspecified());
- EXPECT_EQ(0, returned_subnet->getT2().get());
+ EXPECT_EQ(0U, returned_subnet->getT2().get());
EXPECT_TRUE(returned_subnet->getReservationsGlobal().unspecified());
EXPECT_FALSE(returned_subnet->getReservationsGlobal().get());
Subnet6Ptr returned_subnet = cbptr_->getSubnet6(ServerSelector::ALL(),
test_subnets_[0]->getID());
ASSERT_TRUE(returned_subnet);
- ASSERT_EQ(1, returned_subnet->getServerTags().size());
+ ASSERT_EQ(1U, returned_subnet->getServerTags().size());
EXPECT_EQ("all", returned_subnet->getServerTags().begin()->get());
// The easiest way to verify whether the returned subnet matches the inserted
Subnet6Ptr returned_subnet = cbptr_->getSubnet6(ServerSelector::ALL(),
"2001:db8::/64");
ASSERT_TRUE(returned_subnet);
- ASSERT_EQ(1, returned_subnet->getServerTags().size());
+ ASSERT_EQ(1U, returned_subnet->getServerTags().size());
EXPECT_EQ("all", returned_subnet->getServerTags().begin()->get());
// Verify subnet contents.
// See if the subnets are returned ok.
auto subnet_it = subnets.begin();
for (unsigned i = 0; i < subnets.size(); ++i, ++subnet_it) {
- ASSERT_EQ(1, (*subnet_it)->getServerTags().size());
+ ASSERT_EQ(1U, (*subnet_it)->getServerTags().size());
EXPECT_EQ("all", (*subnet_it)->getServerTags().begin()->get());
EXPECT_EQ(test_subnets_[i + 1]->toElement()->str(),
(*subnet_it)->toElement()->str());
}
// Attempt to remove the non existing subnet should return 0.
- EXPECT_EQ(0, cbptr_->deleteSubnet6(ServerSelector::ALL(), 22));
- EXPECT_EQ(0, cbptr_->deleteSubnet6(ServerSelector::ALL(),
- "2001:db8:555::/64"));
+ EXPECT_EQ(0U, cbptr_->deleteSubnet6(ServerSelector::ALL(), 22));
+ EXPECT_EQ(0U, cbptr_->deleteSubnet6(ServerSelector::ALL(),
+ "2001:db8:555::/64"));
// All subnets should be still there.
ASSERT_EQ(test_subnets_.size() - 1, subnets.size());
// Should not delete the subnet for explicit server tag because
// our subnet is for all servers.
- EXPECT_EQ(0, cbptr_->deleteSubnet6(ServerSelector::ONE("server1"),
- test_subnets_[1]->getID()));
+ EXPECT_EQ(0U, cbptr_->deleteSubnet6(ServerSelector::ONE("server1"),
+ test_subnets_[1]->getID()));
// Also, verify that behavior when deleting by prefix.
- EXPECT_EQ(0, cbptr_->deleteSubnet6(ServerSelector::ONE("server1"),
- test_subnets_[2]->toText()));
+ EXPECT_EQ(0U, cbptr_->deleteSubnet6(ServerSelector::ONE("server1"),
+ test_subnets_[2]->toText()));
// Same for all subnets.
- EXPECT_EQ(0, cbptr_->deleteAllSubnets6(ServerSelector::ONE("server1")));
+ EXPECT_EQ(0U, cbptr_->deleteAllSubnets6(ServerSelector::ONE("server1")));
// Delete first subnet by id and verify that it is gone.
- EXPECT_EQ(1, cbptr_->deleteSubnet6(ServerSelector::ALL(),
- test_subnets_[1]->getID()));
+ EXPECT_EQ(1U, cbptr_->deleteSubnet6(ServerSelector::ALL(),
+ test_subnets_[1]->getID()));
{
SCOPED_TRACE("DELETE first subnet audit entry");
ASSERT_EQ(test_subnets_.size() - 2, subnets.size());
// Delete second subnet by prefix and verify it is gone.
- EXPECT_EQ(1, cbptr_->deleteSubnet6(ServerSelector::ALL(),
- test_subnets_[2]->toText()));
+ EXPECT_EQ(1U, cbptr_->deleteSubnet6(ServerSelector::ALL(),
+ test_subnets_[2]->toText()));
subnets = cbptr_->getAllSubnets6(ServerSelector::ALL());
ASSERT_EQ(test_subnets_.size() - 3, subnets.size());
}
// Delete all.
- EXPECT_EQ(1, cbptr_->deleteAllSubnets6(ServerSelector::ALL()));
+ EXPECT_EQ(1U, cbptr_->deleteAllSubnets6(ServerSelector::ALL()));
subnets = cbptr_->getAllSubnets6(ServerSelector::ALL());
ASSERT_TRUE(subnets.empty());
// All three subnets are associated with the server1.
ASSERT_NO_THROW_LOG(subnets = cbptr_->getAllSubnets6(ServerSelector::ONE("server1")));
- EXPECT_EQ(3, subnets.size());
+ EXPECT_EQ(3U, subnets.size());
// First subnet is associated with all servers.
auto returned_subnet = SubnetFetcher6::get(subnets, SubnetID(1024));
// For server2 we should only get two subnets, i.e. first and last.
ASSERT_NO_THROW_LOG(subnets = cbptr_->getAllSubnets6(ServerSelector::ONE("server2")));
- EXPECT_EQ(2, subnets.size());
+ EXPECT_EQ(2U, subnets.size());
// First subnet is associated with all servers.
returned_subnet = SubnetFetcher6::get(subnets, SubnetID(1024));
// Only the first subnet is associated with all servers.
ASSERT_NO_THROW_LOG(subnets = cbptr_->getAllSubnets6(ServerSelector::ALL()));
- EXPECT_EQ(1, subnets.size());
+ EXPECT_EQ(1U, subnets.size());
returned_subnet = SubnetFetcher6::get(subnets, SubnetID(1024));
ASSERT_TRUE(returned_subnet);
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteSubnet6(server_selector, subnet->getID())
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
deleted_count = 0;
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteSubnet6(server_selector, subnet->toText())
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
};
{
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteSubnet6(server_selector, subnet->getID())
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
EXPECT_FALSE(cbptr_->getSubnet6(server_selector, subnet->getID()));
};
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteSubnet6(server_selector, subnet->toText())
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
EXPECT_FALSE(cbptr_->getSubnet6(server_selector, subnet->toText()));
};
// i.e. do not belong to any server.
uint64_t deleted_count = 0;
ASSERT_NO_THROW_LOG(deleted_count = cbptr_->deleteServer6(ServerTag("server1")));
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
// Trying to fetch the subnet by server tag should return no result.
Subnet6Ptr returned_subnet;
// Also if we ask for all unassigned subnets it should be returned.
ASSERT_NO_THROW_LOG(returned_subnets = cbptr_->getAllSubnets6(ServerSelector::UNASSIGNED()));
- ASSERT_EQ(2, returned_subnets.size());
+ ASSERT_EQ(2U, returned_subnets.size());
// Same for modified subnets.
ASSERT_NO_THROW_LOG(
returned_subnets = cbptr_->getModifiedSubnets6(ServerSelector::UNASSIGNED(),
timestamps_["two days ago"])
);
- ASSERT_EQ(2, returned_subnets.size());
+ ASSERT_EQ(2U, returned_subnets.size());
// If we ask for any subnet by subnet id, it should be returned too.
ASSERT_NO_THROW_LOG(returned_subnet = cbptr_->getSubnet6(ServerSelector::ANY(),
deleted_count = cbptr_->deleteSubnet6(ServerSelector::ONE("server1"),
subnet->getID())
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
// Also, if we delete all subnets for server1.
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteAllSubnets6(ServerSelector::ONE("server1"))
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
// We can delete this subnet when we specify ANY and the matching id.
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteSubnet6(ServerSelector::ANY(), subnet->getID())
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
// We can delete all subnets using UNASSIGNED selector.
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteAllSubnets6(ServerSelector::UNASSIGNED());
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
}
void
Subnet6Collection
subnets = cbptr_->getModifiedSubnets6(ServerSelector::ALL(),
timestamps_["after today"]);
- ASSERT_EQ(1, subnets.size());
+ ASSERT_EQ(1U, subnets.size());
// All subnets should also be returned for explicitly specified server tag.
subnets = cbptr_->getModifiedSubnets6(ServerSelector::ONE("server1"),
timestamps_["after today"]);
- ASSERT_EQ(1, subnets.size());
+ ASSERT_EQ(1U, subnets.size());
// Fetch subnets with timestamp later than yesterday. We should get
// two subnets.
subnets = cbptr_->getModifiedSubnets6(ServerSelector::ALL(),
timestamps_["after yesterday"]);
- ASSERT_EQ(2, subnets.size());
+ ASSERT_EQ(2U, subnets.size());
// Fetch subnets with timestamp later than tomorrow. Nothing should
// be returned.
// Fetch all subnets belonging to shared network level1.
Subnet6Collection subnets = cbptr_->getSharedNetworkSubnets6(ServerSelector::ALL(),
"level1");
- ASSERT_EQ(1, subnets.size());
+ ASSERT_EQ(1U, subnets.size());
// Returned subnet should match test subnet #1.
EXPECT_TRUE(isEquivalent(test_subnets_[1]->toElement(),
// All subnets should also be returned for ANY server.
subnets = cbptr_->getSharedNetworkSubnets6(ServerSelector::ANY(), "level1");
- ASSERT_EQ(1, subnets.size());
+ ASSERT_EQ(1U, subnets.size());
// Returned subnet should match test subnet #1.
EXPECT_TRUE(isEquivalent(test_subnets_[1]->toElement(),
(*subnets.begin())->toElement()));
// Check server tag
- ASSERT_EQ(1, (*subnets.begin())->getServerTags().size());
+ ASSERT_EQ(1U, (*subnets.begin())->getServerTags().size());
EXPECT_EQ("all", (*subnets.begin())->getServerTags().begin()->get());
// Fetch all subnets belonging to shared network level2.
subnets = cbptr_->getSharedNetworkSubnets6(ServerSelector::ALL(), "level2");
- ASSERT_EQ(2, subnets.size());
+ ASSERT_EQ(2U, subnets.size());
ElementPtr test_list = Element::createList();
test_list->add(test_subnets_[2]->toElement());
// All subnets should also be returned for explicitly specified server tag.
subnets = cbptr_->getSharedNetworkSubnets6(ServerSelector::ONE("server1"), "level2");
- ASSERT_EQ(2, subnets.size());
+ ASSERT_EQ(2U, subnets.size());
returned_list = Element::createList();
subnet = subnets.begin();
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet6(ServerSelector::ALL(),
test_subnets_[0]));
// Make sure that the pools have been added to the database.
- EXPECT_EQ(2, countRows("dhcp6_pool"));
- EXPECT_EQ(2, countRows("dhcp6_pd_pool"));
+ EXPECT_EQ(2U, countRows("dhcp6_pool"));
+ EXPECT_EQ(2U, countRows("dhcp6_pd_pool"));
// Create the subnet without options which updates the existing
// subnet.
subnet_id));
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet6(ServerSelector::ALL(), subnet));
// Check that options are gone.
- EXPECT_EQ(0, countRows("dhcp6_pool"));
- EXPECT_EQ(0, countRows("dhcp6_pd_pool"));
+ EXPECT_EQ(0U, countRows("dhcp6_pool"));
+ EXPECT_EQ(0U, countRows("dhcp6_pd_pool"));
};
{
GenericConfigBackendDHCPv6Test::subnetOptionsTest() {
// Add the subnet with two pools and three options.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet6(ServerSelector::ALL(), test_subnets_[0]));
- EXPECT_EQ(2, countRows("dhcp6_pool"));
- EXPECT_EQ(2, countRows("dhcp6_pd_pool"));
- EXPECT_EQ(3, countRows("dhcp6_options"));
+ EXPECT_EQ(2U, countRows("dhcp6_pool"));
+ EXPECT_EQ(2U, countRows("dhcp6_pd_pool"));
+ EXPECT_EQ(3U, countRows("dhcp6_options"));
// The second subnet uses the same subnet id, so this operation should replace
// the existing subnet and its options. The new instance has four pools, each
// including one option, so we should end up with four options.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet6(ServerSelector::ALL(), test_subnets_[1]));
- EXPECT_EQ(2, countRows("dhcp6_pool"));
- EXPECT_EQ(2, countRows("dhcp6_pd_pool"));
- EXPECT_EQ(4, countRows("dhcp6_options"));
+ EXPECT_EQ(2U, countRows("dhcp6_pool"));
+ EXPECT_EQ(2U, countRows("dhcp6_pd_pool"));
+ EXPECT_EQ(4U, countRows("dhcp6_options"));
// Add third subnet with a single option. The number of options in the database
// should now be 5.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet6(ServerSelector::ALL(), test_subnets_[2]));
- EXPECT_EQ(2, countRows("dhcp6_pool"));
- EXPECT_EQ(2, countRows("dhcp6_pd_pool"));
- EXPECT_EQ(5, countRows("dhcp6_options"));
+ EXPECT_EQ(2U, countRows("dhcp6_pool"));
+ EXPECT_EQ(2U, countRows("dhcp6_pd_pool"));
+ EXPECT_EQ(5U, countRows("dhcp6_options"));
// Delete the subnet. All options and pools it contains should also be removed, leaving
// the last added subnet and its sole option.
ASSERT_NO_THROW_LOG(cbptr_->deleteSubnet6(ServerSelector::ALL(), test_subnets_[1]->getID()));
- EXPECT_EQ(1, countRows("dhcp6_subnet"));
- EXPECT_EQ(0, countRows("dhcp6_pool"));
- EXPECT_EQ(0, countRows("dhcp6_pd_pool"));
- EXPECT_EQ(1, countRows("dhcp6_options"));
+ EXPECT_EQ(1U, countRows("dhcp6_subnet"));
+ EXPECT_EQ(0U, countRows("dhcp6_pool"));
+ EXPECT_EQ(0U, countRows("dhcp6_pd_pool"));
+ EXPECT_EQ(1U, countRows("dhcp6_options"));
// Add the first subnet again. We should now have 4 options: 3 options from the
// newly added subnet and one option from the existing subnet.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet6(ServerSelector::ALL(), test_subnets_[0]));
- EXPECT_EQ(2, countRows("dhcp6_pool"));
- EXPECT_EQ(2, countRows("dhcp6_pd_pool"));
- EXPECT_EQ(4, countRows("dhcp6_options"));
+ EXPECT_EQ(2U, countRows("dhcp6_pool"));
+ EXPECT_EQ(2U, countRows("dhcp6_pd_pool"));
+ EXPECT_EQ(4U, countRows("dhcp6_options"));
// Delete the subnet including 3 options. The option from the other subnet should not
// be affected.
ASSERT_NO_THROW_LOG(cbptr_->deleteSubnet6(ServerSelector::ALL(), test_subnets_[0]->getID()));
- EXPECT_EQ(1, countRows("dhcp6_subnet"));
- EXPECT_EQ(0, countRows("dhcp6_pool"));
- EXPECT_EQ(0, countRows("dhcp6_pd_pool"));
- EXPECT_EQ(1, countRows("dhcp6_options"));
+ EXPECT_EQ(1U, countRows("dhcp6_subnet"));
+ EXPECT_EQ(0U, countRows("dhcp6_pool"));
+ EXPECT_EQ(0U, countRows("dhcp6_pd_pool"));
+ EXPECT_EQ(1U, countRows("dhcp6_options"));
}
void
shared_network->getName()));
ASSERT_TRUE(network);
- EXPECT_GT(network->getId(), 0);
- ASSERT_EQ(1, network->getServerTags().size());
+ EXPECT_GT(network->getId(), 0U);
+ ASSERT_EQ(1U, network->getServerTags().size());
EXPECT_EQ(expected_tag, network->getServerTags().begin()->get());
// The easiest way to verify whether the returned shared network matches the
EXPECT_TRUE(returned_network->getClientClasses().empty());
EXPECT_TRUE(returned_network->getValid().unspecified());
- EXPECT_EQ(0, returned_network->getValid().get());
+ EXPECT_EQ(0U, returned_network->getValid().get());
EXPECT_TRUE(returned_network->getPreferred().unspecified());
- EXPECT_EQ(0, returned_network->getPreferred().get());
+ EXPECT_EQ(0U, returned_network->getPreferred().get());
EXPECT_TRUE(returned_network->getT1().unspecified());
- EXPECT_EQ(0, returned_network->getT1().get());
+ EXPECT_EQ(0U, returned_network->getT1().get());
EXPECT_TRUE(returned_network->getT2().unspecified());
- EXPECT_EQ(0, returned_network->getT2().get());
+ EXPECT_EQ(0U, returned_network->getT2().get());
EXPECT_TRUE(returned_network->getReservationsGlobal().unspecified());
EXPECT_FALSE(returned_network->getReservationsGlobal().get());
for (unsigned i = 0; i < networks.size(); ++i) {
EXPECT_EQ(test_networks_[i + 1]->toElement()->str(),
networks[i]->toElement()->str());
- ASSERT_EQ(1, networks[i]->getServerTags().size());
+ ASSERT_EQ(1U, networks[i]->getServerTags().size());
EXPECT_EQ("all", networks[i]->getServerTags().begin()->get());
}
}
// Deleting non-existing shared network should return 0.
- EXPECT_EQ(0, cbptr_->deleteSharedNetwork6(ServerSelector::ALL(),
- "big-fish"));
+ EXPECT_EQ(0U, cbptr_->deleteSharedNetwork6(ServerSelector::ALL(),
+ "big-fish"));
// All shared networks should be still there.
ASSERT_EQ(test_networks_.size() - 1, networks.size());
// Should not delete the shared network for explicit server tag
// because our shared network is for all servers.
- EXPECT_EQ(0, cbptr_->deleteSharedNetwork6(ServerSelector::ONE("server1"),
- test_networks_[1]->getName()));
+ EXPECT_EQ(0U, cbptr_->deleteSharedNetwork6(ServerSelector::ONE("server1"),
+ test_networks_[1]->getName()));
// Same for all shared networks.
- EXPECT_EQ(0, cbptr_->deleteAllSharedNetworks6(ServerSelector::ONE("server1")));
+ EXPECT_EQ(0U, cbptr_->deleteAllSharedNetworks6(ServerSelector::ONE("server1")));
// Delete first shared network with it subnets and verify it is gone.
// Begin by its subnet.
- EXPECT_EQ(1, cbptr_->deleteSharedNetworkSubnets6(ServerSelector::ANY(),
- test_networks_[1]->getName()));
+ EXPECT_EQ(1U, cbptr_->deleteSharedNetworkSubnets6(ServerSelector::ANY(),
+ test_networks_[1]->getName()));
{
SCOPED_TRACE("DELETE audit entry for subnets of the first shared network");
EXPECT_FALSE(subnet);
// And after the shared network itself.
- EXPECT_EQ(1, cbptr_->deleteSharedNetwork6(ServerSelector::ALL(),
- test_networks_[1]->getName()));
+ EXPECT_EQ(1U, cbptr_->deleteSharedNetwork6(ServerSelector::ALL(),
+ test_networks_[1]->getName()));
networks = cbptr_->getAllSharedNetworks6(ServerSelector::ALL());
ASSERT_EQ(test_networks_.size() - 2, networks.size());
}
// Delete all.
- EXPECT_EQ(2, cbptr_->deleteAllSharedNetworks6(ServerSelector::ALL()));
+ EXPECT_EQ(2U, cbptr_->deleteAllSharedNetworks6(ServerSelector::ALL()));
networks = cbptr_->getAllSharedNetworks6(ServerSelector::ALL());
ASSERT_TRUE(networks.empty());
// All three networks are associated with the server1.
ASSERT_NO_THROW_LOG(networks = cbptr_->getAllSharedNetworks6(ServerSelector::ONE("server1")));
- EXPECT_EQ(3, networks.size());
+ EXPECT_EQ(3U, networks.size());
// First network is associated with all servers.
auto returned_network = SharedNetworkFetcher6::get(networks, "level1");
// For server2 we should only get two shared networks, i.e. first and last.
ASSERT_NO_THROW_LOG(networks = cbptr_->getAllSharedNetworks6(ServerSelector::ONE("server2")));
- EXPECT_EQ(2, networks.size());
+ EXPECT_EQ(2U, networks.size());
// First shared network is associated with all servers.
returned_network = SharedNetworkFetcher6::get(networks, "level1");
// Only the first shared network is associated with all servers.
ASSERT_NO_THROW_LOG(networks = cbptr_->getAllSharedNetworks6(ServerSelector::ALL()));
- EXPECT_EQ(1, networks.size());
+ EXPECT_EQ(1U, networks.size());
returned_network = SharedNetworkFetcher6::get(networks, "level1");
ASSERT_TRUE(returned_network);
SharedNetwork6Collection
networks = cbptr_->getModifiedSharedNetworks6(ServerSelector::ALL(),
timestamps_["after today"]);
- ASSERT_EQ(1, networks.size());
+ ASSERT_EQ(1U, networks.size());
// Fetch shared networks with timestamp later than yesterday. We
// should get two shared networks.
networks = cbptr_->getModifiedSharedNetworks6(ServerSelector::ALL(),
timestamps_["after yesterday"]);
- ASSERT_EQ(2, networks.size());
+ ASSERT_EQ(2U, networks.size());
// Fetch shared networks with timestamp later than tomorrow. Nothing
// should be returned.
deleted_count = cbptr_->deleteSharedNetwork6(server_selector,
shared_network->getName())
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
};
{
deleted_count = cbptr_->deleteSharedNetwork6(server_selector,
shared_network->getName())
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
EXPECT_FALSE(cbptr_->getSharedNetwork6(server_selector,
shared_network->getName()));
// considered orphaned, i.e. do not belong to any server.
uint64_t deleted_count = 0;
ASSERT_NO_THROW_LOG(deleted_count = cbptr_->deleteServer6(ServerTag("server1")));
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
// Trying to fetch this shared network by server tag should return no result.
SharedNetwork6Ptr returned_network;
// Also if we ask for all unassigned networks it should be returned.
ASSERT_NO_THROW_LOG(returned_networks = cbptr_->getAllSharedNetworks6(ServerSelector::UNASSIGNED()));
- ASSERT_EQ(2, returned_networks.size());
+ ASSERT_EQ(2U, returned_networks.size());
// And all modified.
ASSERT_NO_THROW_LOG(
returned_networks = cbptr_->getModifiedSharedNetworks6(ServerSelector::UNASSIGNED(),
timestamps_["two days ago"])
);
- ASSERT_EQ(2, returned_networks.size());
+ ASSERT_EQ(2U, returned_networks.size());
// If we ask for any network by name, it should be returned too.
ASSERT_NO_THROW_LOG(returned_network = cbptr_->getSharedNetwork6(ServerSelector::ANY(),
deleted_count = cbptr_->deleteSharedNetwork6(ServerSelector::ONE("server1"),
"level1")
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
// Also, if we delete all shared networks for server1.
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteAllSharedNetworks6(ServerSelector::ONE("server1"))
);
- EXPECT_EQ(0, deleted_count);
+ EXPECT_EQ(0U, deleted_count);
// We can delete this shared network when we specify ANY and the matching name.
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteSharedNetwork6(ServerSelector::ANY(), "level1")
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
// We can delete all networks using UNASSIGNED selector.
ASSERT_NO_THROW_LOG(
deleted_count = cbptr_->deleteAllSharedNetworks6(ServerSelector::UNASSIGNED());
);
- EXPECT_EQ(1, deleted_count);
+ EXPECT_EQ(1U, deleted_count);
}
void
GenericConfigBackendDHCPv6Test::sharedNetworkOptionsTest() {
// Add shared network with three options.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSharedNetwork6(ServerSelector::ALL(), test_networks_[0]));
- EXPECT_EQ(3, countRows("dhcp6_options"));
+ EXPECT_EQ(3U, countRows("dhcp6_options"));
// Add another shared network with a single option. The numnber of options in the
// database should now be 4.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSharedNetwork6(ServerSelector::ALL(), test_networks_[2]));
- EXPECT_EQ(4, countRows("dhcp6_options"));
+ EXPECT_EQ(4U, countRows("dhcp6_options"));
// The second shared network uses the same name as the first shared network, so
// this operation should replace the existing shared network and its options.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSharedNetwork6(ServerSelector::ALL(), test_networks_[1]));
- EXPECT_EQ(1, countRows("dhcp6_options"));
+ EXPECT_EQ(1U, countRows("dhcp6_options"));
// Remove the shared network. This should not affect options assigned to the
// other shared network.
ASSERT_NO_THROW_LOG(cbptr_->deleteSharedNetwork6(ServerSelector::ALL(),
test_networks_[1]->getName()));
- EXPECT_EQ(1, countRows("dhcp6_shared_network"));
- EXPECT_EQ(1, countRows("dhcp6_options"));
+ EXPECT_EQ(1U, countRows("dhcp6_shared_network"));
+ EXPECT_EQ(1U, countRows("dhcp6_options"));
// Create the first option again. The number of options should be equal to the
// sum of options associated with both shared networks.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSharedNetwork6(ServerSelector::ALL(), test_networks_[0]));
- EXPECT_EQ(4, countRows("dhcp6_options"));
+ EXPECT_EQ(4U, countRows("dhcp6_options"));
// Delete this shared network. This should not affect the option associated
// with the remaining shared network.
ASSERT_NO_THROW_LOG(cbptr_->deleteSharedNetwork6(ServerSelector::ALL(),
test_networks_[0]->getName()));
- EXPECT_EQ(1, countRows("dhcp6_shared_network"));
- EXPECT_EQ(1, countRows("dhcp6_options"));
+ EXPECT_EQ(1U, countRows("dhcp6_shared_network"));
+ EXPECT_EQ(1U, countRows("dhcp6_options"));
}
void
test_option_defs_[0]->getCode(),
test_option_defs_[0]->getOptionSpaceName());
ASSERT_TRUE(returned_option_def);
- EXPECT_GT(returned_option_def->getId(), 0);
- ASSERT_EQ(1, returned_option_def->getServerTags().size());
+ EXPECT_GT(returned_option_def->getId(), 0U);
+ ASSERT_EQ(1U, returned_option_def->getServerTags().size());
EXPECT_EQ("all", returned_option_def->getServerTags().begin()->get());
EXPECT_TRUE(returned_option_def->equals(*option_def));
MULTIPLE({ "server1", "server2",
"server3" }));
);
- ASSERT_EQ(3, returned_option_defs.size());
+ ASSERT_EQ(3U, returned_option_defs.size());
// Check that expected option definitions have been returned.
auto current_option = returned_option_defs.begin();
returned_option_defs = cbptr_->getAllOptionDefs6(ServerSelector::ALL());
);
- ASSERT_EQ(1, returned_option_defs.size());
+ ASSERT_EQ(1U, returned_option_defs.size());
EXPECT_TRUE((*returned_option_defs.begin())->equals(*option3));
// Delete the server1. It should remove associations of this server with the
returned_option_defs = cbptr_->getAllOptionDefs6(ServerSelector::ONE("server1"));
);
- ASSERT_EQ(1, returned_option_defs.size());
+ ASSERT_EQ(1U, returned_option_defs.size());
EXPECT_TRUE((*returned_option_defs.begin())->equals(*option3));
{
ASSERT_NO_THROW_LOG(deleted_num = cbptr_->deleteOptionDef6(ServerSelector::ONE("server1"),
option1->getCode(),
option1->getOptionSpaceName()));
- EXPECT_EQ(0, deleted_num);
+ EXPECT_EQ(0U, deleted_num);
// Deleting the existing option definition for server2 should succeed.
ASSERT_NO_THROW_LOG(deleted_num = cbptr_->deleteOptionDef6(ServerSelector::ONE("server2"),
option2->getCode(),
option2->getOptionSpaceName()));
- EXPECT_EQ(1, deleted_num);
+ EXPECT_EQ(1U, deleted_num);
// Create this option definition again to test that deletion of all servers
// removes it too.
ASSERT_NO_THROW_LOG(
returned_option_defs = cbptr_->getAllOptionDefs6(ServerSelector::ALL());
);
- EXPECT_EQ(1, deleted_num);
- EXPECT_EQ(1, returned_option_defs.size());
+ EXPECT_EQ(1U, deleted_num);
+ EXPECT_EQ(1U, returned_option_defs.size());
EXPECT_TRUE((*returned_option_defs.begin())->equals(*option3));
{
ASSERT_NO_THROW_LOG(parser.parse(storage, defs_elem));
auto test_defs = storage->getAll("dhcp6");
- ASSERT_EQ(test_defs->size(), 18);
+ ASSERT_EQ(test_defs->size(), 18U);
// Insert each option definition into the database.
for (auto const& test_def : *test_defs) {
// See if option definitions are returned ok.
for (auto const& def : option_defs) {
- ASSERT_EQ(1, def->getServerTags().size());
+ ASSERT_EQ(1U, def->getServerTags().size());
EXPECT_EQ("all", def->getServerTags().begin()->get());
bool success = false;
for (unsigned i = 1; i < test_option_defs_.size(); ++i) {
}
// Deleting non-existing option definition should return 0.
- EXPECT_EQ(0, cbptr_->deleteOptionDef6(ServerSelector::ALL(),
- 99, "non-exiting-space"));
+ EXPECT_EQ(0U, cbptr_->deleteOptionDef6(ServerSelector::ALL(),
+ 99, "non-exiting-space"));
// All option definitions should be still there.
ASSERT_EQ(test_option_defs_.size() - updates_num, option_defs.size());
// Should not delete option definition for explicit server tag
// because our option definition is for all servers.
- EXPECT_EQ(0, cbptr_->deleteOptionDef6(ServerSelector::ONE("server1"),
- test_option_defs_[1]->getCode(),
- test_option_defs_[1]->getOptionSpaceName()));
+ EXPECT_EQ(0U, cbptr_->deleteOptionDef6(ServerSelector::ONE("server1"),
+ test_option_defs_[1]->getCode(),
+ test_option_defs_[1]->getOptionSpaceName()));
// Same for all option definitions.
- EXPECT_EQ(0, cbptr_->deleteAllOptionDefs6(ServerSelector::ONE("server1")));
+ EXPECT_EQ(0U, cbptr_->deleteAllOptionDefs6(ServerSelector::ONE("server1")));
// Delete one of the option definitions and see if it is gone.
- EXPECT_EQ(1, cbptr_->deleteOptionDef6(ServerSelector::ALL(),
- test_option_defs_[2]->getCode(),
- test_option_defs_[2]->getOptionSpaceName()));
+ EXPECT_EQ(1U, cbptr_->deleteOptionDef6(ServerSelector::ALL(),
+ test_option_defs_[2]->getCode(),
+ test_option_defs_[2]->getOptionSpaceName()));
ASSERT_FALSE(cbptr_->getOptionDef6(ServerSelector::ALL(),
test_option_defs_[2]->getCode(),
test_option_defs_[2]->getOptionSpaceName()));
}
// Delete all remaining option definitions.
- EXPECT_EQ(2, cbptr_->deleteAllOptionDefs6(ServerSelector::ALL()));
+ EXPECT_EQ(2U, cbptr_->deleteAllOptionDefs6(ServerSelector::ALL()));
option_defs = cbptr_->getAllOptionDefs6(ServerSelector::ALL());
ASSERT_TRUE(option_defs.empty());
OptionDefContainer
option_defs = cbptr_->getModifiedOptionDefs6(ServerSelector::ALL(),
timestamps_["after today"]);
- ASSERT_EQ(1, option_defs.size());
+ ASSERT_EQ(1U, option_defs.size());
// Fetch option definitions with timestamp later than yesterday. We
// should get two option definitions.
option_defs = cbptr_->getModifiedOptionDefs6(ServerSelector::ALL(),
timestamps_["after yesterday"]);
- ASSERT_EQ(2, option_defs.size());
+ ASSERT_EQ(2U, option_defs.size());
// Fetch option definitions with timestamp later than tomorrow. Nothing
// should be returned.
}
// Deleting an option with explicitly specified server tag should fail.
- EXPECT_EQ(0, cbptr_->deleteOption6(ServerSelector::ONE("server1"),
- opt_posix_timezone->option_->getType(),
- opt_posix_timezone->space_name_));
+ EXPECT_EQ(0U, cbptr_->deleteOption6(ServerSelector::ONE("server1"),
+ opt_posix_timezone->option_->getType(),
+ opt_posix_timezone->space_name_));
// Deleting option for all servers should succeed.
- EXPECT_EQ(1, cbptr_->deleteOption6(ServerSelector::ALL(),
- opt_posix_timezone->option_->getType(),
- opt_posix_timezone->space_name_));
+ EXPECT_EQ(1U, cbptr_->deleteOption6(ServerSelector::ALL(),
+ opt_posix_timezone->option_->getType(),
+ opt_posix_timezone->space_name_));
EXPECT_FALSE(cbptr_->getOption6(ServerSelector::ALL(),
opt_posix_timezone->option_->getType(),
MULTIPLE({ "server1", "server2",
"server3" }));
);
- ASSERT_EQ(3, returned_options.size());
+ ASSERT_EQ(3U, returned_options.size());
// Check that expected options have been returned.
auto current_option = returned_options.begin();
ASSERT_NO_THROW_LOG(
returned_options = cbptr_->getAllOptions6(ServerSelector::ALL());
);
- ASSERT_EQ(1, returned_options.size());
+ ASSERT_EQ(1U, returned_options.size());
testOptionsEquivalent(*opt_timezone3, *returned_options.begin());
// Delete the server1. It should remove associations of this server with the
ASSERT_NO_THROW_LOG(
returned_options = cbptr_->getAllOptions6(ServerSelector::ONE("server1"));
);
- ASSERT_EQ(1, returned_options.size());
+ ASSERT_EQ(1U, returned_options.size());
testOptionsEquivalent(*opt_timezone3, *returned_options.begin());
{
ASSERT_NO_THROW_LOG(deleted_num = cbptr_->deleteOption6(ServerSelector::ONE("server1"),
opt_timezone1->option_->getType(),
opt_timezone1->space_name_));
- EXPECT_EQ(0, deleted_num);
+ EXPECT_EQ(0U, deleted_num);
// Deleting the existing option for server2 should succeed.
ASSERT_NO_THROW_LOG(deleted_num = cbptr_->deleteOption6(ServerSelector::ONE("server2"),
opt_timezone2->option_->getType(),
opt_timezone2->space_name_));
- EXPECT_EQ(1, deleted_num);
+ EXPECT_EQ(1U, deleted_num);
// Create this option again to test that deletion of all servers removes it too.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateOption6(ServerSelector::ONE("server2"),
ASSERT_NO_THROW_LOG(
returned_options = cbptr_->getAllOptions6(ServerSelector::ALL());
);
- EXPECT_EQ(1, deleted_num);
- ASSERT_EQ(1, returned_options.size());
+ EXPECT_EQ(1U, deleted_num);
+ ASSERT_EQ(1U, returned_options.size());
testOptionsEquivalent(*opt_timezone3, *returned_options.begin());
{
// Retrieve all these options.
OptionContainer returned_options = cbptr_->getAllOptions6(ServerSelector::ALL());
- ASSERT_EQ(3, returned_options.size());
+ ASSERT_EQ(3U, returned_options.size());
// Fetching global options with explicitly specified server tag should return
// the same result.
returned_options = cbptr_->getAllOptions6(ServerSelector::ONE("server1"));
- ASSERT_EQ(3, returned_options.size());
+ ASSERT_EQ(3U, returned_options.size());
// Get the container index used to search options by option code.
const OptionContainerTypeIndex& index = returned_options.get<1>();
auto option0 = index.find(test_options_[0]->option_->getType());
ASSERT_FALSE(option0 == index.end());
testOptionsEquivalent(*test_options_[0], *option0);
- EXPECT_GT(option0->getId(), 0);
- ASSERT_EQ(1, option0->getServerTags().size());
+ EXPECT_GT(option0->getId(), 0U);
+ ASSERT_EQ(1U, option0->getServerTags().size());
EXPECT_EQ("all", option0->getServerTags().begin()->get());
}
auto option1 = index.find(test_options_[1]->option_->getType());
ASSERT_FALSE(option1 == index.end());
testOptionsEquivalent(*test_options_[1], *option1);
- EXPECT_GT(option1->getId(), 0);
- ASSERT_EQ(1, option1->getServerTags().size());
+ EXPECT_GT(option1->getId(), 0U);
+ ASSERT_EQ(1U, option1->getServerTags().size());
EXPECT_EQ("all", option1->getServerTags().begin()->get());
}
auto option5 = index.find(test_options_[5]->option_->getType());
ASSERT_FALSE(option5 == index.end());
testOptionsEquivalent(*test_options_[5], *option5);
- EXPECT_GT(option5->getId(), 0);
- ASSERT_EQ(1, option5->getServerTags().size());
+ EXPECT_GT(option5->getId(), 0U);
+ ASSERT_EQ(1U, option5->getServerTags().size());
EXPECT_EQ("all", option5->getServerTags().begin()->get());
}
}
OptionContainer returned_options =
cbptr_->getModifiedOptions6(ServerSelector::ALL(),
timestamps_["after today"]);
- ASSERT_EQ(1, returned_options.size());
+ ASSERT_EQ(1U, returned_options.size());
// Fetching modified options with explicitly specified server selector
// should return the same result.
returned_options = cbptr_->getModifiedOptions6(ServerSelector::ONE("server1"),
timestamps_["after today"]);
- ASSERT_EQ(1, returned_options.size());
+ ASSERT_EQ(1U, returned_options.size());
// The returned option should be the one with the timestamp
// set to tomorrow.
ClientClassesPtr cclasses = ref_option->copyClientClasses();
// Delete the option by code and client_classes.
- ASSERT_EQ(1, cbptr_->deleteOption6(ServerSelector::ALL(),
- ref_option->option_->getType(),
- DHCP6_OPTION_SPACE,
- cclasses));
+ ASSERT_EQ(1U, cbptr_->deleteOption6(ServerSelector::ALL(),
+ ref_option->option_->getType(),
+ DHCP6_OPTION_SPACE,
+ cclasses));
// Finding the option by code and client_classes should fail.
found_option = cbptr_->getOption6(ServerSelector::ALL(),
}
// The inserted subnet contains four options.
- ASSERT_EQ(4, countRows("dhcp6_options"));
+ ASSERT_EQ(4U, countRows("dhcp6_options"));
OptionDescriptorPtr opt_posix_timezone = test_options_[0];
cbptr_->createUpdateOption6(ServerSelector::ANY(), subnet->getID(),
{
SCOPED_TRACE("verify returned option");
testOptionsEquivalent(*opt_posix_timezone, returned_opt_posix_timezone);
- EXPECT_GT(returned_opt_posix_timezone.getId(), 0);
+ EXPECT_GT(returned_opt_posix_timezone.getId(), 0U);
}
{
// We have added one option to the existing subnet. We should now have
// five options.
- ASSERT_EQ(5, countRows("dhcp6_options"));
+ ASSERT_EQ(5U, countRows("dhcp6_options"));
opt_posix_timezone->persistent_ = !opt_posix_timezone->persistent_;
opt_posix_timezone->cancelled_ = !opt_posix_timezone->cancelled_;
// Updating the option should replace the existing instance with the new
// instance. Therefore, we should still have five options.
- ASSERT_EQ(5, countRows("dhcp6_options"));
+ ASSERT_EQ(5U, countRows("dhcp6_options"));
// It should succeed for any server.
- EXPECT_EQ(1, cbptr_->deleteOption6(ServerSelector::ANY(), subnet->getID(),
- opt_posix_timezone->option_->getType(),
- opt_posix_timezone->space_name_,
- opt_posix_timezone->copyClientClasses()));
+ EXPECT_EQ(1U, cbptr_->deleteOption6(ServerSelector::ANY(), subnet->getID(),
+ opt_posix_timezone->option_->getType(),
+ opt_posix_timezone->space_name_,
+ opt_posix_timezone->copyClientClasses()));
returned_subnet = cbptr_->getSubnet6(ServerSelector::ALL(),
subnet->getID());
}
// We should have only four options after deleting one of them.
- ASSERT_EQ(4, countRows("dhcp6_options"));
+ ASSERT_EQ(4U, countRows("dhcp6_options"));
}
void
}
// Inserted subnet has four options.
- ASSERT_EQ(4, countRows("dhcp6_options"));
+ ASSERT_EQ(4U, countRows("dhcp6_options"));
// Add an option into the pool.
const PoolPtr pool = subnet->getPool(Lease::TYPE_NA,
{
SCOPED_TRACE("verify returned pool option");
testOptionsEquivalent(*opt_posix_timezone, returned_opt_posix_timezone);
- EXPECT_GT(returned_opt_posix_timezone.getId(), 0);
+ EXPECT_GT(returned_opt_posix_timezone.getId(), 0U);
}
{
}
// With the newly inserted option we should now have five options.
- ASSERT_EQ(5, countRows("dhcp6_options"));
+ ASSERT_EQ(5U, countRows("dhcp6_options"));
// Modify the option and update it in the database.
opt_posix_timezone->persistent_ = !opt_posix_timezone->persistent_;
// The new option instance should replace the existing one, so we should
// still have five options.
- ASSERT_EQ(5, countRows("dhcp6_options"));
+ ASSERT_EQ(5U, countRows("dhcp6_options"));
// Delete option for any server should succeed.
- EXPECT_EQ(1, cbptr_->deleteOption6(ServerSelector::ANY(),
- pool->getFirstAddress(),
- pool->getLastAddress(),
- opt_posix_timezone->option_->getType(),
- opt_posix_timezone->space_name_));
+ EXPECT_EQ(1U, cbptr_->deleteOption6(ServerSelector::ANY(),
+ pool->getFirstAddress(),
+ pool->getLastAddress(),
+ opt_posix_timezone->option_->getType(),
+ opt_posix_timezone->space_name_));
// Fetch the subnet and the pool from the database again to make sure
// that the option is really gone.
// The option has been deleted so the number of options should now
// be down to 4.
- EXPECT_EQ(4, countRows("dhcp6_options"));
+ EXPECT_EQ(4U, countRows("dhcp6_options"));
}
void
}
// Inserted subnet has four options.
- ASSERT_EQ(4, countRows("dhcp6_options"));
+ ASSERT_EQ(4U, countRows("dhcp6_options"));
// Add an option into the pd pool.
const PoolPtr pd_pool = subnet->getPool(Lease::TYPE_PD,
{
SCOPED_TRACE("verify returned pool option");
testOptionsEquivalent(*opt_posix_timezone, returned_opt_posix_timezone);
- EXPECT_GT(returned_opt_posix_timezone.getId(), 0);
+ EXPECT_GT(returned_opt_posix_timezone.getId(), 0U);
}
{
}
// With the newly inserted option we should now have five options.
- ASSERT_EQ(5, countRows("dhcp6_options"));
+ ASSERT_EQ(5U, countRows("dhcp6_options"));
// Modify the option and update it in the database.
opt_posix_timezone->persistent_ = !opt_posix_timezone->persistent_;
// The new option instance should replace the existing one, so we should
// still have five options.
- ASSERT_EQ(5, countRows("dhcp6_options"));
+ ASSERT_EQ(5U, countRows("dhcp6_options"));
// Delete option for any server should succeed.
- EXPECT_EQ(1, cbptr_->deleteOption6(ServerSelector::ANY(),
- pd_pool->getFirstAddress(),
- static_cast<uint8_t>(pd_pool_len),
- opt_posix_timezone->option_->getType(),
- opt_posix_timezone->space_name_));
+ EXPECT_EQ(1U, cbptr_->deleteOption6(ServerSelector::ANY(),
+ pd_pool->getFirstAddress(),
+ static_cast<uint8_t>(pd_pool_len),
+ opt_posix_timezone->option_->getType(),
+ opt_posix_timezone->space_name_));
// Fetch the subnet and the pool from the database again to make sure
// that the option is really gone.
// The option has been deleted so the number of options should now
// be down to 4.
- EXPECT_EQ(4, countRows("dhcp6_options"));
+ EXPECT_EQ(4U, countRows("dhcp6_options"));
}
void
}
// The inserted shared network has no options.
- ASSERT_EQ(0, countRows("dhcp6_options"));
+ ASSERT_EQ(0U, countRows("dhcp6_options"));
OptionDescriptorPtr opt_posix_timezone = test_options_[0];
cbptr_->createUpdateOption6(ServerSelector::ANY(),
{
SCOPED_TRACE("verify returned option");
testOptionsEquivalent(*opt_posix_timezone, returned_opt_posix_timezone);
- EXPECT_GT(returned_opt_posix_timezone.getId(), 0);
+ EXPECT_GT(returned_opt_posix_timezone.getId(), 0U);
}
{
}
// One option should now be stored in the database.
- ASSERT_EQ(1, countRows("dhcp6_options"));
+ ASSERT_EQ(1U, countRows("dhcp6_options"));
opt_posix_timezone->persistent_ = !opt_posix_timezone->persistent_;
opt_posix_timezone->cancelled_ = !opt_posix_timezone->cancelled_;
// The new option instance should replace the existing option instance,
// so we should still have one option.
- ASSERT_EQ(1, countRows("dhcp6_options"));
+ ASSERT_EQ(1U, countRows("dhcp6_options"));
// Deleting an option for any server should succeed.
- EXPECT_EQ(1, cbptr_->deleteOption6(ServerSelector::ANY(),
- shared_network->getName(),
- opt_posix_timezone->option_->getType(),
- opt_posix_timezone->space_name_));
+ EXPECT_EQ(1U, cbptr_->deleteOption6(ServerSelector::ANY(),
+ shared_network->getName(),
+ opt_posix_timezone->option_->getType(),
+ opt_posix_timezone->space_name_));
returned_network = cbptr_->getSharedNetwork6(ServerSelector::ALL(),
shared_network->getName());
ASSERT_TRUE(returned_network);
}
// After deleting the option we should be back to 0.
- EXPECT_EQ(0, countRows("dhcp6_options"));
+ EXPECT_EQ(0U, countRows("dhcp6_options"));
}
void
// Add a subnet with two pools with two options each.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet6(ServerSelector::ALL(), test_subnets_[1]));
- EXPECT_EQ(2, countRows("dhcp6_pool"));
- EXPECT_EQ(4, countRows("dhcp6_options"));
+ EXPECT_EQ(2U, countRows("dhcp6_pool"));
+ EXPECT_EQ(4U, countRows("dhcp6_options"));
// Add a second subnet with a single option. The number of options in the database
// should now be 3.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet6(ServerSelector::ALL(), test_subnets_[2]));
- EXPECT_EQ(2, countRows("dhcp6_pool"));
- EXPECT_EQ(5, countRows("dhcp6_options"));
+ EXPECT_EQ(2U, countRows("dhcp6_pool"));
+ EXPECT_EQ(5U, countRows("dhcp6_options"));
// Now replace the first subnet with three options and two pools. This will cause
// the option id values for this subnet to be larger than those in the second
// subnet.
ASSERT_NO_THROW_LOG(cbptr_->createUpdateSubnet6(ServerSelector::ALL(), test_subnets_[0]));
- EXPECT_EQ(2, countRows("dhcp6_pool"));
- EXPECT_EQ(4, countRows("dhcp6_options"));
+ EXPECT_EQ(2U, countRows("dhcp6_pool"));
+ EXPECT_EQ(4U, countRows("dhcp6_options"));
// Now fetch all subnets.
Subnet6Collection subnets;
ASSERT_NO_THROW_LOG(subnets = cbptr_->getAllSubnets6(ServerSelector::ALL()));
- ASSERT_EQ(2, subnets.size());
+ ASSERT_EQ(2U, subnets.size());
// Verify that the subnets returned are as expected.
for (auto const& subnet : subnets) {
- ASSERT_EQ(1, subnet->getServerTags().size());
+ ASSERT_EQ(1U, subnet->getServerTags().size());
EXPECT_EQ("all", subnet->getServerTags().begin()->get());
if (subnet->getID() == 1024) {
EXPECT_EQ(test_subnets_[0]->toElement()->str(), subnet->toElement()->str());
SharedNetwork6Collection networks =
cbptr_->getAllSharedNetworks6(ServerSelector::ALL());
- ASSERT_EQ(2, networks.size());
+ ASSERT_EQ(2U, networks.size());
// See if shared networks are returned ok.
for (unsigned i = 0; i < networks.size(); ++i) {
// Fetch all shared networks.
networks = cbptr_->getAllSharedNetworks6(ServerSelector::ALL());
- ASSERT_EQ(2, networks.size());
+ ASSERT_EQ(2U, networks.size());
// See if shared networks are returned ok.
for (unsigned i = 0; i < networks.size(); ++i) {
}
// Only the first class should be returned for the server selector ALL.
auto client_classes = cbptr_->getAllClientClasses6(ServerSelector::ALL());
- ASSERT_EQ(1, client_classes.getClasses()->size());
+ ASSERT_EQ(1U, client_classes.getClasses()->size());
// All three classes should be returned for the server1.
client_classes = cbptr_->getAllClientClasses6(ServerSelector::ONE("server1"));
auto classes_list = client_classes.getClasses();
- ASSERT_EQ(3, classes_list->size());
+ ASSERT_EQ(3U, classes_list->size());
auto fetched_class = classes_list->begin();
ASSERT_EQ("foo", (*fetched_class)->getName());
// Ensure that the classes order has changed.
client_classes = cbptr_->getAllClientClasses6(ServerSelector::ONE("server1"));
classes_list = client_classes.getClasses();
- ASSERT_EQ(3, classes_list->size());
+ ASSERT_EQ(3U, classes_list->size());
EXPECT_EQ("foo", (*classes_list->begin())->getName());
EXPECT_FALSE((*classes_list->begin())->getMatchExpr());
EXPECT_EQ("foobar", (*(classes_list->begin() + 1))->getName());
client_classes = cbptr_->getAllClientClasses6(ServerSelector::ONE("server1"));
classes_list = client_classes.getClasses();
- ASSERT_EQ(3, classes_list->size());
+ ASSERT_EQ(3U, classes_list->size());
EXPECT_EQ("foo", (*classes_list->begin())->getName());
EXPECT_FALSE((*classes_list->begin())->getMatchExpr());
EXPECT_EQ("foobar", (*(classes_list->begin() + 1))->getName());
ASSERT_TRUE(client_class);
EXPECT_EQ("foo", client_class->getName());
EXPECT_TRUE(client_class->getAdditional());
- EXPECT_EQ(30, client_class->getValid().getMin());
- EXPECT_EQ(60, client_class->getValid().get());
- EXPECT_EQ(90, client_class->getValid().getMax());
- EXPECT_EQ(25, client_class->getPreferred().getMin());
- EXPECT_EQ(55, client_class->getPreferred().get());
- EXPECT_EQ(85, client_class->getPreferred().getMax());
+ EXPECT_EQ(30U, client_class->getValid().getMin());
+ EXPECT_EQ(60U, client_class->getValid().get());
+ EXPECT_EQ(90U, client_class->getValid().getMax());
+ EXPECT_EQ(25U, client_class->getPreferred().getMin());
+ EXPECT_EQ(55U, client_class->getPreferred().get());
+ EXPECT_EQ(85U, client_class->getPreferred().getMax());
// Validate options belonging to this class.
ASSERT_TRUE(client_class->getCfgOption());
ASSERT_TRUE(client_class);
// Verify lifetime values.
- EXPECT_EQ(30, client_class->getValid().getMin());
- EXPECT_EQ(60, client_class->getValid().get());
- EXPECT_EQ(90, client_class->getValid().getMax());
- EXPECT_EQ(25, client_class->getPreferred().getMin());
- EXPECT_EQ(55, client_class->getPreferred().get());
- EXPECT_EQ(85, client_class->getPreferred().getMax());
+ EXPECT_EQ(30U, client_class->getValid().getMin());
+ EXPECT_EQ(60U, client_class->getValid().get());
+ EXPECT_EQ(90U, client_class->getValid().getMax());
+ EXPECT_EQ(25U, client_class->getPreferred().getMin());
+ EXPECT_EQ(55U, client_class->getPreferred().get());
+ EXPECT_EQ(85U, client_class->getPreferred().getMax());
// Validate options belonging to the class.
ASSERT_TRUE(client_class->getCfgOption());
auto returned_def_foo = client_class->getCfgOptionDef()->get(test_option_defs_[0]->getOptionSpaceName(),
test_option_defs_[0]->getCode());
ASSERT_TRUE(returned_def_foo);
- EXPECT_EQ(1234, returned_def_foo->getCode());
+ EXPECT_EQ(1234U, returned_def_foo->getCode());
EXPECT_EQ("foo", returned_def_foo->getName());
EXPECT_EQ(DHCP6_OPTION_SPACE, returned_def_foo->getOptionSpaceName());
EXPECT_EQ("espace", returned_def_foo->getEncapsulatedSpace());
auto returned_def_fish = client_class->getCfgOptionDef()->get(test_option_defs_[2]->getOptionSpaceName(),
test_option_defs_[2]->getCode());
ASSERT_TRUE(returned_def_fish);
- EXPECT_EQ(5235, returned_def_fish->getCode());
+ EXPECT_EQ(5235U, returned_def_fish->getCode());
EXPECT_EQ("fish", returned_def_fish->getName());
EXPECT_EQ(DHCP6_OPTION_SPACE, returned_def_fish->getOptionSpaceName());
EXPECT_TRUE(returned_def_fish->getEncapsulatedSpace().empty());
ASSERT_TRUE(client_class);
// Re-check lifetime values. This ensure bindings line up.
- EXPECT_EQ(30, client_class->getValid().getMin());
- EXPECT_EQ(60, client_class->getValid().get());
- EXPECT_EQ(90, client_class->getValid().getMax());
- EXPECT_EQ(25, client_class->getPreferred().getMin());
- EXPECT_EQ(55, client_class->getPreferred().get());
- EXPECT_EQ(85, client_class->getPreferred().getMax());
+ EXPECT_EQ(30U, client_class->getValid().getMin());
+ EXPECT_EQ(60U, client_class->getValid().get());
+ EXPECT_EQ(90U, client_class->getValid().getMax());
+ EXPECT_EQ(25U, client_class->getPreferred().getMin());
+ EXPECT_EQ(55U, client_class->getPreferred().get());
+ EXPECT_EQ(85U, client_class->getPreferred().getMax());
// Ensure that the first option definition is gone.
ASSERT_TRUE(client_class->getCfgOptionDef());
// Get modified client classes configured for all servers.
auto client_classes = cbptr_->getModifiedClientClasses6(ServerSelector::ALL(),
timestamps_["two days ago"]);
- EXPECT_EQ(2, client_classes.getClasses()->size());
+ EXPECT_EQ(2U, client_classes.getClasses()->size());
// Get modified client classes appropriate for server1. It includes classes
// for all servers and for the server1.
client_classes = cbptr_->getModifiedClientClasses6(ServerSelector::ONE("server1"),
timestamps_["two days ago"]);
- EXPECT_EQ(3, client_classes.getClasses()->size());
+ EXPECT_EQ(3U, client_classes.getClasses()->size());
// Get the classes again but use the timestamp equal to the modification
// time of the first class.
client_classes = cbptr_->getModifiedClientClasses6(ServerSelector::ONE("server1"),
timestamps_["yesterday"]);
- EXPECT_EQ(3, client_classes.getClasses()->size());
+ EXPECT_EQ(3U, client_classes.getClasses()->size());
// Get modified classes starting from today. It should return only two.
client_classes = cbptr_->getModifiedClientClasses6(ServerSelector::ONE("server1"),
timestamps_["today"]);
- EXPECT_EQ(2, client_classes.getClasses()->size());
+ EXPECT_EQ(2U, client_classes.getClasses()->size());
// Get client classes modified in the future. It should return none.
client_classes = cbptr_->getModifiedClientClasses6(ServerSelector::ONE("server1"),
timestamps_["after tomorrow"]);
- EXPECT_EQ(0, client_classes.getClasses()->size());
+ EXPECT_EQ(0U, client_classes.getClasses()->size());
// Getting modified client classes for any server is unsupported.
ASSERT_THROW(cbptr_->getModifiedClientClasses6(ServerSelector::ANY(),
uint64_t result;
ASSERT_NO_THROW_LOG(result = cbptr_->deleteClientClass6(ServerSelector::ONE("server1"),
class2->getName()));
- EXPECT_EQ(1, result);
+ EXPECT_EQ(1U, result);
{
SCOPED_TRACE("client class bar is deleted");
testNewAuditEntry("dhcp6_client_class",
ASSERT_NO_THROW_LOG(result = cbptr_->deleteClientClass6(ServerSelector::ONE("server2"),
class3->getName()));
- EXPECT_EQ(1, result);
+ EXPECT_EQ(1U, result);
{
SCOPED_TRACE("client class foobar is deleted");
testNewAuditEntry("dhcp6_client_class",
ASSERT_NO_THROW_LOG(result = cbptr_->deleteClientClass6(ServerSelector::ANY(),
class1->getName()));
- EXPECT_EQ(1, result);
+ EXPECT_EQ(1U, result);
{
SCOPED_TRACE("client class foo is deleted and no longer available for the server1");
testNewAuditEntry("dhcp6_client_class",
uint64_t result;
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses6(ServerSelector::UNASSIGNED()));
- EXPECT_EQ(0, result);
+ EXPECT_EQ(0U, result);
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses6(ServerSelector::ONE("server2")));
- EXPECT_EQ(1, result);
+ EXPECT_EQ(1U, result);
{
SCOPED_TRACE("client classes for server2 deleted");
testNewAuditEntry("dhcp6_client_class",
}
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses6(ServerSelector::ONE("server2")));
- EXPECT_EQ(0, result);
+ EXPECT_EQ(0U, result);
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses6(ServerSelector::ONE("server1")));
- EXPECT_EQ(1, result);
+ EXPECT_EQ(1U, result);
{
SCOPED_TRACE("client classes for server1 deleted");
testNewAuditEntry("dhcp6_client_class",
}
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses6(ServerSelector::ONE("server1")));
- EXPECT_EQ(0, result);
+ EXPECT_EQ(0U, result);
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses6(ServerSelector::ALL()));
- EXPECT_EQ(1, result);
+ EXPECT_EQ(1U, result);
{
SCOPED_TRACE("client classes for all deleted");
testNewAuditEntry("dhcp6_client_class",
}
ASSERT_NO_THROW_LOG(result = cbptr_->deleteAllClientClasses6(ServerSelector::ALL()));
- EXPECT_EQ(0, result);
+ EXPECT_EQ(0U, result);
// Deleting multiple objects using ANY server tag is unsupported.
ASSERT_THROW(cbptr_->deleteAllClientClasses6(ServerSelector::ANY()), InvalidOperation);
// Now make sure that we can delete the options individually.
for (auto const& ref_option : ref_options) {
- ASSERT_EQ(1, cbptr_->deleteOption6(ServerSelector::ANY(),
- network->getName(),
- ref_option->option_->getType(),
- DHCP6_OPTION_SPACE,
- ref_option->copyClientClasses()));
+ ASSERT_EQ(1U, cbptr_->deleteOption6(ServerSelector::ANY(),
+ network->getName(),
+ ref_option->option_->getType(),
+ DHCP6_OPTION_SPACE,
+ ref_option->copyClientClasses()));
}
// Re-fetch the network.
// Now make sure that we can delete the options individually.
for (auto const& ref_option : ref_options) {
- ASSERT_EQ(1, cbptr_->deleteOption6(ServerSelector::ANY(),
- subnet->getID(),
- ref_option->option_->getType(),
- DHCP6_OPTION_SPACE,
- ref_option->copyClientClasses()));
+ ASSERT_EQ(1U, cbptr_->deleteOption6(ServerSelector::ANY(),
+ subnet->getID(),
+ ref_option->option_->getType(),
+ DHCP6_OPTION_SPACE,
+ ref_option->copyClientClasses()));
}
// Re-fetch the subnet.
// Now make sure that we can delete the options individually.
for (auto const& ref_option : ref_options) {
- ASSERT_EQ(1, cbptr_->deleteOption6(ServerSelector::ANY(),
- pool->getFirstAddress(),
- pool->getLastAddress(),
- ref_option->option_->getType(),
- DHCP6_OPTION_SPACE,
- ref_option->copyClientClasses()));
+ ASSERT_EQ(1U, cbptr_->deleteOption6(ServerSelector::ANY(),
+ pool->getFirstAddress(),
+ pool->getLastAddress(),
+ ref_option->option_->getType(),
+ DHCP6_OPTION_SPACE,
+ ref_option->copyClientClasses()));
}
// Re-fetch the subnet.
// Now make sure that we can delete the options individually.
for (auto const& ref_option : ref_options) {
- ASSERT_EQ(1, cbptr_->deleteOption6(ServerSelector::ANY(),
- pool->getFirstAddress(),
- static_cast<uint8_t>(pool_len),
- ref_option->option_->getType(),
- DHCP6_OPTION_SPACE,
- ref_option->copyClientClasses()));
+ ASSERT_EQ(1U, cbptr_->deleteOption6(ServerSelector::ANY(),
+ pool->getFirstAddress(),
+ static_cast<uint8_t>(pool_len),
+ ref_option->option_->getType(),
+ DHCP6_OPTION_SPACE,
+ ref_option->copyClientClasses()));
}
// Re-fetch the subnet.
ASSERT_THROW_MSG(deleted_num = cbptr_->deleteOptionDef6(ServerSelector::ALL(),
700, DHCP6_OPTION_SPACE),
InvalidOperation, "option exists for option definition: dhcp6.700");
- EXPECT_EQ(0, deleted_num);
+ EXPECT_EQ(0U, deleted_num);
ASSERT_THROW_MSG(deleted_num = cbptr_->deleteOptionDef6(ServerSelector::ALL(),
700, DHCP6_OPTION_SPACE, false),
InvalidOperation, "option exists for option definition: dhcp6.700");
- EXPECT_EQ(0, deleted_num);
+ EXPECT_EQ(0U, deleted_num);
ASSERT_NO_THROW_LOG(deleted_num = cbptr_->deleteOptionDef6(ServerSelector::ALL(),
700, DHCP6_OPTION_SPACE, true));
- EXPECT_EQ(1, deleted_num);
+ EXPECT_EQ(1U, deleted_num);
}
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_);
// Verify we can execute a query. We don't care about the answer.
ASSERT_NO_THROW_LOG(servers = getAllServers());
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_);
// A query should fail with NoSuchDatabase.
ASSERT_THROW(servers = getAllServers(), NoSuchDatabase);
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_);
access = validConnectionString();
access += extra;
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_);
// Verify we can execute a query. We don't care about the answer.
ASSERT_NO_THROW_LOG(servers = getAllServers());
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_);
// Verify we can execute a query. We don't care about the answer.
ASSERT_NO_THROW_LOG(servers = getAllServers());
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_);
// A query should fail with NoSuchDatabase.
ASSERT_THROW(servers = getAllServers(), NoSuchDatabase);
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_);
// A query should fail with NoSuchDatabase.
ASSERT_THROW(servers = getAllServers(), NoSuchDatabase);
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_);
// A query should fail with NoSuchDatabase.
ASSERT_THROW(servers = getAllServers(), NoSuchDatabase);
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_);
}
void
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_);
}
void
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_);
}
void
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_);
access = validConnectionString();
access += extra;
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_);
sleep(1);
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_);
}
void
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_);
sleep(1);
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_);
sleep(1);
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_);
}
ConstHostCollection from_hds = hdsptr_->getAll4(subnet4);
// Make sure we got something back.
- ASSERT_EQ(4, from_hds.size());
+ ASSERT_EQ(4U, from_hds.size());
HostDataSourceUtils::compareHosts(host1, from_hds[0]);
HostDataSourceUtils::compareHosts(host2, from_hds[1]);
ConstHostCollection from_hds = hdsptr_->getAll6(subnet6);
// Make sure we got something back.
- ASSERT_EQ(4, from_hds.size());
+ ASSERT_EQ(4U, from_hds.size());
HostDataSourceUtils::compareHosts(host1, from_hds[0]);
HostDataSourceUtils::compareHosts(host2, from_hds[1]);
// Retrieve one reservation.
from_hds = hdsptr_->getAllbyHostname("host.example.com");
- ASSERT_EQ(1, from_hds.size());
+ ASSERT_EQ(1U, from_hds.size());
HostDataSourceUtils::compareHosts(host4, from_hds[0]);
// Retrieve all reservations with host hostname.
from_hds = hdsptr_->getAllbyHostname("host");
- EXPECT_EQ(3, from_hds.size());
+ EXPECT_EQ(3U, from_hds.size());
bool got1 = false;
bool got2 = false;
bool got3 = false;
// Retrieve one reservation.
from_hds = hdsptr_->getAllbyHostname4("host.example.com", subnet4);
- ASSERT_EQ(1, from_hds.size());
+ ASSERT_EQ(1U, from_hds.size());
HostDataSourceUtils::compareHosts(host4, from_hds[0]);
// Check that the subnet is checked.
// Retrieve all reservations with host hostname.
from_hds = hdsptr_->getAllbyHostname4("host", subnet4);
- EXPECT_EQ(3, from_hds.size());
+ EXPECT_EQ(3U, from_hds.size());
bool got1 = false;
bool got2 = false;
bool got3 = false;
// Retrieve one reservation.
from_hds = hdsptr_->getAllbyHostname6("host.example.com", subnet6);
- ASSERT_EQ(1, from_hds.size());
+ ASSERT_EQ(1U, from_hds.size());
HostDataSourceUtils::compareHosts(host4, from_hds[0]);
// Check that the subnet is checked.
// Retrieve all reservations with host hostname.
from_hds = hdsptr_->getAllbyHostname6("host", subnet6);
- EXPECT_EQ(3, from_hds.size());
+ EXPECT_EQ(3U, from_hds.size());
bool got1 = false;
bool got2 = false;
bool got3 = false;
HostPageSize page_size(10);
ConstHostCollection page;
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(10, page.size());
+ ASSERT_EQ(10U, page.size());
host_id = page[9]->getHostId();
- ASSERT_NE(0, host_id);
+ ASSERT_NE(0U, host_id);
// Get second and last pages.
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(10, page.size());
+ ASSERT_EQ(10U, page.size());
host_id = page[9]->getHostId();
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(5, page.size());
+ ASSERT_EQ(5U, page.size());
host_id = page[4]->getHostId();
// Verify we have everything.
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(0, page.size());
+ ASSERT_EQ(0U, page.size());
host_id = 0;
// Other subnets are empty.
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet6, idx, host_id, page_size));
- ASSERT_EQ(0, page.size());
+ ASSERT_EQ(0U, page.size());
}
void
HostPageSize page_size(10);
ConstHostCollection page;
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(10, page.size());
+ ASSERT_EQ(10U, page.size());
host_id = page[9]->getHostId();
- ASSERT_NE(0, host_id);
+ ASSERT_NE(0U, host_id);
// Get second and last pages.
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(10, page.size());
+ ASSERT_EQ(10U, page.size());
host_id = page[9]->getHostId();
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(5, page.size());
+ ASSERT_EQ(5U, page.size());
host_id = page[4]->getHostId();
// Verify we have everything.
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(0, page.size());
+ ASSERT_EQ(0U, page.size());
host_id = 0;
// Other subnets are empty.
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet4, idx, host_id, page_size));
- ASSERT_EQ(0, page.size());
+ ASSERT_EQ(0U, page.size());
}
void
HostPageSize page_size(4);
ConstHostCollection page;
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(4, page.size());
+ ASSERT_EQ(4U, page.size());
host_id = page[3]->getHostId();
- ASSERT_NE(0, host_id);
+ ASSERT_NE(0U, host_id);
// Get second and last pages.
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(1, page.size());
+ ASSERT_EQ(1U, page.size());
host_id = page[0]->getHostId();
// Verify we have everything.
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(0, page.size());
+ ASSERT_EQ(0U, page.size());
}
void
ConstHostCollection page;
ConstHostCollection all_pages;
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(4, page.size());
+ ASSERT_EQ(4U, page.size());
host_id = page[3]->getHostId();
- ASSERT_NE(0, host_id);
+ ASSERT_NE(0U, host_id);
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Get second and last pages.
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(1, page.size());
+ ASSERT_EQ(1U, page.size());
host_id = page[0]->getHostId();
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Verify we have everything.
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(0, page.size());
+ ASSERT_EQ(0U, page.size());
// hosts are sorted by generated host_id (which is an auto increment for
// MySql and PostgreSql) so the hosts must be sorted by host identifier
ConstHostCollection page;
ConstHostCollection all_pages;
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(3, page.size());
+ ASSERT_EQ(3U, page.size());
host_id = page[2]->getHostId();
- ASSERT_NE(0, host_id);
+ ASSERT_NE(0U, host_id);
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Get second and last pages.
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(2, page.size());
+ ASSERT_EQ(2U, page.size());
host_id = page[1]->getHostId();
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Verify we have everything.
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(0, page.size());
+ ASSERT_EQ(0U, page.size());
// hosts are sorted by generated host_id (which is an auto increment for
// MySql and PostgreSql) so the hosts must be sorted by host identifier
idx = 0;
host_id = 0;
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(3, page.size());
+ ASSERT_EQ(3U, page.size());
host_id = page[2]->getHostId();
- ASSERT_NE(0, host_id);
+ ASSERT_NE(0U, host_id);
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Get second and last pages.
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(2, page.size());
+ ASSERT_EQ(2U, page.size());
host_id = page[1]->getHostId();
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Verify we have everything.
ASSERT_NO_THROW(page = hdsptr_->getPage4(subnet4, idx, host_id, page_size));
- ASSERT_EQ(0, page.size());
+ ASSERT_EQ(0U, page.size());
// hosts are sorted by generated host_id (which is an auto increment for
// MySql and PostgreSql) so the hosts must be sorted by host identifier
ConstHostCollection page;
ConstHostCollection all_pages;
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(3, page.size());
+ ASSERT_EQ(3U, page.size());
host_id = page[2]->getHostId();
- ASSERT_NE(0, host_id);
+ ASSERT_NE(0U, host_id);
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Get second and last pages.
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(2, page.size());
+ ASSERT_EQ(2U, page.size());
host_id = page[1]->getHostId();
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Verify we have everything.
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(0, page.size());
+ ASSERT_EQ(0U, page.size());
// hosts are sorted by generated host_id (which is an auto increment for
// MySql and PostgreSql) so the hosts must be sorted by host identifier
idx = 0;
host_id = 0;
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(3, page.size());
+ ASSERT_EQ(3U, page.size());
host_id = page[2]->getHostId();
- ASSERT_NE(0, host_id);
+ ASSERT_NE(0U, host_id);
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Get second and last pages.
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(2, page.size());
+ ASSERT_EQ(2U, page.size());
host_id = page[1]->getHostId();
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Verify we have everything.
ASSERT_NO_THROW(page = hdsptr_->getPage6(subnet6, idx, host_id, page_size));
- ASSERT_EQ(0, page.size());
+ ASSERT_EQ(0U, page.size());
// hosts are sorted by generated host_id (which is an auto increment for
// MySql and PostgreSql) so the hosts must be sorted by host identifier
ConstHostCollection page;
ConstHostCollection all_pages;
ASSERT_NO_THROW(page = hdsptr_->getPage4(idx, host_id, page_size));
- ASSERT_EQ(3, page.size());
+ ASSERT_EQ(3U, page.size());
host_id = page[2]->getHostId();
- ASSERT_NE(0, host_id);
+ ASSERT_NE(0U, host_id);
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Get second page.
ASSERT_NO_THROW(page = hdsptr_->getPage4(idx, host_id, page_size));
- ASSERT_EQ(3, page.size());
+ ASSERT_EQ(3U, page.size());
host_id = page[2]->getHostId();
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Get last page.
ASSERT_NO_THROW(page = hdsptr_->getPage4(idx, host_id, page_size));
- ASSERT_EQ(2, page.size());
+ ASSERT_EQ(2U, page.size());
host_id = page[1]->getHostId();
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Verify we have everything.
ASSERT_NO_THROW(page = hdsptr_->getPage4(idx, host_id, page_size));
- ASSERT_EQ(0, page.size());
+ ASSERT_EQ(0U, page.size());
// hosts are sorted by generated host_id (which is an auto increment for
// MySql and PostgreSql) so the hosts must be sorted by host identifier
ConstHostCollection page;
ConstHostCollection all_pages;
ASSERT_NO_THROW(page = hdsptr_->getPage6(idx, host_id, page_size));
- ASSERT_EQ(3, page.size());
+ ASSERT_EQ(3U, page.size());
host_id = page[2]->getHostId();
- ASSERT_NE(0, host_id);
+ ASSERT_NE(0U, host_id);
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Get second page.
ASSERT_NO_THROW(page = hdsptr_->getPage6(idx, host_id, page_size));
- ASSERT_EQ(3, page.size());
+ ASSERT_EQ(3U, page.size());
host_id = page[2]->getHostId();
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Get last page.
ASSERT_NO_THROW(page = hdsptr_->getPage6(idx, host_id, page_size));
- ASSERT_EQ(2, page.size());
+ ASSERT_EQ(2U, page.size());
host_id = page[1]->getHostId();
std::copy(page.begin(), page.end(), std::back_inserter(all_pages));
// Verify we have everything.
ASSERT_NO_THROW(page = hdsptr_->getPage6(idx, host_id, page_size));
- ASSERT_EQ(0, page.size());
+ ASSERT_EQ(0U, page.size());
// hosts are sorted by generated host_id (which is an auto increment for
// MySql and PostgreSql) so the hosts must be sorted by host identifier
}
void
-GenericHostDataSourceTest::testMultipleSubnets(int subnets,
+GenericHostDataSourceTest::testMultipleSubnets(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 + 1000);
ASSERT_NO_THROW(hdsptr_->add(host));
}
// 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 + 1000, host->getIPv4Reservation());
ASSERT_EQ(subnets, all_by_addr.size());
// Verify that the values returned are proper.
- int i = 0;
+ unsigned i = 0;
for (auto const& it : all_by_addr) {
EXPECT_EQ(IOAddress("192.0.2.1"), it->getIPv4Reservation());
EXPECT_EQ(1000 + i++, it->getIPv4SubnetID());
}
void
-GenericHostDataSourceTest::testSubnetId6(int subnets, Host::IdentifierType id) {
+GenericHostDataSourceTest::testSubnetId6(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 + 1000, id, &host->getIdentifier()[0],
host->getIdentifier().size());
ASSERT_TRUE(from_hds) << "failed for i=" << i;
- EXPECT_EQ(i + 1000, from_hds->getIPv6SubnetID());
+ EXPECT_EQ(i + 1000U, from_hds->getIPv6SubnetID());
}
// Check that the hosts can all be retrieved by HW address or DUID
ASSERT_EQ(subnets, all_by_id.size());
// Check that the returned values are as expected.
- int i = 0;
+ unsigned i = 0;
for (auto const& it : all_by_id) {
EXPECT_EQ(IOAddress("0.0.0.0"), it->getIPv4Reservation());
- EXPECT_EQ(1000 + i++, it->getIPv6SubnetID());
+ EXPECT_EQ(1000U + i++, it->getIPv6SubnetID());
}
}
ConstHostCollection returned;
ASSERT_NO_THROW(returned = hdsptr_->getAll6(host->getIPv6SubnetID(), IOAddress("2001:db8:1::")));
- EXPECT_EQ(2, returned.size());
+ EXPECT_EQ(2U, returned.size());
EXPECT_NE(returned[0]->getIdentifierAsText(), returned[1]->getIdentifierAsText());
// Let's now try to delete the hosts by subnet_id and address.
ConstHostCollection returned;
ASSERT_NO_THROW(returned = hdsptr_->getAll4(host->getIPv4SubnetID(), IOAddress("192.0.2.1")));
- EXPECT_EQ(2, returned.size());
+ EXPECT_EQ(2U, returned.size());
EXPECT_NE(returned[0]->getIdentifierAsText(), returned[1]->getIdentifierAsText());
// Let's now try to delete the hosts by subnet_id and address.
// getAll4(subnet_id)
ConstHostCollection hosts_by_subnet = hdsptr_->getAll4(subnet_id);
- ASSERT_EQ(1, hosts_by_subnet.size());
+ ASSERT_EQ(1U, hosts_by_subnet.size());
ASSERT_NO_FATAL_FAILURE(HostDataSourceUtils::compareHosts(host, *hosts_by_subnet.begin()));
auto returned_host = *hosts_by_subnet.begin();
// getAll4(address)
ConstHostCollection hosts_by_addr =
hdsptr_->getAll4(host->getIPv4Reservation());
- ASSERT_EQ(1, hosts_by_addr.size());
+ ASSERT_EQ(1U, hosts_by_addr.size());
ASSERT_NO_FATAL_FAILURE(HostDataSourceUtils::compareHosts(host, *hosts_by_addr.begin()));
// get4(subnet_id, identifier_type, identifier, identifier_size)
// getAll6(subnet_id)
ConstHostCollection hosts_by_subnet = hdsptr_->getAll6(subnet_id);
- EXPECT_EQ(1, hosts_by_subnet.size());
+ EXPECT_EQ(1U, hosts_by_subnet.size());
// Don't compare as getAll6() returns the v6 part only.
// getAll(identifier_type, identifier, identifier_size)
ConstHostCollection hosts_by_id =
hdsptr_->getAll(host->getIdentifierType(), &host->getIdentifier()[0],
host->getIdentifier().size());
- ASSERT_EQ(1, hosts_by_id.size());
+ ASSERT_EQ(1U, hosts_by_id.size());
ASSERT_NO_FATAL_FAILURE(HostDataSourceUtils::compareHosts(host, *hosts_by_id.begin()));
}
ConstHostCollection hosts_by_id =
hdsptr_->getAll(host->getIdentifierType(), &host->getIdentifier()[0],
host->getIdentifier().size());
- ASSERT_EQ(1, hosts_by_id.size());
+ ASSERT_EQ(1U, hosts_by_id.size());
ASSERT_NO_FATAL_FAILURE(HostDataSourceUtils::compareHosts(host, *hosts_by_id.begin()));
// Fetch the host via
// getAll4(const asiolink::IOAddress& address) const;
hosts_by_id = hdsptr_->getAll4(IOAddress("192.0.2.5"));
- ASSERT_EQ(1, hosts_by_id.size());
+ ASSERT_EQ(1U, hosts_by_id.size());
ASSERT_NO_FATAL_FAILURE(HostDataSourceUtils::compareHosts(host, *hosts_by_id.begin()));
// Fetch the host via
ConstHostCollection hosts_by_id =
hdsptr_->getAll(host->getIdentifierType(), &host->getIdentifier()[0],
host->getIdentifier().size());
- ASSERT_EQ(1, hosts_by_id.size());
+ ASSERT_EQ(1U, hosts_by_id.size());
ASSERT_NO_FATAL_FAILURE(HostDataSourceUtils::compareHosts(host, *hosts_by_id.begin()));
// Fetch the host via:
ConstHostCollection hosts_by_id =
hdsptr_->getAll(host->getIdentifierType(), &host->getIdentifier()[0],
host->getIdentifier().size());
- ASSERT_EQ(1, hosts_by_id.size());
+ ASSERT_EQ(1U, hosts_by_id.size());
ASSERT_NO_FATAL_FAILURE(HostDataSourceUtils::compareHosts(host, *hosts_by_id.begin()));
// Fetch the host via
// getAll4(const asiolink::IOAddress& address) const;
hosts_by_id = hdsptr_->getAll4(IOAddress("192.0.2.5"));
- ASSERT_EQ(1, hosts_by_id.size());
+ ASSERT_EQ(1U, hosts_by_id.size());
ASSERT_NO_FATAL_FAILURE(HostDataSourceUtils::compareHosts(host, *hosts_by_id.begin()));
// Fetch the host via
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(HostMgr::instance().getHostDataSource());
}
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(HostMgr::instance().getHostDataSource());
}
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_);
access = validConnectString();
access += extra;
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(HostMgr::instance().getHostDataSource());
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(HostMgr::instance().getHostDataSource());
}
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(HostMgr::instance().getHostDataSource());
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(HostMgr::instance().getHostDataSource());
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(HostMgr::instance().getHostDataSource());
}
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_);
}
void
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_);
}
void
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_);
}
void
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_);
access = validConnectString();
access += extra;
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_);
sleep(1);
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_);
}
void
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_);
sleep(1);
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_);
sleep(1);
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_);
}
void
hosts = HostMgr::instance().getAll(Host::IDENT_HWADDR,
&hwaddrs_[0]->hwaddr_[0],
hwaddrs_[0]->hwaddr_.size());
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
// We don't know the order in which the reservations are returned so
// we have to match with any of the two reservations returned.
bool found = false;
for (unsigned i = 0; i < 2; ++i) {
if (hosts[i]->getIPv4Reservation() == IOAddress("192.0.2.5")) {
- ASSERT_EQ(1, hosts[i]->getIPv4SubnetID());
+ ASSERT_EQ(1U, hosts[i]->getIPv4SubnetID());
found = true;
}
}
found = false;
for (unsigned i = 0; i < 2; ++i) {
if (hosts[i]->getIPv4Reservation() == IOAddress("192.0.3.10")) {
- ASSERT_EQ(10, hosts[i]->getIPv4SubnetID());
+ ASSERT_EQ(10U, hosts[i]->getIPv4SubnetID());
found = true;
}
}
found = false;
for (unsigned i = 0; i < hosts.size(); ++i) {
if (hosts[i]->getIPv4Reservation() == IOAddress("192.0.2.5")) {
- ASSERT_EQ(1, hosts[i]->getIPv4SubnetID());
+ ASSERT_EQ(1U, hosts[i]->getIPv4SubnetID());
found = true;
}
}
found = false;
for (unsigned i = 0; i < hosts.size(); ++i) {
if (hosts[i]->getIPv4Reservation() == IOAddress("192.0.3.10")) {
- ASSERT_EQ(10, hosts[i]->getIPv4SubnetID());
+ ASSERT_EQ(10U, hosts[i]->getIPv4SubnetID());
found = true;
}
}
found = false;
for (unsigned i = 0; i < hosts.size(); ++i) {
if (hosts[i]->getIPv4Reservation() == IOAddress("192.0.2.5")) {
- ASSERT_EQ(1, hosts[i]->getIPv4SubnetID());
+ ASSERT_EQ(1U, hosts[i]->getIPv4SubnetID());
found = true;
}
}
found = false;
for (unsigned i = 0; i < hosts.size(); ++i) {
if (hosts[i]->getIPv4Reservation() == IOAddress("192.0.3.10")) {
- ASSERT_EQ(10, hosts[i]->getIPv4SubnetID());
+ ASSERT_EQ(10U, hosts[i]->getIPv4SubnetID());
found = true;
}
}
&hwaddrs_[0]->hwaddr_[0],
hwaddrs_[0]->hwaddr_.size(),
HostMgrOperationTarget::UNSPECIFIED_SOURCE);
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
}
void
// For the correct subnet, there should be two reservations.
hosts = HostMgr::instance().getAll4(SubnetID(1));
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
// Make sure that subnet is correct.
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
- EXPECT_EQ(1, hosts[1]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[1]->getIPv4SubnetID());
// Make sure that two different hosts were returned.
EXPECT_EQ("192.0.2.5", hosts[0]->getIPv4Reservation().toText());
// Select hosts for an unspecified source.
hosts = HostMgr::instance().getAll4(SubnetID(1), HostMgrOperationTarget::UNSPECIFIED_SOURCE);
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
}
void
// For the correct subnet, there should be two reservations.
hosts = HostMgr::instance().getAll6(SubnetID(1));
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
// Make sure that subnet is correct.
- EXPECT_EQ(1, hosts[0]->getIPv6SubnetID());
- EXPECT_EQ(1, hosts[1]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[1]->getIPv6SubnetID());
// Make sure that two different hosts were returned.
EXPECT_TRUE(hosts[0]->hasReservation(
// Select hosts for an unspecified source.
hosts = HostMgr::instance().getAll6(SubnetID(1), HostMgrOperationTarget::UNSPECIFIED_SOURCE);
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
}
void
// For the correct hostname, there should be two reservations.
hosts = HostMgr::instance().getAllbyHostname("host");
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
// Make sure that subnet is correct.
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
- EXPECT_EQ(10, hosts[1]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(10U, hosts[1]->getIPv4SubnetID());
// Make sure that hostname is correct including its case.
EXPECT_EQ("Host", hosts[0]->getHostname());
hosts = HostMgr::instance().getAllbyHostname("host", HostMgrOperationTarget::PRIMARY_SOURCE);
EXPECT_EQ(hosts_in_primary_source, hosts.size());
if (is_first_source_primary) {
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
}
if (is_second_source_primary) {
- EXPECT_EQ(10, hosts[hosts_in_primary_source-1]->getIPv4SubnetID());
+ EXPECT_EQ(10U, hosts[hosts_in_primary_source-1]->getIPv4SubnetID());
}
// Select hosts only from the alternate sources.
hosts = HostMgr::instance().getAllbyHostname("host", HostMgrOperationTarget::ALTERNATE_SOURCES);
EXPECT_EQ(2 - hosts_in_primary_source, hosts.size());
if (!is_first_source_primary) {
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
}
if (!is_second_source_primary) {
- EXPECT_EQ(10, hosts[2 - hosts_in_primary_source - 1]->getIPv4SubnetID());
+ EXPECT_EQ(10U, hosts[2 - hosts_in_primary_source - 1]->getIPv4SubnetID());
}
// Select hosts for an unspecified source.
hosts = HostMgr::instance().getAllbyHostname("host", HostMgrOperationTarget::UNSPECIFIED_SOURCE);
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
}
void
// For the correct hostname, there should be two reservations.
hosts = HostMgr::instance().getAllbyHostname4("host", SubnetID(1));
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
// Make sure that subnet is correct.
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
- EXPECT_EQ(1, hosts[1]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[1]->getIPv4SubnetID());
// Make sure that two different hosts were returned.
EXPECT_EQ("192.0.2.5", hosts[0]->getIPv4Reservation().toText());
// Select hosts for an unspecified source.
hosts = HostMgr::instance().getAllbyHostname4("host", SubnetID(1), HostMgrOperationTarget::UNSPECIFIED_SOURCE);
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
}
void
// For the correct hostname, there should be two reservations.
hosts = HostMgr::instance().getAllbyHostname6("host", SubnetID(1));
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
// Make sure that subnet is correct.
- EXPECT_EQ(1, hosts[0]->getIPv6SubnetID());
- EXPECT_EQ(1, hosts[1]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[1]->getIPv6SubnetID());
// Make sure that two different hosts were returned.
EXPECT_TRUE(hosts[0]->hasReservation(
// Select hosts for an unspecified source.
hosts = HostMgr::instance().getAllbyHostname6("host", SubnetID(1), HostMgrOperationTarget::UNSPECIFIED_SOURCE);
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
}
void
HostMgr::instance().getPage4(SubnetID(1), idx, 0, page_size);
ASSERT_TRUE(hosts.empty());
if (use_database) {
- EXPECT_EQ(2, idx);
+ EXPECT_EQ(2U, idx);
} else {
- EXPECT_EQ(1, idx);
+ EXPECT_EQ(1U, idx);
}
// Add two reservations for the same subnet.
idx = 0;
hosts = HostMgr::instance().getPage4(SubnetID(1), idx, 0, page_size);
if (use_database) {
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
} else {
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
}
// Make sure that returned values are correct.
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ("192.0.2.5", hosts[0]->getIPv4Reservation().toText());
if (!use_database) {
- EXPECT_EQ(1, hosts[1]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[1]->getIPv4SubnetID());
EXPECT_EQ("192.0.2.6", hosts[1]->getIPv4Reservation().toText());
// Check it was the last page.
uint64_t hid = hosts[1]->getHostId();
hosts = HostMgr::instance().getPage4(SubnetID(1), idx, hid, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
idx = 1;
hosts = HostMgr::instance().getPage4(SubnetID(1), idx, 0, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
}
if (use_database) {
uint64_t hid = hosts[0]->getHostId();
- ASSERT_NE(0, hid);
- ASSERT_EQ(0, idx);
+ ASSERT_NE(0U, hid);
+ ASSERT_EQ(0U, idx);
hosts = HostMgr::instance().getPage4(SubnetID(1), idx, hid, page_size);
- ASSERT_EQ(1, hosts.size());
- ASSERT_NE(0, idx);
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
+ ASSERT_EQ(1U, hosts.size());
+ ASSERT_NE(0U, idx);
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ("192.0.2.6", hosts[0]->getIPv4Reservation().toText());
// Alternate way to use the database.
idx = 1;
hosts = HostMgr::instance().getPage4(SubnetID(1), idx, 0, page_size);
- ASSERT_EQ(1, hosts.size());
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
+ ASSERT_EQ(1U, hosts.size());
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ("192.0.2.6", hosts[0]->getIPv4Reservation().toText());
// Check it was the last page.
hid = hosts[0]->getHostId();
- ASSERT_NE(0, hid);
+ ASSERT_NE(0U, hid);
hosts = HostMgr::instance().getPage4(SubnetID(1), idx, hid, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
idx = 2;
hosts = HostMgr::instance().getPage4(SubnetID(1), idx, 0, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
}
}
HostMgr::instance().getPage6(SubnetID(1), idx, 0, page_size);
ASSERT_TRUE(hosts.empty());
if (use_database) {
- EXPECT_EQ(2, idx);
+ EXPECT_EQ(2U, idx);
} else {
- EXPECT_EQ(1, idx);
+ EXPECT_EQ(1U, idx);
}
// Add two reservations for the same subnet.
idx = 0;
hosts = HostMgr::instance().getPage6(SubnetID(1), idx, 0, page_size);
if (use_database) {
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
} else {
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
}
// Make sure that returned values are correct.
- EXPECT_EQ(1, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv6SubnetID());
EXPECT_TRUE(hosts[0]->hasReservation(
IPv6Resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::5"))));
if (!use_database) {
- EXPECT_EQ(1, hosts[1]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[1]->getIPv6SubnetID());
EXPECT_TRUE(hosts[1]->hasReservation(
IPv6Resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::6"))));
// Check it was the last page.
uint64_t hid = hosts[1]->getHostId();
hosts = HostMgr::instance().getPage6(SubnetID(1), idx, hid, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
idx = 1;
hosts = HostMgr::instance().getPage6(SubnetID(1), idx, 0, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
}
if (use_database) {
uint64_t hid = hosts[0]->getHostId();
- ASSERT_NE(0, hid);
- ASSERT_EQ(0, idx);
+ ASSERT_NE(0U, hid);
+ ASSERT_EQ(0U, idx);
hosts = HostMgr::instance().getPage6(SubnetID(1), idx, hid, page_size);
- ASSERT_EQ(1, hosts.size());
- ASSERT_NE(0, idx);
- EXPECT_EQ(1, hosts[0]->getIPv6SubnetID());
+ ASSERT_EQ(1U, hosts.size());
+ ASSERT_NE(0U, idx);
+ EXPECT_EQ(1U, hosts[0]->getIPv6SubnetID());
EXPECT_TRUE(hosts[0]->hasReservation(
IPv6Resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::6"))));
// Alternate way to use the database.
idx = 1;
hosts = HostMgr::instance().getPage6(SubnetID(1), idx, 0, page_size);
- ASSERT_EQ(1, hosts.size());
- EXPECT_EQ(1, hosts[0]->getIPv6SubnetID());
+ ASSERT_EQ(1U, hosts.size());
+ EXPECT_EQ(1U, hosts[0]->getIPv6SubnetID());
EXPECT_TRUE(hosts[0]->hasReservation(
IPv6Resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::6"))));
// Check it was the last page.
hid = hosts[0]->getHostId();
- ASSERT_NE(0, hid);
+ ASSERT_NE(0U, hid);
hosts = HostMgr::instance().getPage6(SubnetID(1), idx, hid, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
idx = 2;
hosts = HostMgr::instance().getPage6(SubnetID(1), idx, 0, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
}
}
HostMgr::instance().getPage4(idx, 0, page_size);
ASSERT_TRUE(hosts.empty());
if (use_database) {
- EXPECT_EQ(2, idx);
+ EXPECT_EQ(2U, idx);
} else {
- EXPECT_EQ(1, idx);
+ EXPECT_EQ(1U, idx);
}
// Add two reservations.
idx = 0;
hosts = HostMgr::instance().getPage4(idx, 0, page_size);
if (use_database) {
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
} else {
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
}
// Make sure that returned values are correct.
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ("192.0.2.5", hosts[0]->getIPv4Reservation().toText());
if (!use_database) {
- EXPECT_EQ(2, hosts[1]->getIPv4SubnetID());
+ EXPECT_EQ(2U, hosts[1]->getIPv4SubnetID());
EXPECT_EQ("192.0.2.6", hosts[1]->getIPv4Reservation().toText());
// Check it was the last page.
uint64_t hid = hosts[1]->getHostId();
hosts = HostMgr::instance().getPage4(idx, hid, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
idx = 1;
hosts = HostMgr::instance().getPage4(idx, 0, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
}
if (use_database) {
uint64_t hid = hosts[0]->getHostId();
- ASSERT_NE(0, hid);
- ASSERT_EQ(0, idx);
+ ASSERT_NE(0U, hid);
+ ASSERT_EQ(0U, idx);
hosts = HostMgr::instance().getPage4(idx, hid, page_size);
- ASSERT_EQ(1, hosts.size());
- ASSERT_NE(0, idx);
- EXPECT_EQ(2, hosts[0]->getIPv4SubnetID());
+ ASSERT_EQ(1U, hosts.size());
+ ASSERT_NE(0U, idx);
+ EXPECT_EQ(2U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ("192.0.2.6", hosts[0]->getIPv4Reservation().toText());
// Alternate way to use the database.
idx = 1;
hosts = HostMgr::instance().getPage4(idx, 0, page_size);
- ASSERT_EQ(1, hosts.size());
- EXPECT_EQ(2, hosts[0]->getIPv4SubnetID());
+ ASSERT_EQ(1U, hosts.size());
+ EXPECT_EQ(2U, hosts[0]->getIPv4SubnetID());
EXPECT_EQ("192.0.2.6", hosts[0]->getIPv4Reservation().toText());
// Check it was the last page.
hid = hosts[0]->getHostId();
- ASSERT_NE(0, hid);
+ ASSERT_NE(0U, hid);
hosts = HostMgr::instance().getPage4(idx, hid, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
idx = 2;
hosts = HostMgr::instance().getPage4(idx, 0, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
}
}
HostMgr::instance().getPage6(idx, 0, page_size);
ASSERT_TRUE(hosts.empty());
if (use_database) {
- EXPECT_EQ(2, idx);
+ EXPECT_EQ(2U, idx);
} else {
- EXPECT_EQ(1, idx);
+ EXPECT_EQ(1U, idx);
}
// Add two reservations.
idx = 0;
hosts = HostMgr::instance().getPage6(idx, 0, page_size);
if (use_database) {
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
} else {
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
}
// Make sure that returned values are correct.
- EXPECT_EQ(1, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv6SubnetID());
EXPECT_TRUE(hosts[0]->hasReservation(
IPv6Resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::5"))));
if (!use_database) {
- EXPECT_EQ(2, hosts[1]->getIPv6SubnetID());
+ EXPECT_EQ(2U, hosts[1]->getIPv6SubnetID());
EXPECT_TRUE(hosts[1]->hasReservation(
IPv6Resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::6"))));
// Check it was the last page.
uint64_t hid = hosts[1]->getHostId();
hosts = HostMgr::instance().getPage6(idx, hid, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
idx = 1;
hosts = HostMgr::instance().getPage6(idx, 0, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
}
if (use_database) {
uint64_t hid = hosts[0]->getHostId();
- ASSERT_NE(0, hid);
- ASSERT_EQ(0, idx);
+ ASSERT_NE(0U, hid);
+ ASSERT_EQ(0U, idx);
hosts = HostMgr::instance().getPage6(idx, hid, page_size);
- ASSERT_EQ(1, hosts.size());
- ASSERT_NE(0, idx);
- EXPECT_EQ(2, hosts[0]->getIPv6SubnetID());
+ ASSERT_EQ(1U, hosts.size());
+ ASSERT_NE(0U, idx);
+ EXPECT_EQ(2U, hosts[0]->getIPv6SubnetID());
EXPECT_TRUE(hosts[0]->hasReservation(
IPv6Resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::6"))));
// Alternate way to use the database.
idx = 1;
hosts = HostMgr::instance().getPage6(idx, 0, page_size);
- ASSERT_EQ(1, hosts.size());
- EXPECT_EQ(2, hosts[0]->getIPv6SubnetID());
+ ASSERT_EQ(1U, hosts.size());
+ EXPECT_EQ(2U, hosts[0]->getIPv6SubnetID());
EXPECT_TRUE(hosts[0]->hasReservation(
IPv6Resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::6"))));
// Check it was the last page.
hid = hosts[0]->getHostId();
- ASSERT_NE(0, hid);
+ ASSERT_NE(0U, hid);
hosts = HostMgr::instance().getPage6(idx, hid, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
idx = 2;
hosts = HostMgr::instance().getPage6(idx, 0, page_size);
- ASSERT_EQ(0, hosts.size());
+ ASSERT_EQ(0U, hosts.size());
}
}
// Retrieve all hosts, This should return hosts from both sources
// in a single container.
hosts = HostMgr::instance().getAll4(IOAddress("192.0.2.5"));
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
// Make sure that IPv4 address is correct.
EXPECT_EQ("192.0.2.5", hosts[0]->getIPv4Reservation().toText());
// Select hosts for an unspecified source.
hosts = HostMgr::instance().getAll4(SubnetID(1), HostMgrOperationTarget::UNSPECIFIED_SOURCE);
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
}
void
&hwaddrs_[0]->hwaddr_[0],
hwaddrs_[0]->hwaddr_.size());
ASSERT_TRUE(host);
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
// Make sure that the operation target is supported.
hwaddrs_[0]->hwaddr_.size(),
operation_target);
ASSERT_TRUE(host);
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
// Select host by explicit but unmatched operation target.
&duids_[0]->getDuid()[0],
duids_[0]->getDuid().size());
ASSERT_TRUE(host);
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
// Set the negative cache flag on the host.
&duids_[0]->getDuid()[0],
duids_[0]->getDuid().size());
ASSERT_TRUE(host);
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
EXPECT_TRUE(host->getNegative());
duids_[0]->getDuid().size(),
HostMgrOperationTarget::PRIMARY_SOURCE);
ASSERT_TRUE(host);
- EXPECT_EQ(1, host->getIPv4SubnetID());
+ EXPECT_EQ(1U, host->getIPv4SubnetID());
EXPECT_EQ("192.0.2.5", host->getIPv4Reservation().toText());
EXPECT_TRUE(host->getNegative());
&duids_[0]->getDuid()[0],
duids_[0]->getDuid().size());
ASSERT_TRUE(host);
- EXPECT_EQ(2, host->getIPv6SubnetID());
+ EXPECT_EQ(2U, host->getIPv6SubnetID());
EXPECT_TRUE(host->hasReservation(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:1::1"))));
duids_[0]->getDuid().size(),
operation_target);
ASSERT_TRUE(host);
- EXPECT_EQ(2, host->getIPv6SubnetID());
+ EXPECT_EQ(2U, host->getIPv6SubnetID());
EXPECT_TRUE(host->hasReservation(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:1::1"))));
&hwaddrs_[0]->hwaddr_[0],
hwaddrs_[0]->hwaddr_.size());
ASSERT_TRUE(host);
- EXPECT_EQ(2, host->getIPv6SubnetID());
+ EXPECT_EQ(2U, host->getIPv6SubnetID());
EXPECT_TRUE(host->hasReservation(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:1::1"))));
&hwaddrs_[0]->hwaddr_[0],
hwaddrs_[0]->hwaddr_.size());
ASSERT_TRUE(host);
- EXPECT_EQ(2, host->getIPv6SubnetID());
+ EXPECT_EQ(2U, host->getIPv6SubnetID());
EXPECT_TRUE(host->hasReservation(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:1::1"))));
EXPECT_TRUE(host->getNegative());
hwaddrs_[0]->hwaddr_.size(),
HostMgrOperationTarget::PRIMARY_SOURCE);
ASSERT_TRUE(host);
- EXPECT_EQ(2, host->getIPv6SubnetID());
+ EXPECT_EQ(2U, host->getIPv6SubnetID());
EXPECT_TRUE(host->hasReservation(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:1::1"))));
// For the correct subnet, there should be two reservations.
hosts = HostMgr::instance().getAll4(SubnetID(1), IOAddress("192.0.2.5"));
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
// Make sure that subnet is correct.
- EXPECT_EQ(1, hosts[0]->getIPv4SubnetID());
- EXPECT_EQ(1, hosts[1]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv4SubnetID());
+ EXPECT_EQ(1U, hosts[1]->getIPv4SubnetID());
// Make sure that two hosts were returned with different identifiers
// but the same address.
// Select hosts for an unspecified source.
hosts = HostMgr::instance().getAll4(SubnetID(1), HostMgrOperationTarget::UNSPECIFIED_SOURCE);
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
}
void
// For the correct subnet, there should be two reservations.
hosts = HostMgr::instance().getAll6(SubnetID(1), IOAddress("2001:db8:1::5"));
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
// Make sure that subnet is correct.
- EXPECT_EQ(1, hosts[0]->getIPv6SubnetID());
- EXPECT_EQ(1, hosts[1]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[1]->getIPv6SubnetID());
// Make sure that two hosts were returned with different identifiers
// but the same address.
// Select hosts for an unspecified source.
hosts = HostMgr::instance().getAll4(SubnetID(1), IOAddress("2001:db8:1::5"), HostMgrOperationTarget::UNSPECIFIED_SOURCE);
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
}
void
// For given IP there should be one reservation.
hosts = HostMgr::instance().getAll6(IOAddress("2001:db8:1::5"));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
// For given IP there should be one reservation.
hosts = HostMgr::instance().getAll6(IOAddress("2001:db8:1::6"));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
// For given IP there should be two reservations.
hosts = HostMgr::instance().getAll6(IOAddress("2001:db8:1::10"));
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
// Make sure that subnet is correct.
- EXPECT_EQ(1, hosts[0]->getIPv6SubnetID());
- EXPECT_EQ(1, hosts[1]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[1]->getIPv6SubnetID());
// Make sure that all hosts were returned with different identifiers, and
// they have expected reservations.
// Select hosts for an unspecified source.
hosts = HostMgr::instance().getAll4(IOAddress("2001:db8:1::10"),
HostMgrOperationTarget::UNSPECIFIED_SOURCE);
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
}
void
// For given IP prefix there should be one reservation.
hosts = HostMgr::instance().getAll6(IOAddress("2001:db8:1:11::"));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
// For given IP prefix there should be one reservation.
hosts = HostMgr::instance().getAll6(IOAddress("2001:db8:1:12::"));
- ASSERT_EQ(1, hosts.size());
+ ASSERT_EQ(1U, hosts.size());
// For given IP prefix there should be two reservations.
hosts = HostMgr::instance().getAll6(IOAddress("2001:db8:1:10::"));
- ASSERT_EQ(2, hosts.size());
+ ASSERT_EQ(2U, hosts.size());
// Make sure that subnet is correct.
- EXPECT_EQ(1, hosts[0]->getIPv6SubnetID());
- EXPECT_EQ(1, hosts[1]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[0]->getIPv6SubnetID());
+ EXPECT_EQ(1U, hosts[1]->getIPv6SubnetID());
// Make sure that all hosts were returned with different identifiers, and
// they have expected reservations.
// Select hosts for an unspecified source.
hosts = HostMgr::instance().getAll4(IOAddress("2001:db8:1:10::"),
HostMgrOperationTarget::UNSPECIFIED_SOURCE);
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
}
void
addHost6(data_source2, duids_[1], SubnetID(1), IOAddress("2001:db8:1::5"));
CfgMgr::instance().commit();
// 4 IPv4 reservations - 2 sources * 2 addresses.
- ASSERT_EQ(4, HostMgr::instance().getAll4(SubnetID(1)).size());
+ ASSERT_EQ(4U, HostMgr::instance().getAll4(SubnetID(1)).size());
// 2 IPv6 reservations - each with 2 reserved addresses.
- ASSERT_EQ(2, HostMgr::instance().getAll6(SubnetID(1)).size());
+ ASSERT_EQ(2U, HostMgr::instance().getAll6(SubnetID(1)).size());
EXPECT_TRUE(HostMgr::instance().del(SubnetID(1), IOAddress("192.0.2.5"), HostMgrOperationTarget::ALL_SOURCES));
EXPECT_TRUE(HostMgr::instance().del(SubnetID(1), IOAddress("2001:db8:1::5"), HostMgrOperationTarget::ALL_SOURCES));
addHost6(data_source1, duids_[2], SubnetID(1), IOAddress("2001:db8:1::5"));
addHost6(data_source2, duids_[3], SubnetID(1), IOAddress("2001:db8:1::5"));
CfgMgr::instance().commit();
- ASSERT_EQ(4, HostMgr::instance().getAll4(SubnetID(1)).size());
- ASSERT_EQ(2, HostMgr::instance().getAll6(SubnetID(1)).size());
+ ASSERT_EQ(4U, HostMgr::instance().getAll4(SubnetID(1)).size());
+ ASSERT_EQ(2U, HostMgr::instance().getAll6(SubnetID(1)).size());
if (has_alternate_source) {
EXPECT_TRUE(HostMgr::instance().del(SubnetID(1), IOAddress("192.0.2.5")));
EXPECT_FALSE(HostMgr::instance().del(SubnetID(1), IOAddress("192.0.2.5"), HostMgrOperationTarget::UNSPECIFIED_SOURCE));
EXPECT_FALSE(HostMgr::instance().del(SubnetID(1), IOAddress("2001:db8:1::5"), HostMgrOperationTarget::UNSPECIFIED_SOURCE));
- EXPECT_EQ(4, HostMgr::instance().getAll4(SubnetID(1)).size());
- EXPECT_EQ(2, HostMgr::instance().getAll6(SubnetID(1)).size());
+ EXPECT_EQ(4U, HostMgr::instance().getAll4(SubnetID(1)).size());
+ EXPECT_EQ(2U, HostMgr::instance().getAll6(SubnetID(1)).size());
HostMgr::instance().del(SubnetID(1), IOAddress("192.0.2.5"), HostMgrOperationTarget::ALL_SOURCES);
HostMgr::instance().del(SubnetID(1), IOAddress("2001:db8:1::5"), HostMgrOperationTarget::ALL_SOURCES);
EXPECT_TRUE(HostMgr::instance().del(SubnetID(1), IOAddress("2001:db8:1::4")));
// Expect other two IPv4 hosts still in reservations.
- EXPECT_EQ(4, HostMgr::instance().getAll4(SubnetID(1)).size());
+ EXPECT_EQ(4U, HostMgr::instance().getAll4(SubnetID(1)).size());
// Expect other two IPv6 hosts still in reservations.
- EXPECT_EQ(2, HostMgr::instance().getAll6(SubnetID(1)).size());
+ EXPECT_EQ(2U, HostMgr::instance().getAll6(SubnetID(1)).size());
}
void
&hwaddrs_[0]->hwaddr_[0],
hwaddrs_[0]->hwaddr_.size()),
NoHostDataSourceManager);
- EXPECT_EQ(1, HostMgr::instance().getAll4(SubnetID(1)).size());
+ EXPECT_EQ(1U, HostMgr::instance().getAll4(SubnetID(1)).size());
// Delete from explicit alternate sources.
EXPECT_THROW(HostMgr::instance().del4(SubnetID(1), Host::IDENT_HWADDR,
hwaddrs_[0]->hwaddr_.size(),
HostMgrOperationTarget::ALTERNATE_SOURCES),
NoHostDataSourceManager);
- EXPECT_EQ(1, HostMgr::instance().getAll4(SubnetID(1)).size());
+ EXPECT_EQ(1U, HostMgr::instance().getAll4(SubnetID(1)).size());
// Delete from unspecified source.
EXPECT_FALSE(HostMgr::instance().del4(SubnetID(1), Host::IDENT_HWADDR,
&hwaddrs_[0]->hwaddr_[0],
hwaddrs_[0]->hwaddr_.size(),
HostMgrOperationTarget::UNSPECIFIED_SOURCE));
- EXPECT_EQ(1, HostMgr::instance().getAll4(SubnetID(1)).size());
+ EXPECT_EQ(1U, HostMgr::instance().getAll4(SubnetID(1)).size());
// Delete from primary source.
EXPECT_TRUE(HostMgr::instance().del4(SubnetID(1), Host::IDENT_HWADDR,
&hwaddrs_[0]->hwaddr_[0],
hwaddrs_[0]->hwaddr_.size()));
// The host reservation in the primary source still exists.
- EXPECT_EQ(1, HostMgr::instance().getAll4(SubnetID(1)).size());
+ EXPECT_EQ(1U, HostMgr::instance().getAll4(SubnetID(1)).size());
// Clean the host reservations.
HostMgr::instance().del4(SubnetID(1), Host::IDENT_HWADDR,
&hwaddrs_[0]->hwaddr_[0],
hwaddrs_[0]->hwaddr_.size(),
HostMgrOperationTarget::ALTERNATE_SOURCES));
// The host reservation in the primary source still exists.
- EXPECT_EQ(1, HostMgr::instance().getAll4(SubnetID(1)).size());
+ EXPECT_EQ(1U, HostMgr::instance().getAll4(SubnetID(1)).size());
// Clean the host reservations.
HostMgr::instance().del4(SubnetID(1), Host::IDENT_HWADDR,
&hwaddrs_[0]->hwaddr_[0],
&hwaddrs_[0]->hwaddr_[0],
hwaddrs_[0]->hwaddr_.size(),
HostMgrOperationTarget::UNSPECIFIED_SOURCE));
- EXPECT_EQ(2, HostMgr::instance().getAll4(SubnetID(1)).size());
+ EXPECT_EQ(2U, HostMgr::instance().getAll4(SubnetID(1)).size());
// Delete from primary source.
EXPECT_TRUE(HostMgr::instance().del4(SubnetID(1), Host::IDENT_HWADDR,
hwaddrs_[0]->hwaddr_.size(),
HostMgrOperationTarget::PRIMARY_SOURCE));
// The host reservation in the alternate source still exists.
- EXPECT_EQ(1, HostMgr::instance().getAll4(SubnetID(1)).size());
+ EXPECT_EQ(1U, HostMgr::instance().getAll4(SubnetID(1)).size());
// Clean the host reservations.
HostMgr::instance().del4(SubnetID(1), Host::IDENT_HWADDR,
&hwaddrs_[0]->hwaddr_[0],
&duids_[0]->getDuid()[0],
duids_[0]->getDuid().size()),
NoHostDataSourceManager);
- EXPECT_EQ(1, HostMgr::instance().getAll6(SubnetID(1)).size());
+ EXPECT_EQ(1U, HostMgr::instance().getAll6(SubnetID(1)).size());
// Delete from explicit alternate sources.
EXPECT_THROW(HostMgr::instance().del6(SubnetID(1), Host::IDENT_DUID,
duids_[0]->getDuid().size(),
HostMgrOperationTarget::ALTERNATE_SOURCES),
NoHostDataSourceManager);
- EXPECT_EQ(1, HostMgr::instance().getAll6(SubnetID(1)).size());
+ EXPECT_EQ(1U, HostMgr::instance().getAll6(SubnetID(1)).size());
// Delete from unspecified source.
EXPECT_FALSE(HostMgr::instance().del6(SubnetID(1), Host::IDENT_DUID,
&duids_[0]->getDuid()[0],
duids_[0]->getDuid().size(),
HostMgrOperationTarget::UNSPECIFIED_SOURCE));
- EXPECT_EQ(1, HostMgr::instance().getAll6(SubnetID(1)).size());
+ EXPECT_EQ(1U, HostMgr::instance().getAll6(SubnetID(1)).size());
// Delete from primary source.
EXPECT_TRUE(HostMgr::instance().del6(SubnetID(1), Host::IDENT_DUID,
&duids_[0]->getDuid()[0],
duids_[0]->getDuid().size()));
// The host reservation in the primary source still exists.
- EXPECT_EQ(1, HostMgr::instance().getAll6(SubnetID(1)).size());
+ EXPECT_EQ(1U, HostMgr::instance().getAll6(SubnetID(1)).size());
// Clean the host reservations.
HostMgr::instance().del6(SubnetID(1), Host::IDENT_DUID,
&duids_[0]->getDuid()[0],
duids_[0]->getDuid().size(),
HostMgrOperationTarget::ALTERNATE_SOURCES));
// The host reservation in the primary source still exists.
- EXPECT_EQ(1, HostMgr::instance().getAll6(SubnetID(1)).size());
+ EXPECT_EQ(1U, HostMgr::instance().getAll6(SubnetID(1)).size());
// Clean the host reservations.
HostMgr::instance().del6(SubnetID(1), Host::IDENT_DUID,
&duids_[0]->getDuid()[0],
&duids_[0]->getDuid()[0],
duids_[0]->getDuid().size(),
HostMgrOperationTarget::UNSPECIFIED_SOURCE));
- EXPECT_EQ(2, HostMgr::instance().getAll6(SubnetID(1)).size());
+ EXPECT_EQ(2U, HostMgr::instance().getAll6(SubnetID(1)).size());
// Delete from primary source.
EXPECT_TRUE(HostMgr::instance().del6(SubnetID(1), Host::IDENT_DUID,
duids_[0]->getDuid().size(),
HostMgrOperationTarget::PRIMARY_SOURCE));
// The host reservation in the alternate source still exists.
- EXPECT_EQ(1, HostMgr::instance().getAll6(SubnetID(1)).size());
+ EXPECT_EQ(1U, HostMgr::instance().getAll6(SubnetID(1)).size());
// Clean the host reservations.
HostMgr::instance().del6(SubnetID(1), Host::IDENT_DUID,
&duids_[0]->getDuid()[0],
// There should be no hosts.
ConstHostCollection hosts(hdsptr_->getAll4(v4_subnet));
- EXPECT_EQ(0, hosts.size());
+ EXPECT_EQ(0U, hosts.size());
// Add the host.
EXPECT_NO_THROW(hdsptr_->add(host));
// The host should be there.
hosts = hdsptr_->getAll4(v4_subnet);
- EXPECT_EQ(1, hosts.size());
+ EXPECT_EQ(1U, hosts.size());
EXPECT_EQ("hwaddr=" + hwaddr + " ipv4_subnet_id=" + to_string(v4_subnet) +
" ipv6_subnet_id=" + to_string(v6_subnet) +
" hostname=(empty) "
// The same host should be in the data source.
hosts = hdsptr_->getAll4(v4_subnet);
- EXPECT_EQ(1, hosts.size());
+ EXPECT_EQ(1U, hosts.size());
EXPECT_EQ("hwaddr=" + hwaddr + " ipv4_subnet_id=" + to_string(v4_subnet) +
" ipv6_subnet_id=" + to_string(v6_subnet) +
" hostname=(empty) "
// The change should be reflected in the data source.
hosts = hdsptr_->getAll4(v4_subnet);
- EXPECT_EQ(1, hosts.size());
+ EXPECT_EQ(1U, hosts.size());
EXPECT_EQ("hwaddr=" + hwaddr + " ipv4_subnet_id=" + to_string(v4_subnet) +
" ipv6_subnet_id=" + to_string(v6_subnet) +
" hostname=foo.example.com "
// The change should be reflected in the data source.
hosts = hdsptr_->getAll4(v4_subnet);
- EXPECT_EQ(1, hosts.size());
+ EXPECT_EQ(1U, hosts.size());
EXPECT_EQ("hwaddr=" + hwaddr + " ipv4_subnet_id=" + to_string(v4_subnet) +
" ipv6_subnet_id=" + to_string(v6_subnet) +
" hostname=(empty) "
///
/// @param subnets number of subnets to test
/// @param id Host identifier type.
- void testMultipleSubnets(int subnets, const Host::IdentifierType& id);
+ void testMultipleSubnets(size_t subnets, const Host::IdentifierType& id);
/// @brief Test inserts several hosts with unique IPv6 addresses and
/// checks that they can be retrieved properly.
///
/// @param subnets number of subnets to test
/// @param id identifier type (IDENT_HWADDR or IDENT_DUID)
- void testSubnetId6(int subnets, Host::IdentifierType id);
+ void testSubnetId6(size_t subnets, Host::IdentifierType id);
/// @brief Test if the duplicate host with same DUID can't be inserted.
///
/// @brief Check v6 leases (using get page to keep order).
void checkLease6() {
- EXPECT_EQ(8, leases6.size());
+ EXPECT_EQ(8U, leases6.size());
Lease6Collection got;
asiolink::IOAddress zero = asiolink::IOAddress::IPV6_ZERO_ADDRESS();
LeasePageSize ps100(100);
GenericExtendedInfoTest<NakedLeaseMgrType>::testInitLease4() {
start(false);
initLease4();
- EXPECT_EQ(8, leases4.size());
+ EXPECT_EQ(8U, leases4.size());
asiolink::IOAddress zero = asiolink::IOAddress::IPV4_ZERO_ADDRESS();
Lease4Collection got;
// Use the page version as it returns leases in order.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id2,
zero,
LeasePageSize(100)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Unknown relay id #2, now - 1000, now + 1000: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id2,
LeasePageSize(100),
now_ - 1000,
now_ + 1000));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Relay id #0, now - 2000, now - 1000: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
LeasePageSize(100),
now_ - 2000,
now_ - 1000));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Relay id #0, now + 1000, now + 2000: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
LeasePageSize(100),
now_ + 1000,
now_ + 2000));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Relay id #0: 3 entries (0, 2, 3, 4).
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
zero,
LeasePageSize(100)));
- ASSERT_EQ(4, got.size());
+ ASSERT_EQ(4U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[0]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
zero,
LeasePageSize(2)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[0]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
addr2,
LeasePageSize(2)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[3]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
addr4,
LeasePageSize(2)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Relay id #0, from now - 500: 3 entries (0, 2, 4).
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRelayId(relay_id0,
zero,
LeasePageSize(100),
now_ - 500));
- ASSERT_EQ(3, got.size());
+ ASSERT_EQ(3U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[0]);
zero,
LeasePageSize(100),
0, now_ - 200));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[2]);
LeasePageSize(1),
now_ - 500,
now_ - 100));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[2]);
LeasePageSize(1),
now_ - 500,
now_ - 100));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[4]);
LeasePageSize(1),
now_ - 500,
now_ - 100));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
}
/// @brief Verifies that getLeases4ByRemoteId works as expected.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id2,
zero,
LeasePageSize(100)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Unknown remote id #2, now - 1000, now + 1000: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id2,
LeasePageSize(100),
now_ - 1000,
now_ + 1000));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Remote id #0, now - 2000, now - 1000: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
LeasePageSize(100),
now_ - 2000,
now_ - 1000));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Remote id #0, now + 1000, now + 2000: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
LeasePageSize(100),
now_ + 1000,
now_ + 2000));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Remote id #0: 3 entries (0, 2, 3, 4).
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
zero,
LeasePageSize(100)));
- ASSERT_EQ(4, got.size());
+ ASSERT_EQ(4U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[0]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
zero,
LeasePageSize(2)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[0]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
addr2,
LeasePageSize(2)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[3]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
addr4,
LeasePageSize(2)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Remote id #0, from now - 500: 3 entries (0, 2, 4).
EXPECT_NO_THROW(got = lease_mgr_->getLeases4ByRemoteId(remote_id0,
zero,
LeasePageSize(100),
now_ - 500));
- ASSERT_EQ(3, got.size());
+ ASSERT_EQ(3U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[0]);
zero,
LeasePageSize(100),
0, now_ - 200));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[2]);
LeasePageSize(1),
now_ - 500,
now_ - 100));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[2]);
LeasePageSize(1),
now_ - 500,
now_ - 100));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(*lease, *leases4[4]);
LeasePageSize(1),
now_ - 500,
now_ - 100));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
}
template<typename NakedLeaseMgrType> void
switch (check) {
case CfgConsistency::EXTENDED_INFO_CHECK_NONE:
// Updated leases: 3, 5.
- EXPECT_EQ(updated, 2);
+ EXPECT_EQ(updated, 2U);
break;
case CfgConsistency::EXTENDED_INFO_CHECK_FIX:
// Updated leases: 2, 3, 4, 5.
- EXPECT_EQ(updated, 4);
+ EXPECT_EQ(updated, 4U);
break;
case CfgConsistency::EXTENDED_INFO_CHECK_STRICT:
// Updated leases: 2, 3, 4, 5, 6.
- EXPECT_EQ(updated, 5);
+ EXPECT_EQ(updated, 5U);
break;
case CfgConsistency::EXTENDED_INFO_CHECK_PEDANTIC:
default:
// Updated leases: 2, 3, 4, 5, 6, 7.
- EXPECT_EQ(updated, 6);
+ EXPECT_EQ(updated, 6U);
break;
}
switch (check) {
case CfgConsistency::EXTENDED_INFO_CHECK_NONE:
// Got leases: 0, 1, 4, 5, 6, 7.
- EXPECT_EQ(6, by_relay_id.size());
+ EXPECT_EQ(6U, by_relay_id.size());
break;
case CfgConsistency::EXTENDED_INFO_CHECK_FIX:
// Got leases: 0, 1, 2, 5, 6, 7.
- EXPECT_EQ(6, by_relay_id.size());
+ EXPECT_EQ(6U, by_relay_id.size());
break;
case CfgConsistency::EXTENDED_INFO_CHECK_STRICT:
// Got leases: 0, 1, 2, 4, 7.
- EXPECT_EQ(5, by_relay_id.size());
+ EXPECT_EQ(5U, by_relay_id.size());
break;
case CfgConsistency::EXTENDED_INFO_CHECK_PEDANTIC:
default:
// Got leases: 0, 1, 2, 4.
- EXPECT_EQ(4, by_relay_id.size());
+ EXPECT_EQ(4U, by_relay_id.size());
break;
}
switch (check) {
case CfgConsistency::EXTENDED_INFO_CHECK_NONE:
// Got leases: 0, 1, 4, 5, 6, 7.
- EXPECT_EQ(6, by_remote_id.size());
+ EXPECT_EQ(6U, by_remote_id.size());
break;
case CfgConsistency::EXTENDED_INFO_CHECK_FIX:
// Got leases: 0, 1, 2, 5, 6, 7.
- EXPECT_EQ(6, by_remote_id.size());
+ EXPECT_EQ(6U, by_remote_id.size());
break;
case CfgConsistency::EXTENDED_INFO_CHECK_STRICT:
// Got leases: 0, 1, 2, 4, 7.
- EXPECT_EQ(5, by_remote_id.size());
+ EXPECT_EQ(5U, by_remote_id.size());
break;
case CfgConsistency::EXTENDED_INFO_CHECK_PEDANTIC:
default:
// Got leases: 0, 1, 2, 4.
- EXPECT_EQ(4, by_remote_id.size());
+ EXPECT_EQ(4U, by_remote_id.size());
break;
}
GenericExtendedInfoTest<NakedLeaseMgrType>::testEnableTables() {
start(true);
initLease6();
- EXPECT_EQ(8, leases6.size());
+ EXPECT_EQ(8U, leases6.size());
Lease6Collection got;
EXPECT_NO_THROW(got = lease_mgr_->getLeases6());
ASSERT_EQ(leases6.size(), got.size());
// Lease manager is created with empty tables.
start(true);
initLease6();
- EXPECT_EQ(0, lease_mgr_->byRelayId6size());
- EXPECT_EQ(0, lease_mgr_->byRemoteId6size());
+ EXPECT_EQ(0U, lease_mgr_->byRelayId6size());
+ EXPECT_EQ(0U, lease_mgr_->byRemoteId6size());
// Create parameter values.
asiolink::IOAddress lease_addr(ADDRESS6[0]);
EXPECT_NO_THROW(lease_mgr_->addRelayId6(lease_addr, relay_id_data1));
EXPECT_NO_THROW(lease_mgr_->addRemoteId6(lease_addr, remote_id0));
EXPECT_NO_THROW(lease_mgr_->addRemoteId6(lease_addr, remote_id1));
- EXPECT_EQ(2, lease_mgr_->byRelayId6size());
- EXPECT_EQ(2, lease_mgr_->byRemoteId6size());
+ EXPECT_EQ(2U, lease_mgr_->byRelayId6size());
+ EXPECT_EQ(2U, lease_mgr_->byRemoteId6size());
// Remove the first lease.
EXPECT_NO_THROW(lease_mgr_->deleteLease(leases6[0]));
EXPECT_FALSE(lease_mgr_->getLease6(Lease::TYPE_PD, lease_addr));
// Check tables are now empty.
- EXPECT_EQ(0, lease_mgr_->byRelayId6size());
- EXPECT_EQ(0, lease_mgr_->byRemoteId6size());
+ EXPECT_EQ(0U, lease_mgr_->byRelayId6size());
+ EXPECT_EQ(0U, lease_mgr_->byRemoteId6size());
}
/// @brief Verifies that getLeases6ByRelayId works as expected.
// Lease manager is created with empty tables.
start(true);
initLease6();
- EXPECT_EQ(0, lease_mgr_->byRelayId6size());
+ EXPECT_EQ(0U, lease_mgr_->byRelayId6size());
// Create parameter values.
asiolink::IOAddress lease_addr0(ADDRESS6[0]);
EXPECT_NO_THROW(lease_mgr_->addRelayId6(lease_addr1, relay_id_data0));
EXPECT_NO_THROW(lease_mgr_->addRelayId6(lease_addr1, relay_id_data1));
EXPECT_NO_THROW(lease_mgr_->addRelayId6(lease_addr2, relay_id_data1));
- EXPECT_EQ(6, lease_mgr_->byRelayId6size());
+ EXPECT_EQ(6U, lease_mgr_->byRelayId6size());
Lease6Collection got;
// Unknown relay id #2: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRelayId(relay_id2,
zero,
LeasePageSize(100)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Relay id #0: 3 entries but 2 addresses.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRelayId(relay_id0,
zero,
LeasePageSize(100)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
Lease6Ptr lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(lease_addr0, lease->addr_);
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRelayId(relay_id1,
zero,
LeasePageSize(2)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(lease_addr0, lease->addr_);
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRelayId(relay_id1,
lease->addr_,
LeasePageSize(2)));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(lease_addr2, lease->addr_);
// Lease manager is created with empty tables.
start(true);
initLease6();
- EXPECT_EQ(0, lease_mgr_->byRemoteId6size());
+ EXPECT_EQ(0U, lease_mgr_->byRemoteId6size());
// Create parameter values.
asiolink::IOAddress lease_addr0(ADDRESS6[0]);
EXPECT_NO_THROW(lease_mgr_->addRemoteId6(lease_addr1, remote_id0));
EXPECT_NO_THROW(lease_mgr_->addRemoteId6(lease_addr1, remote_id1));
EXPECT_NO_THROW(lease_mgr_->addRemoteId6(lease_addr2, remote_id1));
- EXPECT_EQ(6, lease_mgr_->byRemoteId6size());
+ EXPECT_EQ(6U, lease_mgr_->byRemoteId6size());
Lease6Collection got;
// Unknown remote id #2: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRemoteId(remote_id2,
zero,
LeasePageSize(10)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Remote id #0: 3 entries but 2 addresses.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRemoteId(remote_id0,
zero,
LeasePageSize(10)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
Lease6Ptr lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(lease_addr0, lease->addr_);
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRemoteId(remote_id1,
zero,
LeasePageSize(2)));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(lease_addr0, lease->addr_);
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRemoteId(remote_id1,
lease->addr_,
LeasePageSize(2)));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_EQ(lease_addr2, lease->addr_);
// Other link: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6(100, zero,
LeasePageSize(10)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
// Link: 8 entries.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6(1, zero,
LeasePageSize(10)));
- ASSERT_EQ(8, got.size());
+ ASSERT_EQ(8U, got.size());
Lease6Ptr lease;
for (size_t i = 0; i < 8; ++i) {
lease = got[i];
// Link: initial partial: 4 entries.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6(1, zero,
LeasePageSize(4)));
- ASSERT_EQ(4, got.size());
+ ASSERT_EQ(4U, got.size());
for (size_t i = 0; i < 4; ++i) {
lease = got[i];
ASSERT_TRUE(lease);
// Link: next partial: 4 entries.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6(1, lease->addr_,
LeasePageSize(4)));
- ASSERT_EQ(4, got.size());
+ ASSERT_EQ(4U, got.size());
for (size_t i = 0; i < 4; ++i) {
lease = got[i];
ASSERT_TRUE(lease);
// Link: further partial: nothing.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6(1, lease->addr_,
LeasePageSize(4)));
- EXPECT_EQ(0, got.size());
+ EXPECT_EQ(0U, got.size());
}
template<typename NakedLeaseMgrType> void
// If extended info tables were not enabled they are not touched.
if (!extended_info_table_enable) {
- EXPECT_EQ(1, lease_mgr_->byRelayId6size());
- EXPECT_EQ(1, lease_mgr_->byRemoteId6size());
+ EXPECT_EQ(1U, lease_mgr_->byRelayId6size());
+ EXPECT_EQ(1U, lease_mgr_->byRemoteId6size());
// Check relay id.
std::vector<uint8_t> relay_id_data = createFromString(DUIDS[4]);
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRelayId(relay_id,
zero,
ps100));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
EXPECT_EQ(asiolink::IOAddress(ADDRESS6[4]), got[0]->addr_);
// Check remote id.
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRemoteId(remote_id,
zero,
ps100));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
EXPECT_EQ(asiolink::IOAddress(ADDRESS6[5]), got[0]->addr_);
}
if (check == CfgConsistency::EXTENDED_INFO_CHECK_NONE) {
if (!extended_info_table_enable) {
// Nothing was done.
- EXPECT_EQ(0, updated);
+ EXPECT_EQ(0U, updated);
} else {
// Tables were rebuilt with only the third lease.
- EXPECT_EQ(1, updated);
- EXPECT_EQ(1, lease_mgr_->byRelayId6size());
- EXPECT_EQ(1, lease_mgr_->byRemoteId6size());
+ EXPECT_EQ(1U, updated);
+ EXPECT_EQ(1U, lease_mgr_->byRelayId6size());
+ EXPECT_EQ(1U, lease_mgr_->byRemoteId6size());
DUID relay_id(std::vector<uint8_t>(8, 0x64));
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRelayId(relay_id,
zero,
ps100));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
data::ConstElementPtr expected2 = leases6[2]->toElement();
LeasePtr lease = got[0];
ASSERT_TRUE(lease);
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRemoteId(remote_id,
zero,
ps100));
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_TRUE(expected2->equals(*lease->toElement()))
// Updated first and second.
if (!extended_info_table_enable) {
// and nothing else.
- EXPECT_EQ(2, updated);
+ EXPECT_EQ(2U, updated);
} else {
// Second and third leases were added to extended info tables.
- EXPECT_EQ(3, updated);
- EXPECT_EQ(2, lease_mgr_->byRelayId6size());
- EXPECT_EQ(2, lease_mgr_->byRemoteId6size());
+ EXPECT_EQ(3U, updated);
+ EXPECT_EQ(2U, lease_mgr_->byRelayId6size());
+ EXPECT_EQ(2U, lease_mgr_->byRemoteId6size());
DUID relay_id(std::vector<uint8_t>(8, 0x64));
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRelayId(relay_id,
zero,
ps100));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
data::ConstElementPtr expected1 = leases6[1]->toElement();
LeasePtr lease = got[0];
ASSERT_TRUE(lease);
EXPECT_NO_THROW(got = lease_mgr_->getLeases6ByRemoteId(remote_id,
zero,
ps100));
- ASSERT_EQ(2, got.size());
+ ASSERT_EQ(2U, got.size());
lease = got[0];
ASSERT_TRUE(lease);
EXPECT_TRUE(expected1->equals(*lease->toElement()))
for (size_t i = 0; i < straddress4_.size(); ++i) {
leases.push_back(initializeLease4(straddress4_[i]));
}
- EXPECT_EQ(8, leases.size());
+ EXPECT_EQ(8U, leases.size());
// Check all were created and that they are different.
checkLeasesDifferent(leases);
for (size_t i = 0; i < straddress6_.size(); ++i) {
leases.push_back(initializeLease6(straddress6_[i]));
}
- EXPECT_EQ(8, leases.size());
+ EXPECT_EQ(8U, leases.size());
// Check all were created and that they are different.
checkLeasesDifferent(leases);
EXPECT_TRUE(lmptr_->addLease(lease));
Lease4Collection returned = lmptr_->getLease4(*lease->client_id_);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
// We should retrieve our lease...
detailCompareLease(lease, *returned.begin());
lease = initializeLease4(straddress4_[2]);
returned = lmptr_->getLease4(*lease->client_id_);
- ASSERT_EQ(0, returned.size());
+ ASSERT_EQ(0U, returned.size());
}
void
// But getting the lease with non-NULL client id should be successful.
returned = lmptr_->getLease4(*leaseB->client_id_);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
}
void
// Check that we can get the lease by HWAddr
HWAddr tmp(*leases[2]->hwaddr_);
Lease4Collection returned = lmptr_->getLease4(tmp);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
detailCompareLease(leases[2], *returned.begin());
l_returned = lmptr_->getLease4(tmp, leases[2]->subnet_id_);
// we should not have a lease, with this MAC Addr
Lease4Collection returned = lmptr_->getLease4(hwaddrB);
- ASSERT_EQ(0, returned.size());
+ ASSERT_EQ(0U, returned.size());
// But with this one
returned = lmptr_->getLease4(hwaddrA);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
}
void
Lease4Collection returned = lmptr_->getLease4(tmp);
// Should be three leases, matching leases[1], [3] and [5].
- ASSERT_EQ(3, returned.size());
+ ASSERT_EQ(3U, returned.size());
// Check the lease[5] (and only this one) has an user context.
size_t contexts = 0;
EXPECT_EQ("{ \"foo\": true }", i->getContext()->str());
}
}
- EXPECT_EQ(1, contexts);
+ EXPECT_EQ(1U, contexts);
// Easiest way to check is to look at the addresses.
vector<string> addresses;
// Repeat test with just one expected match
returned = lmptr_->getLease4(*leases[2]->hwaddr_);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
detailCompareLease(leases[2], *returned.begin());
// Check that an empty vector is valid
EXPECT_TRUE(leases[7]->hwaddr_->hwaddr_.empty());
EXPECT_FALSE(leases[7]->client_id_->getClientId().empty());
returned = lmptr_->getLease4(*leases[7]->hwaddr_);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
detailCompareLease(leases[7], *returned.begin());
// Try to get something with invalid hardware address
HWAddr hwaddr(vector<uint8_t>(6, 0x80), HTYPE_ETHER);
hwaddr.hwaddr_ = vector<uint8_t>(6, 0);
returned = lmptr_->getLease4(hwaddr);
- EXPECT_EQ(0, returned.size());
+ EXPECT_EQ(0U, returned.size());
}
void
// These are not important from lease management perspective, but
// let's check them anyway.
EXPECT_EQ(Lease::TYPE_NA, x->type_);
- EXPECT_EQ(100, x->preferred_lft_);
- EXPECT_EQ(200, x->valid_lft_);
+ EXPECT_EQ(100U, x->preferred_lft_);
+ EXPECT_EQ(200U, x->valid_lft_);
// Test getLease6(duid, iaid, subnet_id) - positive case
Lease6Ptr y = lmptr_->getLease6(Lease::TYPE_NA, *duid, iaid, subnet_id);
Lease6Ptr stored1 = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
ASSERT_TRUE(stored1);
ASSERT_TRUE(stored1->hwaddr_);
- EXPECT_EQ(123, stored1->hwaddr_->htype_);
+ EXPECT_EQ(123U, stored1->hwaddr_->htype_);
EXPECT_EQ(HWAddr::HWADDR_SOURCE_RAW, stored1->hwaddr_->source_);
// Second lease should have a hardware address in it
Lease6Ptr stored2 = lmptr_->getLease6(leasetype6_[2], ioaddress6_[2]);
ASSERT_TRUE(stored2);
ASSERT_TRUE(stored2->hwaddr_);
- EXPECT_EQ(456, stored2->hwaddr_->htype_);
+ EXPECT_EQ(456U, stored2->hwaddr_->htype_);
EXPECT_EQ(HWAddr::HWADDR_SOURCE_DUID, stored2->hwaddr_->source_);
// Third lease should NOT have any hardware address.
// we should not have a lease, with this HWAddr
Lease6Collection returned = lmptr_->getLease6(hwaddrB);
- ASSERT_EQ(0, returned.size());
+ ASSERT_EQ(0U, returned.size());
// But with this one
returned = lmptr_->getLease6(hwaddrA);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
}
void
Lease6Collection returned = lmptr_->getLease6(tmp);
// Should be three leases, matching leases[1], [3] and [5].
- ASSERT_EQ(3, returned.size());
+ ASSERT_EQ(3U, returned.size());
// Check the lease[5] (and only this one) has an user context.
size_t contexts = 0;
EXPECT_EQ("{ \"foo\": true }", i->getContext()->str());
}
}
- EXPECT_EQ(1, contexts);
+ EXPECT_EQ(1U, contexts);
// Easiest way to check is to look at the addresses.
vector<string> addresses;
// Repeat test with just one expected match
returned = lmptr_->getLease6(*leases[2]->hwaddr_);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
detailCompareLease(leases[2], *returned.begin());
// Check that an empty vector is valid
EXPECT_TRUE(leases[7]->hwaddr_->hwaddr_.empty());
returned = lmptr_->getLease6(*leases[7]->hwaddr_);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
detailCompareLease(leases[7], *returned.begin());
// Try to get something with invalid hardware address
HWAddr hwaddr(vector<uint8_t>(6, 0x80), HTYPE_ETHER);
hwaddr.hwaddr_ = vector<uint8_t>(6, 0);
returned = lmptr_->getLease6(hwaddr);
- EXPECT_EQ(0, returned.size());
+ EXPECT_EQ(0U, returned.size());
}
void
Lease4Collection returned =
lmptr_->getLease4(*leases[1]->hwaddr_);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
detailCompareLease(leases[1], *returned.begin());
ASSERT_TRUE(lmptr_->deleteLease(leases[1]));
}
Lease6Collection returned =
lmptr_->getLease6(*leases[1]->hwaddr_);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
detailCompareLease(leases[1], *returned.begin());
ASSERT_TRUE(lmptr_->deleteLease(leases[1]));
}
Lease4Collection returned = lmptr_->getLease4(*leases[1]->client_id_);
// Should be four leases, matching leases[1], [4], [5] and [6].
- ASSERT_EQ(4, returned.size());
+ ASSERT_EQ(4U, returned.size());
// Check the lease[5] (and only this one) has an user context.
size_t contexts = 0;
EXPECT_EQ("{ \"foo\": true }", i->getContext()->str());
}
}
- EXPECT_EQ(1, contexts);
+ EXPECT_EQ(1U, contexts);
// Easiest way to check is to look at the addresses.
vector<string> addresses;
// Repeat test with just one expected match
returned = lmptr_->getLease4(*leases[3]->client_id_);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
detailCompareLease(leases[3], *returned.begin());
// Try to get something with invalid client ID
const uint8_t invalid_data[] = {0, 0, 0};
ClientId invalid(invalid_data, sizeof(invalid_data));
returned = lmptr_->getLease4(invalid);
- EXPECT_EQ(0, returned.size());
+ EXPECT_EQ(0U, returned.size());
}
void
// There should be exactly two leases for the subnet id that the second
// lease belongs to.
Lease4Collection returned = lmptr_->getLeases4(leases[1]->subnet_id_);
- ASSERT_EQ(2, returned.size());
+ ASSERT_EQ(2U, returned.size());
}
void
// There should be exactly 4 leases for the hostname of the second lease.
ASSERT_FALSE(leases[1]->hostname_.empty());
returned = lmptr_->getLeases4(leases[1]->hostname_);
- EXPECT_EQ(4, returned.size());
+ EXPECT_EQ(4U, returned.size());
// And 3 for the forth lease.
ASSERT_FALSE(leases[3]->hostname_.empty());
returned = lmptr_->getLeases4(leases[3]->hostname_);
- EXPECT_EQ(3, returned.size());
+ EXPECT_EQ(3U, returned.size());
}
void
Lease4Collection got = lmptr_->getLeases4(Lease::STATE_DECLINED, 0);
// Easy check: got 4 leases in declined state.
- EXPECT_EQ(4, got.size());
+ EXPECT_EQ(4U, got.size());
for (auto const& lease : got) {
EXPECT_EQ(Lease::STATE_DECLINED, lease->state_);
}
// Try again with leases[2] subnet.
got = lmptr_->getLeases4(Lease::STATE_DECLINED, leases[2]->subnet_id_);
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
EXPECT_TRUE(*leases[2] == *got[0]);
}
// There should be exactly two leases for the subnet id that the second
// lease belongs to.
Lease6Collection returned = lmptr_->getLeases6(leases[1]->subnet_id_);
- EXPECT_EQ(2, returned.size());
+ EXPECT_EQ(2U, returned.size());
}
void
// There should be exactly 4 leases for the hostname of the second lease.
ASSERT_FALSE(leases[1]->hostname_.empty());
returned = lmptr_->getLeases6(leases[1]->hostname_);
- EXPECT_EQ(4, returned.size());
+ EXPECT_EQ(4U, returned.size());
// One for the fifth lease.
ASSERT_FALSE(leases[4]->hostname_.empty());
returned = lmptr_->getLeases6(leases[4]->hostname_);
- EXPECT_EQ(1, returned.size());
+ EXPECT_EQ(1U, returned.size());
// And 3 for the sixth lease.
ASSERT_FALSE(leases[5]->hostname_.empty());
returned = lmptr_->getLeases6(leases[5]->hostname_);
- EXPECT_EQ(3, returned.size());
+ EXPECT_EQ(3U, returned.size());
}
void
Lease6Collection got = lmptr_->getLeases6(Lease::STATE_DECLINED, 0);
// Easy check: got 4 leases in declined state.
- EXPECT_EQ(4, got.size());
+ EXPECT_EQ(4U, got.size());
for (auto const& lease : got) {
EXPECT_EQ(Lease::STATE_DECLINED, lease->state_);
}
// Try again with leases[2] subnet.
got = lmptr_->getLeases6(Lease::STATE_DECLINED, leases[2]->subnet_id_);
- ASSERT_EQ(1, got.size());
+ ASSERT_EQ(1U, got.size());
EXPECT_TRUE(*leases[2] == *got[0]);
}
GenericLeaseMgrTest::testGetLeases6DuidIaid() {
// Get the leases to be used for the test.
vector<Lease6Ptr> leases = createLeases6();
- ASSERT_LE(6, leases.size()); // Expect to access leases 0 through 5
+ ASSERT_LE(6U, leases.size()); // Expect to access leases 0 through 5
// Add them to the database
for (size_t i = 0; i < leases.size(); ++i) {
leases[1]->iaid_);
// Should be two leases, matching leases[1] and [4].
- ASSERT_EQ(2, returned.size());
+ ASSERT_EQ(2U, returned.size());
// Easiest way to check is to look at the addresses.
vector<string> addresses;
// nothing.
returned = lmptr_->getLeases6(leasetype6_[1], *leases[1]->duid_,
leases[1]->iaid_ + 1);
- EXPECT_EQ(0, returned.size());
+ EXPECT_EQ(0U, returned.size());
// Alter the leases[1] DUID to match nothing in the database.
vector<uint8_t> duid_vector = leases[1]->duid_->getDuid();
++duid_vector[0];
DUID new_duid(duid_vector);
returned = lmptr_->getLeases6(leasetype6_[1], new_duid, leases[1]->iaid_);
- EXPECT_EQ(0, returned.size());
+ EXPECT_EQ(0U, returned.size());
}
void
Lease6Collection returned = lmptr_->getLeases6(leasetype6_[1],
*leases[1]->duid_,
leases[1]->iaid_);
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
detailCompareLease(leases[1], *returned.begin());
ASSERT_TRUE(lmptr_->deleteLease(leases[1]));
}
std::sort(returned.begin(), returned.end(), compare);
// We should match two per lease type.
- ASSERT_EQ(2, returned.size());
+ ASSERT_EQ(2U, returned.size());
// Collection order returned is not guaranteed.
// Easiest way to check is to look at the addresses.
for (int i = 0; i < 2; ++i) {
Lease6Collection returned = lmptr_->getLeases6(leasetype6_[i], *duid, 142, 23);
// We should match one per lease type.
- ASSERT_EQ(1, returned.size());
+ ASSERT_EQ(1U, returned.size());
EXPECT_TRUE(*(returned[0]) == *leases[i * 2]);
}
Lease6Collection found_leases = lmptr_->getLeases6(Lease::TYPE_NA,
*duid, large_iaid);
// We should match the lease.
- ASSERT_EQ(1, found_leases.size());
+ ASSERT_EQ(1U, found_leases.size());
EXPECT_TRUE(*(found_leases[0]) == *lease);
}
Lease6Collection returned3 = lmptr_->getLeases6(*(lease3->duid_));
//verify if the returned lease mathces
- ASSERT_EQ(returned1.size(), 1);
- ASSERT_EQ(returned2.size(), 1);
- ASSERT_EQ(returned3.size(), 1);
+ ASSERT_EQ(returned1.size(), 1U);
+ ASSERT_EQ(returned2.size(), 1U);
+ ASSERT_EQ(returned3.size(), 1U);
//verify that the returned lease are same
EXPECT_TRUE(returned1[0]->addr_ == lease1->addr_);
GenericLeaseMgrTest::testUpdateLease6() {
// Get the leases to be used for the test.
vector<Lease6Ptr> leases = createLeases6();
- ASSERT_LE(3, leases.size()); // Expect to access leases 0 through 2
+ ASSERT_LE(3U, leases.size()); // Expect to access leases 0 through 2
// Add a lease to the database and check that the lease is there.
EXPECT_TRUE(lmptr_->addLease(leases[1]));
GenericLeaseMgrTest::testConcurrentUpdateLease6() {
// Get the leases to be used for the test.
vector<Lease6Ptr> leases = createLeases6();
- ASSERT_LE(3, leases.size()); // Expect to access leases 0 through 2
+ ASSERT_LE(3U, leases.size()); // Expect to access leases 0 through 2
// Add a lease to the database and check that the lease is there.
EXPECT_TRUE(lmptr_->addLease(leases[1]));
}
void
-GenericLeaseMgrTest::testVersion(int major, int minor) {
+GenericLeaseMgrTest::testVersion(uint32_t major, uint32_t minor) {
EXPECT_EQ(major, lmptr_->getVersion().first);
EXPECT_EQ(minor, lmptr_->getVersion().second);
}
// Get the leases to be used for the test.
vector<Lease4Ptr> leases = createLeases4();
// Make sure we have at least 6 leases there.
- ASSERT_GE(leases.size(), 6);
+ ASSERT_GE(leases.size(), 6U);
// Use the same current time for all leases.
time_t current_time = time(NULL);
// This matches the reverse order to which they have been added.
size_t count = 0;
for (auto const& lease : boost::adaptors::reverse(expired_leases)) {
- int index = count++;
+ size_t index = count++;
// Multiple current index by two, because only leases with even indexes
// should have been returned.
ASSERT_LE(2 * index, leases.size());
// This time leases should be returned in the non-reverse order.
count = 0;
for (auto const& lease : expired_leases) {
- int index = count++;
+ size_t index = count++;
ASSERT_LE(2 * index, leases.size());
EXPECT_EQ(leases[2 * index]->addr_, lease->addr_);
}
ASSERT_NO_THROW(lmptr_->getExpiredLeases4(expired_leases, 2));
// Make sure we have exactly 2 leases returned.
- ASSERT_EQ(2, expired_leases.size());
+ ASSERT_EQ(2U, expired_leases.size());
// Test that most expired leases have been returned.
count = 0;
for (auto const& lease : expired_leases) {
- int index = count++;
+ size_t index = count++;
ASSERT_LE(2 * index, leases.size());
EXPECT_EQ(leases[2 * index]->addr_, lease->addr_);
}
// those that have even index.
count = 0;
for (auto const& lease : expired_leases) {
- int index = count++;
+ size_t index = count++;
EXPECT_EQ(saved_expired_leases[2 * index]->addr_, lease->addr_);
}
}
// Get the leases to be used for the test.
vector<Lease6Ptr> leases = createLeases6();
// Make sure we have at least 6 leases there.
- ASSERT_GE(leases.size(), 6);
+ ASSERT_GE(leases.size(), 6U);
// Use the same current time for all leases.
time_t current_time = time(NULL);
// This matches the reverse order to which they have been added.
size_t count = 0;
for (auto const& lease : boost::adaptors::reverse(expired_leases)) {
- int index = count++;
+ size_t index = count++;
// Multiple current index by two, because only leases with even indexes
// should have been returned.
EXPECT_EQ(leases[2 * index]->addr_, lease->addr_);
// This time leases should be returned in the non-reverse order.
count = 0;
for (auto const& lease : expired_leases) {
- int index = count++;
+ size_t index = count++;
EXPECT_EQ(leases[2 * index]->addr_, lease->addr_);
}
ASSERT_NO_THROW(lmptr_->getExpiredLeases6(expired_leases, 2));
// Make sure we have exactly 2 leases returned.
- ASSERT_EQ(2, expired_leases.size());
+ ASSERT_EQ(2U, expired_leases.size());
// Test that most expired leases have been returned.
count = 0;
for (auto const& lease : expired_leases) {
- int index = count++;
+ size_t index = count++;
EXPECT_EQ(leases[2 * index]->addr_, lease->addr_);
}
// those that have even index.
count = 0;
for (auto const& lease : expired_leases) {
- int index = count++;
+ size_t index = count++;
EXPECT_EQ(saved_expired_leases[2 * index]->addr_, lease->addr_);
}
}
ASSERT_NO_THROW(lmptr_->getExpiredLeases4(expired_leases, 10));
// No lease should be returned.
- EXPECT_EQ(0, expired_leases.size());
+ EXPECT_EQ(0U, expired_leases.size());
}
void
ASSERT_NO_THROW(lmptr_->getExpiredLeases6(expired_leases, 10));
// No lease should be returned.
- EXPECT_EQ(0, expired_leases.size());
+ EXPECT_EQ(0U, expired_leases.size());
}
void
// Get the leases to be used for the test.
vector<Lease4Ptr> leases = createLeases4();
// Make sure we have at least 6 leases there.
- ASSERT_GE(leases.size(), 6);
+ ASSERT_GE(leases.size(), 6U);
time_t current_time = time(NULL);
deleted_num = lmptr_->deleteExpiredReclaimedLeases4(lease_affinity_time)
);
// No lease should have been deleted.
- EXPECT_EQ(0, deleted_num);
+ EXPECT_EQ(0U, deleted_num);
// Reopen the database. This to ensure that the leases have been deleted
// from the persistent storage.
// Get the leases to be used for the test.
vector<Lease6Ptr> leases = createLeases6();
// Make sure we have at least 6 leases there.
- ASSERT_GE(leases.size(), 6);
+ ASSERT_GE(leases.size(), 6U);
time_t current_time = time(NULL);
deleted_num = lmptr_->deleteExpiredReclaimedLeases6(lease_affinity_time)
);
// No lease should have been deleted.
- EXPECT_EQ(0, deleted_num);
+ EXPECT_EQ(0U, deleted_num);
// Reopen the database. This to ensure that the leases have been deleted
// from the persistent storage.
vector<Lease4Ptr> leases = createLeases4();
// Make sure we have at least 8 leases there.
- ASSERT_GE(leases.size(), 8);
+ ASSERT_GE(leases.size(), 8U);
// Use the same current time for all leases.
time_t current_time = time(NULL);
// This matches the reverse order to which they have been added.
size_t count = 0;
for (auto const& lease : boost::adaptors::reverse(expired_leases)) {
- int index = count++;
+ size_t index = count++;
// Multiple current index by two, because only leases with even indexes
// should have been returned.
EXPECT_EQ(leases[2 * index]->addr_, lease->addr_);
}
// LeaseMgr is supposed to return both default and declined leases
- EXPECT_NE(0, declined_state);
- EXPECT_NE(0, default_state);
+ EXPECT_NE(0U, declined_state);
+ EXPECT_NE(0U, default_state);
// Update current time for the next test.
current_time = time(NULL);
default_state = 0;
count = 0;
for (auto const& lease : expired_leases) {
- int index = count++;
+ size_t index = count++;
EXPECT_EQ(leases[2 * index]->addr_, lease->addr_);
// Count leases in default and declined states
}
// Check that both declined and default state leases were returned.
- EXPECT_NE(0, declined_state);
- EXPECT_NE(0, default_state);
+ EXPECT_NE(0U, declined_state);
+ EXPECT_NE(0U, default_state);
// Remove expired leases again.
expired_leases.clear();
ASSERT_NO_THROW(lmptr_->getExpiredLeases4(expired_leases, 2));
// Make sure we have exactly 2 leases returned.
- ASSERT_EQ(2, expired_leases.size());
+ ASSERT_EQ(2U, expired_leases.size());
// Test that most expired leases have been returned.
count = 0;
for (auto const& lease : expired_leases) {
- int index = count++;
+ size_t index = count++;
EXPECT_EQ(leases[2 * index]->addr_, lease->addr_);
}
}
vector<Lease6Ptr> leases = createLeases6();
// Make sure we have at least 8 leases there.
- ASSERT_GE(leases.size(), 8);
+ ASSERT_GE(leases.size(), 8U);
// Use the same current time for all leases.
time_t current_time = time(NULL);
// This matches the reverse order to which they have been added.
size_t count = 0;
for (auto const& lease : boost::adaptors::reverse(expired_leases)) {
- int index = count++;
+ size_t index = count++;
// Multiple current index by two, because only leases with even indexes
// should have been returned.
EXPECT_EQ(leases[2 * index]->addr_, lease->addr_);
}
// LeaseMgr is supposed to return both default and declined leases
- EXPECT_NE(0, declined_state);
- EXPECT_NE(0, default_state);
+ EXPECT_NE(0U, declined_state);
+ EXPECT_NE(0U, default_state);
// Update current time for the next test.
current_time = time(NULL);
default_state = 0;
count = 0;
for (auto const& lease : expired_leases) {
- int index = count++;
+ size_t index = count++;
EXPECT_EQ(leases[2 * index]->addr_, lease->addr_);
// Count leases in default and declined states
}
// Check that both declined and default state leases were returned.
- EXPECT_NE(0, declined_state);
- EXPECT_NE(0, default_state);
+ EXPECT_NE(0U, declined_state);
+ EXPECT_NE(0U, default_state);
// Remove expired leases again.
expired_leases.clear();
ASSERT_NO_THROW(lmptr_->getExpiredLeases6(expired_leases, 2));
// Make sure we have exactly 2 leases returned.
- ASSERT_EQ(2, expired_leases.size());
+ ASSERT_EQ(2U, expired_leases.size());
// Test that most expired leases have been returned.
count = 0;
for (auto const& lease : expired_leases) {
- int index = count++;
+ size_t index = count++;
EXPECT_EQ(leases[2 * index]->addr_, lease->addr_);
}
}
// Let's try something simple. There shouldn't be any leases in
// subnet 2. The keep deleting the leases, perhaps in a different
// order they were added.
- EXPECT_EQ(0, lmptr_->wipeLeases6(2));
- EXPECT_EQ(4, lmptr_->wipeLeases6(333));
- EXPECT_EQ(3, lmptr_->wipeLeases6(1));
- EXPECT_EQ(1, lmptr_->wipeLeases6(22));
+ EXPECT_EQ(0U, lmptr_->wipeLeases6(2));
+ EXPECT_EQ(4U, lmptr_->wipeLeases6(333));
+ EXPECT_EQ(3U, lmptr_->wipeLeases6(1));
+ EXPECT_EQ(1U, lmptr_->wipeLeases6(22));
// All the leases should be gone now. Check that that repeated
// attempt to delete them will not result in any additional removals.
- EXPECT_EQ(0, lmptr_->wipeLeases6(1));
- EXPECT_EQ(0, lmptr_->wipeLeases6(22));
- EXPECT_EQ(0, lmptr_->wipeLeases6(333));
+ EXPECT_EQ(0U, lmptr_->wipeLeases6(1));
+ EXPECT_EQ(0U, lmptr_->wipeLeases6(22));
+ EXPECT_EQ(0U, lmptr_->wipeLeases6(333));
}
void
// Let's try something simple. There shouldn't be any leases in
// subnet 2. The keep deleting the leases, perhaps in a different
// order they were added.
- EXPECT_EQ(0, lmptr_->wipeLeases4(2));
- EXPECT_EQ(4, lmptr_->wipeLeases4(333));
- EXPECT_EQ(3, lmptr_->wipeLeases4(1));
- EXPECT_EQ(1, lmptr_->wipeLeases4(22));
+ EXPECT_EQ(0U, lmptr_->wipeLeases4(2));
+ EXPECT_EQ(4U, lmptr_->wipeLeases4(333));
+ EXPECT_EQ(3U, lmptr_->wipeLeases4(1));
+ EXPECT_EQ(1U, lmptr_->wipeLeases4(22));
// All the leases should be gone now. Check that that repeated
// attempt to delete them will not result in any additional removals.
- EXPECT_EQ(0, lmptr_->wipeLeases4(1));
- EXPECT_EQ(0, lmptr_->wipeLeases4(22));
- EXPECT_EQ(0, lmptr_->wipeLeases4(333));
+ EXPECT_EQ(0U, lmptr_->wipeLeases4(1));
+ EXPECT_EQ(0U, lmptr_->wipeLeases4(22));
+ EXPECT_EQ(0U, lmptr_->wipeLeases4(333));
}
void
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(LeaseMgrFactory::haveInstance());
}
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(LeaseMgrFactory::haveInstance());
}
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_);
access = validConnectString();
access += extra;
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(LeaseMgrFactory::haveInstance());
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(LeaseMgrFactory::haveInstance());
}
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_);
sleep(1);
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(LeaseMgrFactory::haveInstance());
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(LeaseMgrFactory::haveInstance());
}
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_);
}
void
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_);
}
void
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_);
}
void
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_);
access = validConnectString();
access += extra;
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_);
sleep(1);
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_);
}
void
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_);
sleep(1);
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_);
sleep(1);
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_);
}
void
const RowSet& expected_rows) {
ASSERT_TRUE(query) << "query is null";
- int rows_matched = 0;
+ size_t rows_matched = 0;
LeaseStatsRow row;
while (query->getNextRow(row)) {
auto found_row = expected_rows.find(row);
ElementPtr ctx2 = makeContextWithClasses(classes2);
// Counts should be 0.
- EXPECT_EQ(0, lmptr_->getClassLeaseCount("water"));
- EXPECT_EQ(0, lmptr_->getClassLeaseCount("melon"));
+ EXPECT_EQ(0U, lmptr_->getClassLeaseCount("water"));
+ EXPECT_EQ(0U, lmptr_->getClassLeaseCount("melon"));
// Create a lease to add to the lease store.
vector<Lease4Ptr> leases = createLeases4();
// Add the lease to the lease store and verify class lease counts.
ASSERT_NO_THROW_LOG(lmptr_->addLease(lease));
- EXPECT_EQ(1, lmptr_->getClassLeaseCount("water"));
- EXPECT_EQ(0, lmptr_->getClassLeaseCount("melon"));
+ EXPECT_EQ(1U, lmptr_->getClassLeaseCount("water"));
+ EXPECT_EQ(0U, lmptr_->getClassLeaseCount("melon"));
// Re-fetch lease. This returns a copy of the persisted lease, which is
// what Kea logic always does. Fetches a copy. Otherwise we're changing
// Update the lease in the lease store and verify class lease counts.
ASSERT_NO_THROW_LOG(lmptr_->updateLease4(lease));
- EXPECT_EQ(0, lmptr_->getClassLeaseCount("water"));
- EXPECT_EQ(1, lmptr_->getClassLeaseCount("melon"));
+ EXPECT_EQ(0U, lmptr_->getClassLeaseCount("water"));
+ EXPECT_EQ(1U, lmptr_->getClassLeaseCount("melon"));
lease = lmptr_->getLease4(lease->addr_);
ASSERT_TRUE(lease);
// Now delete the lease from the store and verify counts.
ASSERT_NO_THROW_LOG(lmptr_->deleteLease(lease));
- EXPECT_EQ(0, lmptr_->getClassLeaseCount("water"));
- EXPECT_EQ(0, lmptr_->getClassLeaseCount("melon"));
+ EXPECT_EQ(0U, lmptr_->getClassLeaseCount("water"));
+ EXPECT_EQ(0U, lmptr_->getClassLeaseCount("melon"));
lease = lmptr_->getLease4(lease->addr_);
ASSERT_FALSE(lease);
ElementPtr ctx2 = makeContextWithClasses(classes2);
// Counts should be 0.
- EXPECT_EQ(0, lmptr_->getClassLeaseCount("water", ltype));
- EXPECT_EQ(0, lmptr_->getClassLeaseCount("melon", ltype));
+ EXPECT_EQ(0U, lmptr_->getClassLeaseCount("water", ltype));
+ EXPECT_EQ(0U, lmptr_->getClassLeaseCount("melon", ltype));
// Create a lease to add to the lease store.
vector<Lease6Ptr> leases = createLeases6();
// Add the lease to the lease store and verify class lease counts.
ASSERT_NO_THROW_LOG(lmptr_->addLease(lease));
- EXPECT_EQ(1, lmptr_->getClassLeaseCount("water", ltype));
- EXPECT_EQ(0, lmptr_->getClassLeaseCount("melon", ltype));
+ EXPECT_EQ(1U, lmptr_->getClassLeaseCount("water", ltype));
+ EXPECT_EQ(0U, lmptr_->getClassLeaseCount("melon", ltype));
// Re-fetch lease. This returns a copy of the persisted lease, which is
// what Kea logic always does. Fetches a copy. Otherwise we're changing
// Update the lease in the lease store and verify class lease counts.
ASSERT_NO_THROW_LOG(lmptr_->updateLease6(lease));
- EXPECT_EQ(0, lmptr_->getClassLeaseCount("water", ltype));
- EXPECT_EQ(1, lmptr_->getClassLeaseCount("melon", ltype));
+ EXPECT_EQ(0U, lmptr_->getClassLeaseCount("water", ltype));
+ EXPECT_EQ(1U, lmptr_->getClassLeaseCount("melon", ltype));
lease = lmptr_->getLease6(ltype, lease->addr_);
ASSERT_TRUE(lease);
// Now delete the lease from the store and verify counts.
ASSERT_NO_THROW_LOG(lmptr_->deleteLease(lease));
- EXPECT_EQ(0, lmptr_->getClassLeaseCount("water", ltype));
- EXPECT_EQ(0, lmptr_->getClassLeaseCount("melon", ltype));
+ EXPECT_EQ(0U, lmptr_->getClassLeaseCount("water", ltype));
+ EXPECT_EQ(0U, lmptr_->getClassLeaseCount("melon", ltype));
lease = lmptr_->getLease6(ltype, lease->addr_);
ASSERT_FALSE(lease);
EXPECT_TRUE(lmptr_->addLease(lease));
// Make sure that the callback has been invoked.
- ASSERT_EQ(1, logs_.size());
+ ASSERT_EQ(1U, logs_.size());
// This flag should be false for the Memfile backend and true
// for the SQL backends.
EXPECT_TRUE(lmptr_->addLease(lease));
// Make sure that the callback has been invoked.
- ASSERT_EQ(1, logs_.size());
+ ASSERT_EQ(1U, logs_.size());
// This flag should be false for the Memfile backend and true
// for the SQL backends.
EXPECT_TRUE(lmptr_->addLease(lease));
// Make sure that the callback has been invoked.
- ASSERT_EQ(1, logs_.size());
+ ASSERT_EQ(1U, logs_.size());
// This flag should be false for the Memfile backend and true
// for the SQL backends.
lmptr_->updateLease4(lease);
// Make sure that the callback has been invoked.
- ASSERT_EQ(1, logs_.size());
+ ASSERT_EQ(1U, logs_.size());
// This flag should be false for the Memfile backend and true
// for the SQL backends.
lmptr_->updateLease6(lease);
// Make sure that the callback has been invoked.
- ASSERT_EQ(1, logs_.size());
+ ASSERT_EQ(1U, logs_.size());
// This flag should be false for the Memfile backend and true
// for the SQL backends.
lmptr_->updateLease6(lease);
// Make sure that the callback has been invoked.
- ASSERT_EQ(1, logs_.size());
+ ASSERT_EQ(1U, logs_.size());
// This flag should be false for the Memfile backend and true
// for the SQL backends.
lmptr_->deleteLease(lease);
// Make sure that the callback has been invoked.
- ASSERT_EQ(1, logs_.size());
+ ASSERT_EQ(1U, logs_.size());
// This flag should be false for the Memfile backend and true
// for the SQL backends.
lmptr_->deleteLease(lease);
// Make sure that the callback has been invoked.
- ASSERT_EQ(1, logs_.size());
+ ASSERT_EQ(1U, logs_.size());
// This flag should be false for the Memfile backend and true
// for the SQL backends.
lmptr_->deleteLease(lease);
// Make sure that the callback has been invoked.
- ASSERT_EQ(1, logs_.size());
+ ASSERT_EQ(1U, logs_.size());
// This flag should be false for the Memfile backend and true
// for the SQL backends.
EXPECT_TRUE(lmptr_->addLease(lease));
// Make sure that the callback has been invoked.
- EXPECT_EQ(1, logs_.size());
+ EXPECT_EQ(1U, logs_.size());
}
void
picked.emplace(picked_address);
}
- ASSERT_EQ(picked.size(), 4);
+ ASSERT_EQ(picked.size(), 4U);
}
}
picked.emplace(picked_address);
}
- ASSERT_EQ(picked.size(), 4);
+ ASSERT_EQ(picked.size(), 4U);
}
}
// Fetching all pools should find none.
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4GetAll());
- ASSERT_EQ(0, pool_infos->size());
+ ASSERT_EQ(0U, pool_infos->size());
auto test_start = boost::posix_time::second_clock::local_time();
// Fetching all pools should find all three.
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4GetAll());
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(3, pool_infos->size());
+ ASSERT_EQ(3U, pool_infos->size());
// Should get them back ordered by subnet and start address.
checkPoolInfos(*(*pool_infos)[0], *test_pools[2], __LINE__);
pool_infos.reset();
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(1));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(2, pool_infos->size());
+ ASSERT_EQ(2U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pools[2], __LINE__);
checkPoolInfos(*(*pool_infos)[1], *test_pools[0], __LINE__);
pool_infos.reset();
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(2));
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
pool_infos.reset();
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(99));
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();
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(IOAddress("1.2.3.4"),
IOAddress("1.2.3.4")));
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();
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(IOAddress("192.0.0.0"),
IOAddress("192.0.4.0")));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(3, pool_infos->size());
+ ASSERT_EQ(3U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pools[2], __LINE__);
checkPoolInfos(*(*pool_infos)[1], *test_pools[0], __LINE__);
checkPoolInfos(*(*pool_infos)[2], *test_pools[1], __LINE__);
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(test_pool->start_address_,
test_pool->end_address_));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
+ ASSERT_EQ(1U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pool, __LINE__);
}
auto end_address = IOAddress::increase(test_pool->end_address_);
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(start_address, end_address));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
+ ASSERT_EQ(1U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pool, __LINE__);
}
auto end_address = IOAddress(test_pool->end_address_.toUint32() - 1);
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(start_address, end_address));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
+ ASSERT_EQ(1U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pool, __LINE__);
}
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(test_pool->start_address_,
test_pool->end_address_));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(0, pool_infos->size());
+ ASSERT_EQ(0U, pool_infos->size());
}
}
// Fetching all pools should find none.
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6GetAll());
- ASSERT_EQ(0, pool_infos->size());
+ ASSERT_EQ(0U, pool_infos->size());
auto test_start = boost::posix_time::second_clock::local_time();
// Fetching all pools should find all three.
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6GetAll());
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(3, pool_infos->size());
+ ASSERT_EQ(3U, pool_infos->size());
// Should get them back ordered by subnet and start address.
checkPoolInfos(*(*pool_infos)[0], *test_pools[2], __LINE__);
pool_infos.reset();
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(1));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(2, pool_infos->size());
+ ASSERT_EQ(2U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pools[2], __LINE__);
checkPoolInfos(*(*pool_infos)[1], *test_pools[0], __LINE__);
pool_infos.reset();
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(2));
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
pool_infos.reset();
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(99));
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();
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(IOAddress("2001::1"),
IOAddress("2001::2")));
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();
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(IOAddress("3001::"),
IOAddress("3001::FF")));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(3, pool_infos->size());
+ ASSERT_EQ(3U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pools[2], __LINE__);
checkPoolInfos(*(*pool_infos)[1], *test_pools[0], __LINE__);
checkPoolInfos(*(*pool_infos)[2], *test_pools[1], __LINE__);
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(start_address.toText(),
end_address.toText()));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size()) << start_address.toText() << " - " << end_address.toText();
+ ASSERT_EQ(1U, pool_infos->size()) << start_address.toText() << " - " << end_address.toText();
checkPoolInfos(*(*pool_infos)[0], *test_pool, __LINE__);
}
auto end_address = IOAddress::increase(test_pool->end_address_);
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(start_address, end_address));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
+ ASSERT_EQ(1U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pool, __LINE__);
}
auto end_address = IOAddress::subtract(test_pool->end_address_, one);
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(start_address, end_address));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
+ ASSERT_EQ(1U, pool_infos->size());
checkPoolInfos(*(*pool_infos)[0], *test_pool, __LINE__);
}
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(test_pool->start_address_,
test_pool->end_address_));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(0, pool_infos->size());
+ ASSERT_EQ(0U, pool_infos->size());
}
}
// Fetching all pools should find none.
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4GetAll());
- ASSERT_EQ(0, pool_infos->size());
+ ASSERT_EQ(0U, pool_infos->size());
auto test_start = boost::posix_time::second_clock::local_time();
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(test_pools[1]->start_address_,
test_pools[1]->end_address_));
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__);
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(test_pools[1]->start_address_,
test_pools[1]->end_address_));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(2, pool_infos->size());
+ ASSERT_EQ(2U, pool_infos->size());
// Deleting the middle pool affects free_lease count for the other two.
// Users would need to fix them by calling create with recreate = true.
test_pools[0]->free_leases_ = 5;
// Fetching all pools should find none.
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6GetAll());
- ASSERT_EQ(0, pool_infos->size());
+ ASSERT_EQ(0U, pool_infos->size());
auto test_start = boost::posix_time::second_clock::local_time();
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(test_pools[1]->start_address_,
test_pools[1]->end_address_));
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__);
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(test_pools[1]->start_address_,
test_pools[1]->end_address_));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(2, pool_infos->size());
+ ASSERT_EQ(2U, pool_infos->size());
// Deleting the middle pool affects free_lease count for the other two.
// Users would need to fix them by calling create with recreate = true.
test_pools[0]->free_leases_ = 5;
SflqPoolInfoCollectionPtr pool_infos;
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(start_address, end_address));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
- ASSERT_EQ(65536, (*pool_infos)[0]->free_leases_);
+ ASSERT_EQ(1U, pool_infos->size());
+ ASSERT_EQ(65536U, (*pool_infos)[0]->free_leases_);
// Now let's do concurrent recreates.
threads.clear();
// Verify the pool and free leases are correct.
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool4Get(start_address, end_address));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
- ASSERT_EQ(65536, (*pool_infos)[0]->free_leases_);
+ ASSERT_EQ(1U, pool_infos->size());
+ ASSERT_EQ(65536U, (*pool_infos)[0]->free_leases_);
}
SflqPoolInfoCollectionPtr pool_infos;
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(start_address, end_address));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
- ASSERT_EQ(65536, (*pool_infos)[0]->free_leases_);
+ ASSERT_EQ(1U, pool_infos->size());
+ ASSERT_EQ(65536U, (*pool_infos)[0]->free_leases_);
ASSERT_EQ(Lease::TYPE_PD, (*pool_infos)[0]->lease_type_);
// Now let's do concurrent recreates.
// Verify the pool and free leases are correct.
ASSERT_NO_THROW_LOG(pool_infos = lmptr_->sflqPool6Get(start_address, end_address));
ASSERT_TRUE(pool_infos);
- ASSERT_EQ(1, pool_infos->size());
- ASSERT_EQ(65536, (*pool_infos)[0]->free_leases_);
+ ASSERT_EQ(1U, pool_infos->size());
+ ASSERT_EQ(65536U, (*pool_infos)[0]->free_leases_);
ASSERT_EQ(Lease::TYPE_PD, (*pool_infos)[0]->lease_type_);
// Now let's try creates with a different delegated_len.
/// @brief Verifies that the backend reports expected version numbers.
/// @param major Expected major version to be reported.
/// @param minor Expected minor version to be reported.
- void testVersion(int major, int minor);
+ void testVersion(uint32_t major, uint32_t minor);
/// @brief Checks that the expired DHCPv4 leases can be retrieved.
///
projects / thirdparty / kea.git / commitdiff
