BIND 10 trac3171, updated. cbda6551031656b6d03f7d5578d0389c562a4238 [3171] Several extra address test adapted for PD allocation testing
BIND 10 source code commits
bind10-changes at lists.isc.org
Fri Sep 20 16:22:14 UTC 2013
The branch, trac3171 has been updated
via cbda6551031656b6d03f7d5578d0389c562a4238 (commit)
from a282ac7153171ac4445c6b6eb2220937d097fd74 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit cbda6551031656b6d03f7d5578d0389c562a4238
Author: Tomek Mrugalski <tomasz at isc.org>
Date: Fri Sep 20 18:21:54 2013 +0200
[3171] Several extra address test adapted for PD allocation testing
-----------------------------------------------------------------------
Summary of changes:
src/lib/dhcpsrv/tests/alloc_engine_unittest.cc | 273 ++++++++++++------------
1 file changed, 138 insertions(+), 135 deletions(-)
-----------------------------------------------------------------------
diff --git a/src/lib/dhcpsrv/tests/alloc_engine_unittest.cc b/src/lib/dhcpsrv/tests/alloc_engine_unittest.cc
index 9204f2e..64a2865 100644
--- a/src/lib/dhcpsrv/tests/alloc_engine_unittest.cc
+++ b/src/lib/dhcpsrv/tests/alloc_engine_unittest.cc
@@ -93,10 +93,16 @@ public:
// instantiate cfg_mgr
CfgMgr& cfg_mgr = CfgMgr::instance();
+ // Configure normal address pool
subnet_ = Subnet6Ptr(new Subnet6(IOAddress("2001:db8:1::"), 56, 1, 2, 3, 4));
pool_ = Pool6Ptr(new Pool6(Lease::TYPE_NA, IOAddress("2001:db8:1::10"),
IOAddress("2001:db8:1::20")));
subnet_->addPool(pool_);
+
+ // Configure PD pool
+ pd_pool_ = Pool6Ptr(new Pool6(Lease::TYPE_PD, IOAddress("2001:db8:1::"), 56, 64));
+ subnet_->addPool(pd_pool_);
+
cfg_mgr.addSubnet6(subnet_);
factory_.create("type=memfile");
@@ -165,6 +171,109 @@ public:
.toText());
}
+ /// checks if the simple allocation can succeed
+ ///
+ /// The type of lease is determined by pool type (pool->getType()
+ ///
+ /// @param pool pool from which the lease will be allocated from
+ /// @param hint address to be used as a hint
+ /// @param fake true - this is fake allocation (SOLICIT)
+ /// @return allocated lease (or NULL)
+ Lease6Ptr simpleAlloc6Test(const Pool6Ptr& pool, const IOAddress& hint,
+ bool fake) {
+ Lease::Type type = pool->getType();
+ uint8_t expected_len = pool->getLength();
+
+ boost::scoped_ptr<AllocEngine> engine;
+ EXPECT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE,
+ 100)));
+ // We can't use ASSERT macros in non-void methods
+ EXPECT_TRUE(engine);
+ if (!engine) {
+ return (Lease6Ptr());
+ }
+
+ Lease6Ptr lease;
+ EXPECT_NO_THROW(lease = expectOneLease(engine->allocateAddress6(subnet_,
+ duid_, iaid_, hint, type, false, false,
+ "", fake, CalloutHandlePtr())));
+
+ // Check that we got a lease
+ EXPECT_TRUE(lease);
+ if (!lease) {
+ return (Lease6Ptr());
+ }
+
+ // Do all checks on the lease
+ checkLease6(lease, type, expected_len);
+
+ // Check that the lease is indeed in LeaseMgr
+ Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(type,
+ lease->addr_);
+ if (!fake) {
+ // This is a real (REQUEST) allocation, the lease must be in the DB
+ EXPECT_TRUE(from_mgr);
+ if (!from_mgr) {
+ return (Lease6Ptr());
+ }
+
+ // Now check that the lease in LeaseMgr has the same parameters
+ detailCompareLease(lease, from_mgr);
+ } else {
+ // This is a fake (SOLICIT) allocation, the lease must not be in DB
+ EXPECT_FALSE(from_mgr);
+ if (from_mgr) {
+ return (Lease6Ptr());
+ }
+ }
+
+ return (lease);
+ }
+
+ void allocWithUsedHintTest(Lease::Type type, IOAddress used_addr,
+ IOAddress requested, uint8_t expected_pd_len) {
+ boost::scoped_ptr<AllocEngine> engine;
+ ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE,
+ 100)));
+ ASSERT_TRUE(engine);
+
+ // Let's create a lease and put it in the LeaseMgr
+ DuidPtr duid2 = boost::shared_ptr<DUID>(new DUID(vector<uint8_t>(8, 0xff)));
+ time_t now = time(NULL);
+ Lease6Ptr used(new Lease6(type, used_addr,
+ duid2, 1, 2, 3, 4, now, subnet_->getID()));
+ ASSERT_TRUE(LeaseMgrFactory::instance().addLease(used));
+
+ // Another client comes in and request an address that is in pool, but
+ // unfortunately it is used already. The same address must not be allocated
+ // twice.
+ Lease6Ptr lease;
+ EXPECT_NO_THROW(lease = expectOneLease(engine->allocateAddress6(subnet_,
+ duid_, iaid_, requested, type, false, false, "", false,
+ CalloutHandlePtr())));
+
+ // Check that we got a lease
+ ASSERT_TRUE(lease);
+
+ // Allocated address must be different
+ EXPECT_NE(used_addr.toText(), lease->addr_.toText());
+
+ // We should NOT get what we asked for, because it is used already
+ EXPECT_NE(requested.toText(), lease->addr_.toText());
+
+ // Do all checks on the lease
+ checkLease6(lease, type, expected_pd_len);
+
+ // Check that the lease is indeed in LeaseMgr
+ Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
+ lease->addr_);
+ ASSERT_TRUE(from_mgr);
+
+ // Now check that the lease in LeaseMgr has the same parameters
+ detailCompareLease(lease, from_mgr);
+ }
+
+
virtual ~AllocEngine6Test() {
factory_.destroy();
}
@@ -172,7 +281,8 @@ public:
DuidPtr duid_; ///< client-identifier (value used in tests)
uint32_t iaid_; ///< IA identifier (value used in tests)
Subnet6Ptr subnet_; ///< subnet6 (used in tests)
- Pool6Ptr pool_; ///< pool belonging to subnet_
+ Pool6Ptr pool_; ///< NA pool belonging to subnet_
+ Pool6Ptr pd_pool_; ///< PD pool belonging to subnet_
LeaseMgrFactory factory_; ///< pointer to LeaseMgr factory
};
@@ -267,161 +377,54 @@ TEST_F(AllocEngine6Test, constructor) {
EXPECT_THROW(x->getAllocator(Lease::TYPE_V4), BadValue);
}
-// This test checks if the simple allocation can succeed
+// This test checks if the simple allocation (REQUEST) can succeed
TEST_F(AllocEngine6Test, simpleAlloc6) {
- boost::scoped_ptr<AllocEngine> engine;
- ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, 100)));
- ASSERT_TRUE(engine);
-
- Lease6Ptr lease;
- EXPECT_NO_THROW(lease = expectOneLease(engine->allocateAddress6(subnet_,
- duid_, iaid_, IOAddress("::"), Lease::TYPE_NA, false, false,
- "", false, CalloutHandlePtr())));
-
- // Check that we got a lease
- ASSERT_TRUE(lease);
-
- // Do all checks on the lease
- checkLease6(lease, Lease::TYPE_NA, 128);
-
- // Check that the lease is indeed in LeaseMgr
- Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
- lease->addr_);
- ASSERT_TRUE(from_mgr);
-
- // Now check that the lease in LeaseMgr has the same parameters
- detailCompareLease(lease, from_mgr);
+ simpleAlloc6Test(pool_, IOAddress("::"), false);
}
-
-// This test checks if the simple PD allocation can succeed
+// This test checks if the simple PD allocation (REQUEST) can succeed
TEST_F(AllocEngine6Test, pdSimpleAlloc6) {
- boost::scoped_ptr<AllocEngine> engine;
- ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, 100)));
- ASSERT_TRUE(engine);
-
- subnet_->delPools(Lease::TYPE_NA);
-
- Pool6Ptr pd_pool(new Pool6(Lease::TYPE_PD, IOAddress("2001:db8:1::"), 56, 64));
- subnet_->addPool(pd_pool);
-
- Lease6Ptr lease;
- EXPECT_NO_THROW(lease = expectOneLease(engine->allocateAddress6(subnet_,
- duid_, iaid_, IOAddress("::"), Lease::TYPE_PD, false, false,
- "", false, CalloutHandlePtr())));
-
- // Check that we got a lease
- ASSERT_TRUE(lease);
-
- EXPECT_EQ(Lease::TYPE_PD, lease->type_);
-
- // Do all checks on the PD lease
- checkLease6(lease, Lease::TYPE_PD, pd_pool->getLength());
-
- // Check that the lease is indeed in LeaseMgr
- Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
- lease->addr_);
- ASSERT_TRUE(from_mgr);
-
- // Now check that the lease in LeaseMgr has the same parameters
- detailCompareLease(lease, from_mgr);
+ simpleAlloc6Test(pd_pool_, IOAddress("::"), false);
}
// This test checks if the fake allocation (for SOLICIT) can succeed
TEST_F(AllocEngine6Test, fakeAlloc6) {
- boost::scoped_ptr<AllocEngine> engine;
- ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, 100)));
- ASSERT_TRUE(engine);
-
- Lease6Ptr lease;
- EXPECT_NO_THROW(lease = expectOneLease(engine->allocateAddress6(subnet_,
- duid_, iaid_, IOAddress("::"), Lease::TYPE_NA, false, false,
- "", true, CalloutHandlePtr())));
-
- // Check that we got a lease
- ASSERT_TRUE(lease);
- // Do all checks on the lease
- checkLease6(lease, Lease::TYPE_NA, 128);
-
- // Check that the lease is NOT in LeaseMgr
- Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
- lease->addr_);
- ASSERT_FALSE(from_mgr);
+ simpleAlloc6Test(pool_, IOAddress("::"), true);
}
+// This test checks if the fake PD allocation (for SOLICIT) can succeed
+TEST_F(AllocEngine6Test, pdFakeAlloc6) {
+ simpleAlloc6Test(pd_pool_, IOAddress("::"), true);
+};
+
// This test checks if the allocation with a hint that is valid (in range,
// in pool and free) can succeed
TEST_F(AllocEngine6Test, allocWithValidHint6) {
- boost::scoped_ptr<AllocEngine> engine;
- ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, 100)));
- ASSERT_TRUE(engine);
- Lease6Ptr lease;
- EXPECT_NO_THROW(lease = expectOneLease(engine->allocateAddress6(subnet_,
- duid_, iaid_, IOAddress("2001:db8:1::15"),
- Lease::TYPE_NA, false, false, "", false,
- CalloutHandlePtr())));
-
- // Check that we got a lease
- ASSERT_TRUE(lease);
+ Lease6Ptr lease = simpleAlloc6Test(pool_, IOAddress("2001:db8:1::15"),
+ false);
// We should get what we asked for
EXPECT_EQ(lease->addr_.toText(), "2001:db8:1::15");
-
- // Do all checks on the lease
- checkLease6(lease, Lease::TYPE_NA, 128);
-
- // Check that the lease is indeed in LeaseMgr
- Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
- lease->addr_);
- ASSERT_TRUE(from_mgr);
-
- // Now check that the lease in LeaseMgr has the same parameters
- detailCompareLease(lease, from_mgr);
}
-// This test checks if the allocation with a hint that is in range,
-// in pool, but is currently used) can succeed
+// This test checks if the address allocation with a hint that is in range,
+// in pool, but is currently used, can succeed
TEST_F(AllocEngine6Test, allocWithUsedHint6) {
- boost::scoped_ptr<AllocEngine> engine;
- ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, 100)));
- ASSERT_TRUE(engine);
-
- // Let's create a lease and put it in the LeaseMgr
- DuidPtr duid2 = boost::shared_ptr<DUID>(new DUID(vector<uint8_t>(8, 0xff)));
- time_t now = time(NULL);
- Lease6Ptr used(new Lease6(Lease::TYPE_NA, IOAddress("2001:db8:1::1f"),
- duid2, 1, 2, 3, 4, now, subnet_->getID()));
- ASSERT_TRUE(LeaseMgrFactory::instance().addLease(used));
-
- // Another client comes in and request an address that is in pool, but
- // unfortunately it is used already. The same address must not be allocated
- // twice.
- Lease6Ptr lease;
- EXPECT_NO_THROW(lease = expectOneLease(engine->allocateAddress6(subnet_,
- duid_, iaid_, IOAddress("2001:db8:1::1f"), Lease::TYPE_NA,
- false, false, "", false, CalloutHandlePtr())));
-
- // Check that we got a lease
- ASSERT_TRUE(lease);
-
- // Allocated address must be different
- EXPECT_TRUE(used->addr_.toText() != lease->addr_.toText());
-
- // We should NOT get what we asked for, because it is used already
- EXPECT_TRUE(lease->addr_.toText() != "2001:db8:1::1f");
-
- // Do all checks on the lease
- checkLease6(lease, Lease::TYPE_NA, 128);
-
- // Check that the lease is indeed in LeaseMgr
- Lease6Ptr from_mgr = LeaseMgrFactory::instance().getLease6(lease->type_,
- lease->addr_);
- ASSERT_TRUE(from_mgr);
+ allocWithUsedHintTest(Lease::TYPE_NA,
+ IOAddress("2001:db8:1::1f"), // allocate this as used
+ IOAddress("2001:db8:1::1f"), // request this addr
+ 128);
+}
- // Now check that the lease in LeaseMgr has the same parameters
- detailCompareLease(lease, from_mgr);
+// This test checks if the PD allocation with a hint that is in range,
+// in pool, but is currently used, can succeed
+TEST_F(AllocEngine6Test, pdAllocWithUsedHint6) {
+ allocWithUsedHintTest(Lease::TYPE_PD,
+ IOAddress("2001:db8:1::"), // allocate this prefix as used
+ IOAddress("2001:db8:1::"), // request this prefix
+ 64);
}
// This test checks if the allocation with a hint that is out the blue
@@ -679,7 +682,7 @@ TEST_F(AllocEngine6Test, IterativeAllocator_manyPools6) {
// One way to easily verify that the iterative allocator really works is
// to uncomment the following line and observe its output that it
- // covers all defined subnets.
+ // covers all defined pools.
// cout << candidate.toText() << endl;
if (generated_addrs.find(candidate) == generated_addrs.end()) {
More information about the bind10-changes
mailing list