[master] Merge branch 'trac3359' (shared unit-tests for all DHCP backends)

src/lib/dhcpsrv/tests/Makefile.am

@@ -61,6 +61,7 @@ libdhcpsrv_unittests_SOURCES += dbaccess_parser_unittest.cc
 libdhcpsrv_unittests_SOURCES += lease_unittest.cc
 libdhcpsrv_unittests_SOURCES += lease_mgr_factory_unittest.cc
 libdhcpsrv_unittests_SOURCES += lease_mgr_unittest.cc
+libdhcpsrv_unittests_SOURCES += generic_lease_mgr_unittest.cc
 libdhcpsrv_unittests_SOURCES += memfile_lease_mgr_unittest.cc
 libdhcpsrv_unittests_SOURCES += dhcp_parsers_unittest.cc
 if HAVE_MYSQL

src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.h

@@ -0,0 +1,249 @@
+// Copyright (C) 2014 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef GENERIC_LEASE_MGR_UNITTEST_H
+#define GENERIC_LEASE_MGR_UNITTEST_H
+
+#include <dhcpsrv/lease_mgr.h>
+#include <gtest/gtest.h>
+#include <vector>
+
+namespace isc {
+namespace dhcp {
+namespace test {
+
+/// @brief Test Fixture class with utility functions for LeaseMgr backends
+///
+/// It contains utility functions, like dummy lease creation.
+/// All concrete LeaseMgr test classes should be derived from it.
+class GenericLeaseMgrTest : public ::testing::Test {
+public:
+
+    /// @brief Default constructor.
+    GenericLeaseMgrTest();
+
+    /// @brief Virtual destructor.
+    virtual ~GenericLeaseMgrTest();
+
+    /// @brief Reopen the database
+    ///
+    /// Closes the database and re-opens it. It must be implemented
+    /// in derived classes.
+    virtual void reopen() = 0;
+
+    /// @brief Initialize Lease4 Fields
+    ///
+    /// Returns a pointer to a Lease4 structure.  Different values are put into
+    /// the lease according to the address passed.
+    ///
+    /// This is just a convenience function for the test methods.
+    ///
+    /// @param address Address to use for the initialization
+    ///
+    /// @return Lease4Ptr.  This will not point to anything if the
+    ///         initialization failed (e.g. unknown address).
+    Lease4Ptr initializeLease4(std::string address);
+
+    /// @brief Initialize Lease6 Fields
+    ///
+    /// Returns a pointer to a Lease6 structure.  Different values are put into
+    /// the lease according to the address passed.
+    ///
+    /// This is just a convenience function for the test methods.
+    ///
+    /// @param address Address to use for the initialization
+    ///
+    /// @return Lease6Ptr.  This will not point to anything if the initialization
+    ///         failed (e.g. unknown address).
+    Lease6Ptr initializeLease6(std::string address);
+
+    /// @brief Check Leases present and different
+    ///
+    /// Checks a vector of lease pointers and ensures that all the leases
+    /// they point to are present and different.  If not, a GTest assertion
+    /// will fail.
+    ///
+    /// @param leases Vector of pointers to leases
+    /// @tparam Type of the leases held in the vector: @c Lease4 or
+    /// @c Lease6.
+    template <typename T>
+    void checkLeasesDifferent(const std::vector<T>& leases) const;
+
+    /// @brief Creates leases for the test
+    ///
+    /// Creates all leases for the test and checks that they are different.
+    ///
+    /// @return vector<Lease4Ptr> Vector of pointers to leases
+    std::vector<Lease4Ptr> createLeases4();
+
+    /// @brief Creates leases for the test
+    ///
+    /// Creates all leases for the test and checks that they are different.
+    ///
+    /// @return vector<Lease6Ptr> Vector of pointers to leases
+    std::vector<Lease6Ptr> createLeases6();
+
+    /// @brief checks that addLease, getLease4(addr) and deleteLease() works
+    void testBasicLease4();
+
+    /// @brief Test lease retrieval using client id.
+    void testGetLease4ClientId();
+
+    /// @brief Test lease retrieval when leases with NULL client id are present.
+    void testGetLease4NullClientId();
+
+    /// @brief Test lease retrieval using HW address.
+    void testGetLease4HWAddr1();
+
+    /// @brief Check GetLease4 methods - access by Hardware Address
+    ///
+    /// Adds leases to the database and checks that they can be accessed using
+    /// HWAddr information.
+    void testGetLease4HWAddr2();
+
+    /// @brief Test lease retrieval using client id, HW address and subnet id.
+    void testGetLease4ClientIdHWAddrSubnetId();
+
+    // @brief Get lease4 by hardware address (2)
+    //
+    // Check that the system can cope with getting a hardware address of
+    // any size.
+    void testGetLease4HWAddrSize();
+
+    /// @brief Check GetLease4 methods - access by Hardware Address & Subnet ID
+    ///
+    /// Adds leases to the database and checks that they can be accessed via
+    /// a combination of hardware address and subnet ID
+    void testGetLease4HWAddrSubnetId();
+
+    /// @brief Get lease4 by hardware address and subnet ID (2)
+    ///
+    /// Check that the system can cope with getting a hardware address of
+    /// any size.
+    void testGetLease4HWAddrSubnetIdSize();
+
+    /// @brief Check GetLease4 methods - access by Client ID
+    ///
+    /// Adds leases to the database and checks that they can be accessed via
+    /// the Client ID.
+    void testGetLease4ClientId2();
+
+    /// @brief Get Lease4 by client ID (2)
+    ///
+    /// Check that the system can cope with a client ID of any size.
+    void testGetLease4ClientIdSize();
+
+    /// @brief Check GetLease4 methods - access by Client ID & Subnet ID
+    ///
+    /// Adds leases to the database and checks that they can be accessed via
+    /// a combination of client and subnet IDs.
+    void testGetLease4ClientIdSubnetId();
+
+    /// @brief Basic Lease4 Checks
+    ///
+    /// Checks that the addLease, getLease4(by address), getLease4(hwaddr,subnet_id),
+    /// updateLease4() and deleteLease (IPv4 address) can handle NULL client-id.
+    /// (client-id is optional and may not be present)
+    ///
+    /// @todo: check if it does overlap with @ref testGetLease4NullClientId()
+    void testLease4NullClientId();
+
+    /// @brief Basic Lease6 Checks
+    ///
+    /// Checks that the addLease, getLease6 (by address) and deleteLease (with an
+    /// IPv6 address) works.
+    void testBasicLease6();
+
+    /// @brief Test that IPv6 lease can be added, retrieved and deleted.
+    ///
+    /// This method checks basic IPv6 lease operations. There's check_t1_t2
+    /// parameter that controls whether the backend supports storing T1, T2
+    /// parameters. memfile supports it, while MySQL doesn't. If T1,T2
+    /// storage is not supported, the expected values are 0.
+    ///
+    /// @param check_t1_t2 controls whether T1,T2 timers should be checked
+    void testAddGetDelete6(bool check_t1_t2);
+
+    /// @brief Check GetLease6 methods - access by DUID/IAID
+    ///
+    /// Adds leases to the database and checks that they can be accessed via
+    /// a combination of DUID and IAID.
+    void testGetLeases6DuidIaid();
+
+    /// @brief Check that the system can cope with a DUID of allowed size.
+    void testGetLeases6DuidSize();
+
+    /// @brief Check that getLease6 methods discriminate by lease type.
+    ///
+    /// Adds six leases, two per lease type all with the same duid and iad but
+    /// with alternating subnet_ids.
+    /// It then verifies that all of getLeases6() method variants correctly
+    /// discriminate between the leases based on lease type alone.
+    void testLease6LeaseTypeCheck();
+
+    /// @brief Check GetLease6 methods - access by DUID/IAID/SubnetID
+    ///
+    /// Adds leases to the database and checks that they can be accessed via
+    /// a combination of DIUID and IAID.
+    void testGetLease6DuidIaidSubnetId();
+
+    /// @brief Checks that getLease6() works with different DUID sizes
+    void testGetLease6DuidIaidSubnetIdSize();
+
+    /// @brief Verify that too long hostname for Lease4 is not accepted.
+    ///
+    /// Checks that the it is not possible to create a lease when the hostname
+    /// length exceeds 255 characters.
+    void testLease4InvalidHostname();
+
+    /// @brief Verify that too long hostname for Lease6 is not accepted.
+    ///
+    /// Checks that the it is not possible to create a lease when the hostname
+    /// length exceeds 255 characters.
+    void testLease6InvalidHostname();
+
+    /// @brief Lease4 update test
+    ///
+    /// Checks that the code is able to update an IPv4 lease in the database.
+    void testUpdateLease4();
+
+    /// @brief Lease6 update test
+    ///
+    /// Checks that the code is able to update an IPv6 lease in the database.
+    void testUpdateLease6();
+
+    /// @brief String forms of IPv4 addresses
+    std::vector<std::string>  straddress4_;
+
+    /// @brief IOAddress forms of IPv4 addresses
+    std::vector<isc::asiolink::IOAddress> ioaddress4_;
+
+    /// @brief String forms of IPv6 addresses
+    std::vector<std::string>  straddress6_;
+
+    /// @brief Types of IPv6 Leases
+    std::vector<Lease::Type> leasetype6_;
+
+    /// @brief IOAddress forms of IPv6 addresses
+    std::vector<isc::asiolink::IOAddress> ioaddress6_;
+
+    /// @brief Pointer to the lease manager
+    LeaseMgr* lmptr_;
+};
+
+}; // namespace test
+}; // namespace dhcp
+}; // namespace isc
+
+#endif

src/lib/dhcpsrv/tests/lease_mgr_unittest.cc

@@ -18,6 +18,7 @@
 #include <dhcpsrv/lease_mgr.h>
 #include <dhcpsrv/memfile_lease_mgr.h>
 #include <dhcpsrv/tests/test_utils.h>
+#include <dhcpsrv/tests/generic_lease_mgr_unittest.h>
 
 #include <gtest/gtest.h>
 
@@ -247,6 +248,14 @@ class LeaseMgrTest : public GenericLeaseMgrTest {
 public:
     LeaseMgrTest() {
     }
+
+    /// @brief Reopen the database
+    ///
+    /// No-op implementation. We need to provide concrete implementation,
+    /// as this is a pure virtual method in GenericLeaseMgrTest.
+    virtual void reopen() {
+    }
+
 };
 
 namespace {

src/lib/dhcpsrv/tests/memfile_lease_mgr_unittest.cc

@@ -19,6 +19,7 @@
 #include <dhcpsrv/lease_mgr.h>
 #include <dhcpsrv/memfile_lease_mgr.h>
 #include <dhcpsrv/tests/test_utils.h>
+#include <dhcpsrv/tests/generic_lease_mgr_unittest.h>
 #include <gtest/gtest.h>
 
 #include <iostream>
@@ -34,13 +35,25 @@ namespace {
 // empty class for now, but may be extended once Addr6 becomes bigger
 class MemfileLeaseMgrTest : public GenericLeaseMgrTest {
 public:
+
+    /// @brief memfile lease mgr test constructor
+    ///
+    /// Creates memfile and stores it in lmptr_ pointer
     MemfileLeaseMgrTest() {
         const LeaseMgr::ParameterMap pmap;
         lmptr_ = new Memfile_LeaseMgr(pmap);
     }
 
+    virtual void reopen() {
+        /// @todo: write lease to disk, flush, read file from disk
+    }
+
+    /// @brief destructor
+    ///
+    /// destroys lease manager backend.
     virtual ~MemfileLeaseMgrTest() {
         delete lmptr_;
+        lmptr_ = 0;
     }
 
 };
@@ -57,113 +70,169 @@ TEST_F(MemfileLeaseMgrTest, constructor) {
 
 // Checks if the getType() and getName() methods both return "memfile".
 TEST_F(MemfileLeaseMgrTest, getTypeAndName) {
-    const LeaseMgr::ParameterMap pmap;  // Empty parameter map
-    boost::scoped_ptr<Memfile_LeaseMgr> lease_mgr(new Memfile_LeaseMgr(pmap));
-
-    EXPECT_EQ(std::string("memfile"), lease_mgr->getType());
-    EXPECT_EQ(std::string("memory"), lease_mgr->getName());
+    EXPECT_EQ(std::string("memfile"), lmptr_->getType());
+    EXPECT_EQ(std::string("memory"),  lmptr_->getName());
 }
 
 // Checks that adding/getting/deleting a Lease6 object works.
 TEST_F(MemfileLeaseMgrTest, addGetDelete6) {
-    const LeaseMgr::ParameterMap pmap;  // Empty parameter map
-    boost::scoped_ptr<LeaseMgr> lease_mgr(new Memfile_LeaseMgr(pmap));
-
-    IOAddress addr("2001:db8:1::456");
+    testAddGetDelete6(true); // true - check T1,T2 values
+    // memfile is able to preserve those values, but some other
+    // backends can't do that.
+}
 
-    uint8_t llt[] = {0, 1, 2, 3, 4, 5, 6, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf};
-    DuidPtr duid(new DUID(llt, sizeof(llt)));
+/// @brief Basic Lease4 Checks
+///
+/// Checks that the addLease, getLease4 (by address) and deleteLease (with an
+/// IPv4 address) works.
+TEST_F(MemfileLeaseMgrTest, basicLease4) {
+    testBasicLease4();
+}
 
-    uint32_t iaid = 7; // just a number
+/// @todo Write more memfile tests
 
-    SubnetID subnet_id = 8; // just another number
+// Simple test about lease4 retrieval through client id method
+TEST_F(MemfileLeaseMgrTest, getLease4ClientId) {
+    testGetLease4ClientId();
+}
 
-    Lease6Ptr lease(new Lease6(Lease::TYPE_NA, addr,
-                               duid, iaid, 100, 200, 50, 80,
-                               subnet_id));
+// Checks that lease4 retrieval client id is null is working
+TEST_F(MemfileLeaseMgrTest, getLease4NullClientId) {
+    testGetLease4NullClientId();
+}
 
-    EXPECT_TRUE(lease_mgr->addLease(lease));
+// Checks lease4 retrieval through HWAddr
+TEST_F(MemfileLeaseMgrTest, getLease4HWAddr1) {
+    testGetLease4HWAddr1();
+}
 
-    // should not be allowed to add a second lease with the same address
-    EXPECT_FALSE(lease_mgr->addLease(lease));
+/// @brief Check GetLease4 methods - access by Hardware Address
+///
+/// Adds leases to the database and checks that they can be accessed via
+/// a combination of DUID and IAID.
+TEST_F(MemfileLeaseMgrTest, getLease4HWAddr2) {
+    testGetLease4HWAddr2();
+}
 
-    Lease6Ptr x = lease_mgr->getLease6(Lease::TYPE_NA,
-                                       IOAddress("2001:db8:1::234"));
-    EXPECT_EQ(Lease6Ptr(), x);
+// Checks lease4 retrieval with clientId, HWAddr and subnet_id
+TEST_F(MemfileLeaseMgrTest, getLease4ClientIdHWAddrSubnetId) {
+    testGetLease4ClientIdHWAddrSubnetId();
+}
 
-    x = lease_mgr->getLease6(Lease::TYPE_NA,
-                             IOAddress("2001:db8:1::456"));
-    ASSERT_TRUE(x);
+/// @brief Basic Lease4 Checks
+///
+/// Checks that the addLease, getLease4(by address), getLease4(hwaddr,subnet_id),
+/// updateLease4() and deleteLease (IPv4 address) can handle NULL client-id.
+/// (client-id is optional and may not be present)
+TEST_F(MemfileLeaseMgrTest, DISABLED_lease4NullClientId) {
 
-    EXPECT_EQ(x->addr_, addr);
-    EXPECT_TRUE(*x->duid_ == *duid);
-    EXPECT_EQ(x->iaid_, iaid);
-    EXPECT_EQ(x->subnet_id_, subnet_id);
+    /// @todo Test is disabled, because memfile does not support disk storage, so
+    /// all leases are lost after reopen()
+    testLease4NullClientId();
+}
 
-    // These are not important from lease management perspective, but
-    // let's check them anyway.
-    EXPECT_EQ(x->type_, Lease::TYPE_NA);
-    EXPECT_EQ(x->preferred_lft_, 100);
-    EXPECT_EQ(x->valid_lft_, 200);
-    EXPECT_EQ(x->t1_, 50);
-    EXPECT_EQ(x->t2_, 80);
+/// @brief Check GetLease4 methods - access by Hardware Address & Subnet ID
+///
+/// Adds leases to the database and checks that they can be accessed via
+/// a combination of hardware address and subnet ID
+TEST_F(MemfileLeaseMgrTest, DISABLED_getLease4HwaddrSubnetId) {
 
-    // Test getLease6(duid, iaid, subnet_id) - positive case
-    Lease6Ptr y = lease_mgr->getLease6(Lease::TYPE_NA, *duid, iaid,
-                                       subnet_id);
-    ASSERT_TRUE(y);
-    EXPECT_TRUE(*y->duid_ == *duid);
-    EXPECT_EQ(y->iaid_, iaid);
-    EXPECT_EQ(y->addr_, addr);
+    /// @todo: fails on memfile. It's probably a memfile bug.
+    testGetLease4HWAddrSubnetId();
+}
 
-    // Test getLease6(duid, iaid, subnet_id) - wrong iaid
-    uint32_t invalid_iaid = 9; // no such iaid
-    y = lease_mgr->getLease6(Lease::TYPE_NA, *duid, invalid_iaid,
-                             subnet_id);
-    EXPECT_FALSE(y);
+/// @brief Check GetLease4 methods - access by Client ID
+///
+/// Adds leases to the database and checks that they can be accessed via
+/// the Client ID.
+TEST_F(MemfileLeaseMgrTest, getLease4ClientId2) {
+    testGetLease4ClientId2();
+}
 
-    uint32_t invalid_subnet_id = 999;
-    y = lease_mgr->getLease6(Lease::TYPE_NA, *duid, iaid,
-                             invalid_subnet_id);
-    EXPECT_FALSE(y);
+// @brief Get Lease4 by client ID
+//
+// Check that the system can cope with a client ID of any size.
+TEST_F(MemfileLeaseMgrTest, getLease4ClientIdSize) {
+    testGetLease4ClientIdSize();
+}
 
-    // truncated duid
-    DuidPtr invalid_duid(new DUID(llt, sizeof(llt) - 1));
-    y = lease_mgr->getLease6(Lease::TYPE_NA, *invalid_duid, iaid,
-                             subnet_id);
-    EXPECT_FALSE(y);
+/// @brief Check GetLease4 methods - access by Client ID & Subnet ID
+///
+/// Adds leases to the database and checks that they can be accessed via
+/// a combination of client and subnet IDs.
+TEST_F(MemfileLeaseMgrTest, getLease4ClientIdSubnetId) {
+    testGetLease4ClientIdSubnetId();
+}
 
-    // should return false - there's no such address
-    EXPECT_FALSE(lease_mgr->deleteLease(IOAddress("2001:db8:1::789")));
+/// @brief Check GetLease6 methods - access by DUID/IAID
+///
+/// Adds leases to the database and checks that they can be accessed via
+/// a combination of DUID and IAID.
+/// @todo: test disabled, because Memfile_LeaseMgr::getLeases6(Lease::Type,
+/// const DUID& duid, uint32_t iaid) const is not implemented yet.
+TEST_F(MemfileLeaseMgrTest, DISABLED_getLeases6DuidIaid) {
+    testGetLeases6DuidIaid();
+}
 
-    // this one should succeed
-    EXPECT_TRUE(lease_mgr->deleteLease(IOAddress("2001:db8:1::456")));
+// Check that the system can cope with a DUID of allowed size.
 
-    // after the lease is deleted, it should really be gone
-    x = lease_mgr->getLease6(Lease::TYPE_NA, IOAddress("2001:db8:1::456"));
-    EXPECT_EQ(Lease6Ptr(), x);
+/// @todo: test disabled, because Memfile_LeaseMgr::getLeases6(Lease::Type,
+/// const DUID& duid, uint32_t iaid) const is not implemented yet.
+TEST_F(MemfileLeaseMgrTest, DISABLED_getLeases6DuidSize) {
+    testGetLeases6DuidSize();
 }
 
-/// @todo Write more memfile tests
+/// @brief Check that getLease6 methods discriminate by lease type.
+///
+/// Adds six leases, two per lease type all with the same duid and iad but
+/// with alternating subnet_ids.
+/// It then verifies that all of getLeases6() method variants correctly
+/// discriminate between the leases based on lease type alone.
+/// @todo: Disabled, because type parameter in Memfile_LeaseMgr::getLease6
+/// (Lease::Type, const isc::asiolink::IOAddress& addr) const is not used.
+TEST_F(MemfileLeaseMgrTest, DISABLED_lease6LeaseTypeCheck) {
+    testLease6LeaseTypeCheck();
+}
 
-// Simple test about lease4 retrieval through client id method
-TEST_F(MemfileLeaseMgrTest, getLease4ClientId) {
-    testGetLease4ClientId();
+/// @brief Check GetLease6 methods - access by DUID/IAID/SubnetID
+///
+/// Adds leases to the database and checks that they can be accessed via
+/// a combination of DIUID and IAID.
+TEST_F(MemfileLeaseMgrTest, getLease6DuidIaidSubnetId) {
+    testGetLease6DuidIaidSubnetId();
 }
 
-// Checks that lease4 retrieval client id is null is working
-TEST_F(MemfileLeaseMgrTest, getLease4NullClientId) {
-    testGetLease4NullClientId();
+/// Checks that getLease6(type, duid, iaid, subnet-id) works with different
+/// DUID sizes
+TEST_F(MemfileLeaseMgrTest, getLease6DuidIaidSubnetIdSize) {
+    testGetLease6DuidIaidSubnetIdSize();
 }
 
-// Checks lease4 retrieval through HWAddr
-TEST_F(MemfileLeaseMgrTest, getLease4HWAddr) {
-    testGetLease4HWAddr();
+/// @brief Lease4 update tests
+///
+/// Checks that we are able to update a lease in the database.
+/// @todo: Disabled, because memfile does not throw when lease is updated.
+/// We should reconsider if lease{4,6} structures should have a limit
+/// implemented in them.
+TEST_F(MemfileLeaseMgrTest, DISABLED_updateLease4) {
+    testUpdateLease4();
 }
 
-// Checks lease4 retrieval with clientId, HWAddr and subnet_id
-TEST_F(MemfileLeaseMgrTest, getLease4ClientIdHWAddrSubnetId) {
-    testGetLease4ClientIdHWAddrSubnetId();
+/// @brief Lease6 update tests
+///
+/// Checks that we are able to update a lease in the database.
+/// @todo: Disabled, because memfile does not throw when lease is updated.
+/// We should reconsider if lease{4,6} structures should have a limit
+/// implemented in them.
+TEST_F(MemfileLeaseMgrTest, DISABLED_updateLease6) {
+    testUpdateLease6();
 }
 
+// The following tests are not applicable for memfile. When adding
+// new tests to the list here, make sure to provide brief explanation
+// why they are not applicable:
+//
+// testGetLease4HWAddrSubnetIdSize() - memfile just keeps Lease structure
+//     and does not do any checks of HWAddr content
+
 }; // end of anonymous namespace

src/lib/dhcpsrv/tests/mysql_lease_mgr_unittest.cc

@@ -18,9 +18,9 @@
 #include <dhcpsrv/lease_mgr_factory.h>
 #include <dhcpsrv/mysql_lease_mgr.h>
 #include <dhcpsrv/tests/test_utils.h>
+#include <dhcpsrv/tests/generic_lease_mgr_unittest.h>
 #include <exceptions/exceptions.h>
 
-
 #include <gtest/gtest.h>
 
 #include <algorithm>
@@ -323,122 +323,21 @@ TEST_F(MySqlLeaseMgrTest, checkVersion) {
 /// Checks that the addLease, getLease4 (by address) and deleteLease (with an
 /// IPv4 address) works.
 TEST_F(MySqlLeaseMgrTest, basicLease4) {
-    // Get the leases to be used for the test.
-    vector<Lease4Ptr> leases = createLeases4();
-
-    // Start the tests.  Add three leases to the database, read them back and
-    // check they are what we think they are.
-    EXPECT_TRUE(lmptr_->addLease(leases[1]));
-    EXPECT_TRUE(lmptr_->addLease(leases[2]));
-    EXPECT_TRUE(lmptr_->addLease(leases[3]));
-    lmptr_->commit();
-
-    // Reopen the database to ensure that they actually got stored.
-    reopen();
-
-    Lease4Ptr l_returned = lmptr_->getLease4(ioaddress4_[1]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[1], l_returned);
-
-    l_returned = lmptr_->getLease4(ioaddress4_[2]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[2], l_returned);
-
-    l_returned = lmptr_->getLease4(ioaddress4_[3]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[3], l_returned);
-
-    // Check that we can't add a second lease with the same address
-    EXPECT_FALSE(lmptr_->addLease(leases[1]));
-
-    // Delete a lease, check that it's gone, and that we can't delete it
-    // a second time.
-    EXPECT_TRUE(lmptr_->deleteLease(ioaddress4_[1]));
-    l_returned = lmptr_->getLease4(ioaddress4_[1]);
-    EXPECT_FALSE(l_returned);
-    EXPECT_FALSE(lmptr_->deleteLease(ioaddress4_[1]));
-
-    // Check that the second address is still there.
-    l_returned = lmptr_->getLease4(ioaddress4_[2]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[2], l_returned);
+    testBasicLease4();
+}
+
+TEST_F(MySqlLeaseMgrTest, testAddGetDelete6) {
+    testAddGetDelete6(false);
 }
 
+
 /// @brief Basic Lease4 Checks
 ///
 /// Checks that the addLease, getLease4(by address), getLease4(hwaddr,subnet_id),
 /// updateLease4() and deleteLease (IPv4 address) can handle NULL client-id.
 /// (client-id is optional and may not be present)
 TEST_F(MySqlLeaseMgrTest, lease4NullClientId) {
-    // Get the leases to be used for the test.
-    vector<Lease4Ptr> leases = createLeases4();
-
-    // Let's clear client-id pointers
-    leases[1]->client_id_ = ClientIdPtr();
-    leases[2]->client_id_ = ClientIdPtr();
-    leases[3]->client_id_ = ClientIdPtr();
-
-    // Start the tests.  Add three leases to the database, read them back and
-    // check they are what we think they are.
-    EXPECT_TRUE(lmptr_->addLease(leases[1]));
-    EXPECT_TRUE(lmptr_->addLease(leases[2]));
-    EXPECT_TRUE(lmptr_->addLease(leases[3]));
-    lmptr_->commit();
-
-    // Reopen the database to ensure that they actually got stored.
-    reopen();
-
-    Lease4Ptr l_returned = lmptr_->getLease4(ioaddress4_[1]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[1], l_returned);
-
-    l_returned = lmptr_->getLease4(ioaddress4_[2]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[2], l_returned);
-
-    l_returned = lmptr_->getLease4(ioaddress4_[3]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[3], l_returned);
-
-    // Check that we can't add a second lease with the same address
-    EXPECT_FALSE(lmptr_->addLease(leases[1]));
-
-    // Check that we can get the lease by HWAddr
-    HWAddr tmp(leases[2]->hwaddr_, HTYPE_ETHER);
-    Lease4Collection returned = lmptr_->getLease4(tmp);
-    ASSERT_EQ(1, returned.size());
-    detailCompareLease(leases[2], *returned.begin());
-
-    l_returned = lmptr_->getLease4(tmp, leases[2]->subnet_id_);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[2], l_returned);
-
-
-    // Check that we can update the lease
-    // Modify some fields in lease 1 (not the address) and update it.
-    ++leases[1]->subnet_id_;
-    leases[1]->valid_lft_ *= 2;
-    lmptr_->updateLease4(leases[1]);
-
-    // ... and check that the lease is indeed updated
-    l_returned = lmptr_->getLease4(ioaddress4_[1]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[1], l_returned);
-
-
-
-    // Delete a lease, check that it's gone, and that we can't delete it
-    // a second time.
-    EXPECT_TRUE(lmptr_->deleteLease(ioaddress4_[1]));
-    l_returned = lmptr_->getLease4(ioaddress4_[1]);
-    EXPECT_FALSE(l_returned);
-    EXPECT_FALSE(lmptr_->deleteLease(ioaddress4_[1]));
-
-    // Check that the second address is still there.
-    l_returned = lmptr_->getLease4(ioaddress4_[2]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[2], l_returned);
-
+    testLease4NullClientId();
 }
 
 /// @brief Verify that too long hostname for Lease4 is not accepted.
@@ -446,24 +345,7 @@ TEST_F(MySqlLeaseMgrTest, lease4NullClientId) {
 /// Checks that the it is not possible to create a lease when the hostname
 /// length exceeds 255 characters.
 TEST_F(MySqlLeaseMgrTest, lease4InvalidHostname) {
-    // Get the leases to be used for the test.
-    vector<Lease4Ptr> leases = createLeases4();
-
-    // Create a dummy hostname, consisting of 255 characters.
-    leases[1]->hostname_.assign(255, 'a');
-    ASSERT_TRUE(lmptr_->addLease(leases[1]));
-
-    // The new lease must be in the database.
-    Lease4Ptr l_returned = lmptr_->getLease4(ioaddress4_[1]);
-    detailCompareLease(leases[1], l_returned);
-
-    // Let's delete the lease, so as we can try to add it again with
-    // invalid hostname.
-    EXPECT_TRUE(lmptr_->deleteLease(ioaddress4_[1]));
-
-    // Create a hostname with 256 characters. It should not be accepted.
-    leases[1]->hostname_.assign(256, 'a');
-    EXPECT_THROW(lmptr_->addLease(leases[1]), DbOperationError);
+    testLease4InvalidHostname();
 }
 
 /// @brief Basic Lease6 Checks
@@ -471,45 +353,7 @@ TEST_F(MySqlLeaseMgrTest, lease4InvalidHostname) {
 /// Checks that the addLease, getLease6 (by address) and deleteLease (with an
 /// IPv6 address) works.
 TEST_F(MySqlLeaseMgrTest, basicLease6) {
-    // Get the leases to be used for the test.
-    vector<Lease6Ptr> leases = createLeases6();
-
-    // Start the tests.  Add three leases to the database, read them back and
-    // check they are what we think they are.
-    EXPECT_TRUE(lmptr_->addLease(leases[1]));
-    EXPECT_TRUE(lmptr_->addLease(leases[2]));
-    EXPECT_TRUE(lmptr_->addLease(leases[3]));
-    lmptr_->commit();
-
-    // Reopen the database to ensure that they actually got stored.
-    reopen();
-
-    Lease6Ptr l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[1], l_returned);
-
-    l_returned = lmptr_->getLease6(leasetype6_[2], ioaddress6_[2]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[2], l_returned);
-
-    l_returned = lmptr_->getLease6(leasetype6_[3], ioaddress6_[3]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[3], l_returned);
-
-    // Check that we can't add a second lease with the same address
-    EXPECT_FALSE(lmptr_->addLease(leases[1]));
-
-    // Delete a lease, check that it's gone, and that we can't delete it
-    // a second time.
-    EXPECT_TRUE(lmptr_->deleteLease(ioaddress6_[1]));
-    l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
-    EXPECT_FALSE(l_returned);
-    EXPECT_FALSE(lmptr_->deleteLease(ioaddress6_[1]));
-
-    // Check that the second address is still there.
-    l_returned = lmptr_->getLease6(leasetype6_[2], ioaddress6_[2]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[2], l_returned);
+    testBasicLease6();
 }
 
 /// @brief Verify that too long hostname for Lease6 is not accepted.
@@ -517,102 +361,25 @@ TEST_F(MySqlLeaseMgrTest, basicLease6) {
 /// Checks that the it is not possible to create a lease when the hostname
 /// length exceeds 255 characters.
 TEST_F(MySqlLeaseMgrTest, lease6InvalidHostname) {
-    // Get the leases to be used for the test.
-    vector<Lease6Ptr> leases = createLeases6();
-
-    // Create a dummy hostname, consisting of 255 characters.
-    leases[1]->hostname_.assign(255, 'a');
-    ASSERT_TRUE(lmptr_->addLease(leases[1]));
-
-    // The new lease must be in the database.
-    Lease6Ptr l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
-    detailCompareLease(leases[1], l_returned);
-
-    // Let's delete the lease, so as we can try to add it again with
-    // invalid hostname.
-    EXPECT_TRUE(lmptr_->deleteLease(ioaddress6_[1]));
-
-    // Create a hostname with 256 characters. It should not be accepted.
-    leases[1]->hostname_.assign(256, 'a');
-    EXPECT_THROW(lmptr_->addLease(leases[1]), DbOperationError);
+    testLease6InvalidHostname();
 }
 
 /// @brief Check GetLease4 methods - access by Hardware Address
-///
-/// Adds leases to the database and checks that they can be accessed via
-/// a combination of DIUID and IAID.
-TEST_F(MySqlLeaseMgrTest, getLease4Hwaddr) {
-    // Get the leases to be used for the test and add to the database
-    vector<Lease4Ptr> leases = createLeases4();
-    for (int i = 0; i < leases.size(); ++i) {
-        EXPECT_TRUE(lmptr_->addLease(leases[i]));
-    }
-
-    // Get the leases matching the hardware address of lease 1
-    /// @todo: Simply use HWAddr directly once 2589 is implemented
-    HWAddr tmp(leases[1]->hwaddr_, HTYPE_ETHER);
-    Lease4Collection returned = lmptr_->getLease4(tmp);
-
-    // Should be three leases, matching leases[1], [3] and [5].
-    ASSERT_EQ(3, returned.size());
+TEST_F(MySqlLeaseMgrTest, getLease4HWAddr1) {
+    testGetLease4HWAddr1();
+}
 
-    // Easiest way to check is to look at the addresses.
-    vector<string> addresses;
-    for (Lease4Collection::const_iterator i = returned.begin();
-         i != returned.end(); ++i) {
-        addresses.push_back((*i)->addr_.toText());
-    }
-    sort(addresses.begin(), addresses.end());
-    EXPECT_EQ(straddress4_[1], addresses[0]);
-    EXPECT_EQ(straddress4_[3], addresses[1]);
-    EXPECT_EQ(straddress4_[5], addresses[2]);
-
-    // Repeat test with just one expected match
-    /// @todo: Simply use HWAddr directly once 2589 is implemented
-    returned = lmptr_->getLease4(HWAddr(leases[2]->hwaddr_, HTYPE_ETHER));
-    ASSERT_EQ(1, returned.size());
-    detailCompareLease(leases[2], *returned.begin());
-
-    // Check that an empty vector is valid
-    EXPECT_TRUE(leases[7]->hwaddr_.empty());
-    /// @todo: Simply use HWAddr directly once 2589 is implemented
-    returned = lmptr_->getLease4(HWAddr(leases[7]->hwaddr_, HTYPE_ETHER));
-    ASSERT_EQ(1, returned.size());
-    detailCompareLease(leases[7], *returned.begin());
-
-    // Try to get something with invalid hardware address
-    vector<uint8_t> invalid(6, 0);
-    returned = lmptr_->getLease4(invalid);
-    EXPECT_EQ(0, returned.size());
+/// @brief Check GetLease4 methods - access by Hardware Address
+TEST_F(MySqlLeaseMgrTest, getLease4HWAddr2) {
+    testGetLease4HWAddr2();
 }
 
 // @brief Get lease4 by hardware address (2)
 //
 // Check that the system can cope with getting a hardware address of
 // any size.
-TEST_F(MySqlLeaseMgrTest, getLease4HwaddrSize) {
-
-    // Create leases, although we need only one.
-    vector<Lease4Ptr> leases = createLeases4();
-
-    // Now add leases with increasing hardware address size.
-    for (uint8_t i = 0; i <= HWAddr::MAX_HWADDR_LEN; ++i) {
-        leases[1]->hwaddr_.resize(i, i);
-        EXPECT_TRUE(lmptr_->addLease(leases[1]));
-        /// @todo: Simply use HWAddr directly once 2589 is implemented
-        Lease4Collection returned =
-            lmptr_->getLease4(HWAddr(leases[1]->hwaddr_, HTYPE_ETHER));
-
-        ASSERT_EQ(1, returned.size());
-        detailCompareLease(leases[1], *returned.begin());
-        (void) lmptr_->deleteLease(leases[1]->addr_);
-    }
-
-    // Database should not let us add one that is too big
-    // (The 42 is a random value put in each byte of the address.)
-    /// @todo: 2589 will make this test impossible
-    leases[1]->hwaddr_.resize(HWAddr::MAX_HWADDR_LEN + 100, 42);
-    EXPECT_THROW(lmptr_->addLease(leases[1]), isc::dhcp::DbOperationError);
+TEST_F(MySqlLeaseMgrTest, getLease4HWAddrSize) {
+    testGetLease4HWAddrSize();
 }
 
 /// @brief Check GetLease4 methods - access by Hardware Address & Subnet ID
@@ -620,167 +387,35 @@ TEST_F(MySqlLeaseMgrTest, getLease4HwaddrSize) {
 /// Adds leases to the database and checks that they can be accessed via
 /// a combination of hardware address and subnet ID
 TEST_F(MySqlLeaseMgrTest, getLease4HwaddrSubnetId) {
-    // Get the leases to be used for the test and add to the database
-    vector<Lease4Ptr> leases = createLeases4();
-    for (int i = 0; i < leases.size(); ++i) {
-        EXPECT_TRUE(lmptr_->addLease(leases[i]));
-    }
-
-    // Get the leases matching the hardware address of lease 1 and
-    // subnet ID of lease 1.  Result should be a single lease - lease 1.
-    /// @todo: Simply use HWAddr directly once 2589 is implemented
-    Lease4Ptr returned = lmptr_->getLease4(HWAddr(leases[1]->hwaddr_,
-        HTYPE_ETHER), leases[1]->subnet_id_);
-
-    ASSERT_TRUE(returned);
-    detailCompareLease(leases[1], returned);
-
-    // Try for a match to the hardware address of lease 1 and the wrong
-    // subnet ID.
-    /// @todo: Simply use HWAddr directly once 2589 is implemented
-    returned = lmptr_->getLease4(HWAddr(leases[1]->hwaddr_, HTYPE_ETHER),
-                                 leases[1]->subnet_id_ + 1);
-    EXPECT_FALSE(returned);
-
-    // Try for a match to the subnet ID of lease 1 (and lease 4) but
-    // the wrong hardware address.
-    vector<uint8_t> invalid_hwaddr(15, 0x77);
-    /// @todo: Simply use HWAddr directly once 2589 is implemented
-    returned = lmptr_->getLease4(HWAddr(invalid_hwaddr, HTYPE_ETHER),
-                                 leases[1]->subnet_id_);
-    EXPECT_FALSE(returned);
-
-    // Try for a match to an unknown hardware address and an unknown
-    // subnet ID.
-    /// @todo: Simply use HWAddr directly once 2589 is implemented
-    returned = lmptr_->getLease4(HWAddr(invalid_hwaddr, HTYPE_ETHER),
-                                 leases[1]->subnet_id_ + 1);
-    EXPECT_FALSE(returned);
-
-    // Add a second lease with the same values as the first and check that
-    // an attempt to access the database by these parameters throws a
-    // "multiple records" exception. (We expect there to be only one record
-    // with that combination, so getting them via getLeaseX() (as opposed
-    // to getLeaseXCollection() should throw an exception.)
-    EXPECT_TRUE(lmptr_->deleteLease(leases[2]->addr_));
-    leases[1]->addr_ = leases[2]->addr_;
-    EXPECT_TRUE(lmptr_->addLease(leases[1]));
-    /// @todo: Simply use HWAddr directly once 2589 is implemented
-    EXPECT_THROW(returned = lmptr_->getLease4(HWAddr(leases[1]->hwaddr_,
-                                                    HTYPE_ETHER),
-                                             leases[1]->subnet_id_),
-                 isc::dhcp::MultipleRecords);
-
+    testGetLease4HWAddrSubnetId();
 }
 
 // @brief Get lease4 by hardware address and subnet ID (2)
 //
 // Check that the system can cope with getting a hardware address of
 // any size.
-TEST_F(MySqlLeaseMgrTest, getLease4HwaddrSubnetIdSize) {
-
-    // Create leases, although we need only one.
-    vector<Lease4Ptr> leases = createLeases4();
-
-    // Now add leases with increasing hardware address size and check
-    // that they can be retrieved.
-    for (uint8_t i = 0; i <= HWAddr::MAX_HWADDR_LEN; ++i) {
-        leases[1]->hwaddr_.resize(i, i);
-        EXPECT_TRUE(lmptr_->addLease(leases[1]));
-        /// @todo: Simply use HWAddr directly once 2589 is implemented
-        Lease4Ptr returned = lmptr_->getLease4(HWAddr(leases[1]->hwaddr_,
-                                                      HTYPE_ETHER),
-                                               leases[1]->subnet_id_);
-        ASSERT_TRUE(returned);
-        detailCompareLease(leases[1], returned);
-        (void) lmptr_->deleteLease(leases[1]->addr_);
-    }
+TEST_F(MySqlLeaseMgrTest, getLease4HWAddrSubnetIdSize) {
+    testGetLease4HWAddrSubnetIdSize();
+}
 
-    // Database should not let us add one that is too big
-    // (The 42 is a random value put in each byte of the address.)
-    leases[1]->hwaddr_.resize(HWAddr::MAX_HWADDR_LEN + 100, 42);
-    EXPECT_THROW(lmptr_->addLease(leases[1]), isc::dhcp::DbOperationError);
+// This test was derived from memfile.
+TEST_F(MySqlLeaseMgrTest, getLease4ClientId) {
+    testGetLease4ClientId();
 }
 
 /// @brief Check GetLease4 methods - access by Client ID
 ///
 /// Adds leases to the database and checks that they can be accessed via
 /// the Client ID.
-TEST_F(MySqlLeaseMgrTest, getLease4ClientId) {
-    // Get the leases to be used for the test and add to the database
-    vector<Lease4Ptr> leases = createLeases4();
-    for (int i = 0; i < leases.size(); ++i) {
-        EXPECT_TRUE(lmptr_->addLease(leases[i]));
-    }
-
-    // Get the leases matching the Client ID address of lease 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());
-
-    // Easiest way to check is to look at the addresses.
-    vector<string> addresses;
-    for (Lease4Collection::const_iterator i = returned.begin();
-         i != returned.end(); ++i) {
-        addresses.push_back((*i)->addr_.toText());
-    }
-    sort(addresses.begin(), addresses.end());
-    EXPECT_EQ(straddress4_[1], addresses[0]);
-    EXPECT_EQ(straddress4_[4], addresses[1]);
-    EXPECT_EQ(straddress4_[5], addresses[2]);
-    EXPECT_EQ(straddress4_[6], addresses[3]);
-
-    // Repeat test with just one expected match
-    returned = lmptr_->getLease4(*leases[3]->client_id_);
-    ASSERT_EQ(1, returned.size());
-    detailCompareLease(leases[3], *returned.begin());
-
-    // Check that client-id is NULL
-    EXPECT_FALSE(leases[7]->client_id_);
-    HWAddr tmp(leases[7]->hwaddr_, HTYPE_ETHER);
-    returned = lmptr_->getLease4(tmp);
-    ASSERT_EQ(1, returned.size());
-    detailCompareLease(leases[7], *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());
+TEST_F(MySqlLeaseMgrTest, getLease4ClientId2) {
+    testGetLease4ClientId2();
 }
 
 // @brief Get Lease4 by client ID (2)
 //
 // Check that the system can cope with a client ID of any size.
 TEST_F(MySqlLeaseMgrTest, getLease4ClientIdSize) {
-
-    // Create leases, although we need only one.
-    vector<Lease4Ptr> leases = createLeases4();
-
-    // Now add leases with increasing Client ID size can be retrieved.
-    // For speed, go from 0 to 128 is steps of 16.
-    // Intermediate client_id_max is to overcome problem if
-    // ClientId::MAX_CLIENT_ID_LEN is used in an EXPECT_EQ.
-    int client_id_max = ClientId::MAX_CLIENT_ID_LEN;
-    EXPECT_EQ(128, client_id_max);
-
-    int client_id_min = ClientId::MIN_CLIENT_ID_LEN;
-    EXPECT_EQ(2, client_id_min); // See RFC2132, section 9.14
-
-    for (uint8_t i = client_id_min; i <= client_id_max; i += 16) {
-        vector<uint8_t> clientid_vec(i, i);
-        leases[1]->client_id_.reset(new ClientId(clientid_vec));
-        EXPECT_TRUE(lmptr_->addLease(leases[1]));
-        Lease4Collection returned = lmptr_->getLease4(*leases[1]->client_id_);
-        ASSERT_TRUE(returned.size() == 1);
-        detailCompareLease(leases[1], *returned.begin());
-        (void) lmptr_->deleteLease(leases[1]->addr_);
-    }
-
-    // Don't bother to check client IDs longer than the maximum -
-    // these cannot be constructed, and that limitation is tested
-    // in the DUID/Client ID unit tests.
+    testGetLease4ClientIdSize();
 }
 
 /// @brief Check GetLease4 methods - access by Client ID & Subnet ID
@@ -788,115 +423,20 @@ TEST_F(MySqlLeaseMgrTest, getLease4ClientIdSize) {
 /// Adds leases to the database and checks that they can be accessed via
 /// a combination of client and subnet IDs.
 TEST_F(MySqlLeaseMgrTest, getLease4ClientIdSubnetId) {
-    // Get the leases to be used for the test and add to the database
-    vector<Lease4Ptr> leases = createLeases4();
-    for (int i = 0; i < leases.size(); ++i) {
-        EXPECT_TRUE(lmptr_->addLease(leases[i]));
-    }
-
-    // Get the leases matching the client ID of lease 1 and
-    // subnet ID of lease 1.  Result should be a single lease - lease 1.
-    Lease4Ptr returned = lmptr_->getLease4(*leases[1]->client_id_,
-                                           leases[1]->subnet_id_);
-    ASSERT_TRUE(returned);
-    detailCompareLease(leases[1], returned);
-
-    // Try for a match to the client ID of lease 1 and the wrong
-    // subnet ID.
-    returned = lmptr_->getLease4(*leases[1]->client_id_,
-                                 leases[1]->subnet_id_ + 1);
-    EXPECT_FALSE(returned);
-
-    // Try for a match to the subnet ID of lease 1 (and lease 4) but
-    // the wrong client ID
-    const uint8_t invalid_data[] = {0, 0, 0};
-    ClientId invalid(invalid_data, sizeof(invalid_data));
-    returned = lmptr_->getLease4(invalid, leases[1]->subnet_id_);
-    EXPECT_FALSE(returned);
-
-    // Try for a match to an unknown hardware address and an unknown
-    // subnet ID.
-    returned = lmptr_->getLease4(invalid, leases[1]->subnet_id_ + 1);
-    EXPECT_FALSE(returned);
+    testGetLease4ClientIdSubnetId();
 }
 
 /// @brief Check GetLease6 methods - access by DUID/IAID
 ///
 /// Adds leases to the database and checks that they can be accessed via
-/// a combination of DIUID and IAID.
+/// a combination of DUID and IAID.
 TEST_F(MySqlLeaseMgrTest, getLeases6DuidIaid) {
-    // 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
-
-    // Add them to the database
-    for (int i = 0; i < leases.size(); ++i) {
-        EXPECT_TRUE(lmptr_->addLease(leases[i]));
-    }
-
-    // Get the leases matching the DUID and IAID of lease[1].
-    Lease6Collection returned = lmptr_->getLeases6(leasetype6_[1],
-                                                   *leases[1]->duid_,
-                                                   leases[1]->iaid_);
-
-    // Should be two leases, matching leases[1] and [4].
-    ASSERT_EQ(2, returned.size());
-
-    // Easiest way to check is to look at the addresses.
-    vector<string> addresses;
-    for (Lease6Collection::const_iterator i = returned.begin();
-         i != returned.end(); ++i) {
-        addresses.push_back((*i)->addr_.toText());
-    }
-    sort(addresses.begin(), addresses.end());
-    EXPECT_EQ(straddress6_[1], addresses[0]);
-    EXPECT_EQ(straddress6_[4], addresses[1]);
-
-    // Check that nothing is returned when either the IAID or DUID match
-    // nothing.
-    returned = lmptr_->getLeases6(leasetype6_[1], *leases[1]->duid_,
-                                  leases[1]->iaid_ + 1);
-    EXPECT_EQ(0, 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());
+    testGetLeases6DuidIaid();
 }
 
-// @brief Get Lease4 by DUID and IAID (2)
-//
-// Check that the system can cope with a DUID of any size.
-TEST_F(MySqlLeaseMgrTest, getLeases6DuidIaidSize) {
-
-    // Create leases, although we need only one.
-    vector<Lease6Ptr> leases = createLeases6();
-
-    // Now add leases with increasing DUID size can be retrieved.
-    // For speed, go from 0 to 128 is steps of 16.
-    int duid_max = DUID::MAX_DUID_LEN;
-    EXPECT_EQ(128, duid_max);
-
-    int duid_min = DUID::MIN_DUID_LEN;
-    EXPECT_EQ(1, duid_min);
-
-    for (uint8_t i = duid_min; i <= duid_max; i += 16) {
-        vector<uint8_t> duid_vec(i, i);
-        leases[1]->duid_.reset(new DUID(duid_vec));
-        EXPECT_TRUE(lmptr_->addLease(leases[1]));
-        Lease6Collection returned = lmptr_->getLeases6(leasetype6_[1],
-                                                       *leases[1]->duid_,
-                                                       leases[1]->iaid_);
-        ASSERT_EQ(1, returned.size());
-        detailCompareLease(leases[1], *returned.begin());
-        (void) lmptr_->deleteLease(leases[1]->addr_);
-    }
-
-    // Don't bother to check DUIDs longer than the maximum - these cannot be
-    // constructed, and that limitation is tested in the DUID/Client ID unit
-    // tests.
+// Check that the system can cope with a DUID of allowed size.
+TEST_F(MySqlLeaseMgrTest, getLeases6DuidSize) {
+    testGetLeases6DuidSize();
 }
 
 /// @brief Check that getLease6 methods discriminate by lease type.
@@ -906,95 +446,7 @@ TEST_F(MySqlLeaseMgrTest, getLeases6DuidIaidSize) {
 /// It then verifies that all of getLeases6() method variants correctly
 /// discriminate between the leases based on lease type alone.
 TEST_F(MySqlLeaseMgrTest, lease6LeaseTypeCheck) {
-
-    Lease6Ptr empty_lease(new Lease6());
-
-    DuidPtr duid(new DUID(vector<uint8_t>(8, 0x77)));
-
-    // Initialize unused fields.
-    empty_lease->t1_ = 0;                             // Not saved
-    empty_lease->t2_ = 0;                             // Not saved
-    empty_lease->fixed_ = false;                      // Unused
-    empty_lease->comments_ = std::string("");         // Unused
-    empty_lease->iaid_ = 142;
-    empty_lease->duid_ = DuidPtr(new DUID(*duid));
-    empty_lease->subnet_id_ = 23;
-    empty_lease->preferred_lft_ = 100;
-    empty_lease->valid_lft_ = 100;
-    empty_lease->cltt_ = 100;
-    empty_lease->fqdn_fwd_ = true;
-    empty_lease->fqdn_rev_ = true;
-    empty_lease->hostname_ = "myhost.example.com.";
-    empty_lease->prefixlen_ = 4;
-
-    // Make Two leases per lease type, all with the same  DUID, IAID but
-    // alternate the subnet_ids.
-    vector<Lease6Ptr> leases;
-    for (int i = 0; i < 6; ++i) {
-          Lease6Ptr lease(new Lease6(*empty_lease));
-          lease->type_ = leasetype6_[i / 2];
-          lease->addr_ = IOAddress(straddress6_[i]);
-          lease->subnet_id_ += (i % 2);
-          leases.push_back(lease);
-          EXPECT_TRUE(lmptr_->addLease(lease));
-     }
-
-    // Verify getting a single lease by type and address.
-    for (int i = 0; i < 6; ++i) {
-        // Look for exact match for each lease type.
-        Lease6Ptr returned = lmptr_->getLease6(leasetype6_[i / 2],
-                                               leases[i]->addr_);
-        // We should match one per lease type.
-        ASSERT_TRUE(returned);
-        EXPECT_TRUE(*returned == *leases[i]);
-
-        // Same address but wrong lease type, should not match.
-        returned = lmptr_->getLease6(leasetype6_[i / 2 + 1], leases[i]->addr_);
-        ASSERT_FALSE(returned);
-    }
-
-    // Verify getting a collection of leases by type, DUID, and IAID.
-    // Iterate over the lease types, asking for leases based on
-    // lease type, DUID, and IAID.
-    for (int i = 0; i < 3; ++i) {
-        Lease6Collection returned = lmptr_->getLeases6(leasetype6_[i],
-                                                       *duid, 142);
-        // We should match two per lease type.
-        ASSERT_EQ(2, returned.size());
-
-        // Collection order returned is not guaranteed.
-        // Easiest way to check is to look at the addresses.
-        vector<string> addresses;
-        for (Lease6Collection::const_iterator it = returned.begin();
-            it != returned.end(); ++it) {
-            addresses.push_back((*it)->addr_.toText());
-        }
-        sort(addresses.begin(), addresses.end());
-
-        // Now verify that the lease addresses match.
-        EXPECT_EQ(addresses[0], leases[(i * 2)]->addr_.toText());
-        EXPECT_EQ(addresses[1], leases[(i * 2 + 1)]->addr_.toText());
-    }
-
-    // Verify getting a collection of leases by type, DUID, IAID, and subnet id.
-    // Iterate over the lease types, asking for leases based on
-    // lease type, DUID, IAID, and subnet_id.
-    for (int i = 0; i < 3; ++i) {
-        Lease6Collection returned = lmptr_->getLeases6(leasetype6_[i],
-                                                   *duid, 142, 23);
-        // We should match one per lease type.
-        ASSERT_EQ(1, returned.size());
-        EXPECT_TRUE(*(returned[0]) == *leases[i * 2]);
-    }
-
-    // Verify getting a single lease by type, duid, iad, and subnet id.
-    for (int i = 0; i < 6; ++i) {
-        Lease6Ptr returned = lmptr_->getLease6(leasetype6_[i / 2],
-                                                *duid, 142, (23 + (i % 2)));
-        // We should match one per lease type.
-        ASSERT_TRUE(returned);
-        EXPECT_TRUE(*returned == *leases[i]);
-    }
+    testLease6LeaseTypeCheck();
 }
 
 /// @brief Check GetLease6 methods - access by DUID/IAID/SubnetID
@@ -1002,180 +454,25 @@ TEST_F(MySqlLeaseMgrTest, lease6LeaseTypeCheck) {
 /// Adds leases to the database and checks that they can be accessed via
 /// a combination of DIUID and IAID.
 TEST_F(MySqlLeaseMgrTest, getLease6DuidIaidSubnetId) {
-    // Get the leases to be used for the test and add them to the database.
-    vector<Lease6Ptr> leases = createLeases6();
-    for (int i = 0; i < leases.size(); ++i) {
-        EXPECT_TRUE(lmptr_->addLease(leases[i]));
-    }
-
-    // Get the leases matching the DUID and IAID of lease[1].
-    Lease6Ptr returned = lmptr_->getLease6(leasetype6_[1], *leases[1]->duid_,
-                                           leases[1]->iaid_,
-                                           leases[1]->subnet_id_);
-    ASSERT_TRUE(returned);
-    EXPECT_TRUE(*returned == *leases[1]);
-
-    // Modify each of the three parameters (DUID, IAID, Subnet ID) and
-    // check that nothing is returned.
-    returned = lmptr_->getLease6(leasetype6_[1], *leases[1]->duid_,
-                                 leases[1]->iaid_ + 1, leases[1]->subnet_id_);
-    EXPECT_FALSE(returned);
-
-    returned = lmptr_->getLease6(leasetype6_[1], *leases[1]->duid_,
-                                 leases[1]->iaid_, leases[1]->subnet_id_ + 1);
-    EXPECT_FALSE(returned);
-
-    // 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_->getLease6(leasetype6_[1], new_duid, leases[1]->iaid_,
-                                 leases[1]->subnet_id_);
-    EXPECT_FALSE(returned);
+    testGetLease6DuidIaidSubnetId();
 }
 
-
-// @brief Get Lease4 by DUID, IAID & subnet ID (2)
-//
-// Check that the system can cope with a DUID of any size.
 TEST_F(MySqlLeaseMgrTest, getLease6DuidIaidSubnetIdSize) {
-
-    // Create leases, although we need only one.
-    vector<Lease6Ptr> leases = createLeases6();
-
-    // Now add leases with increasing DUID size can be retrieved.
-    // For speed, go from 0 to 128 is steps of 16.
-    int duid_max = DUID::MAX_DUID_LEN;
-    EXPECT_EQ(128, duid_max);
-
-    int duid_min = DUID::MIN_DUID_LEN;
-    EXPECT_EQ(1, duid_min);
-
-    for (uint8_t i = duid_min; i <= duid_max; i += 16) {
-        vector<uint8_t> duid_vec(i, i);
-        leases[1]->duid_.reset(new DUID(duid_vec));
-        EXPECT_TRUE(lmptr_->addLease(leases[1]));
-        Lease6Ptr returned = lmptr_->getLease6(leasetype6_[1], *leases[1]->duid_,
-                                               leases[1]->iaid_,
-                                               leases[1]->subnet_id_);
-        ASSERT_TRUE(returned);
-        detailCompareLease(leases[1], returned);
-        (void) lmptr_->deleteLease(leases[1]->addr_);
-    }
-
-    // Don't bother to check DUIDs longer than the maximum - these cannot be
-    // constructed, and that limitation is tested in the DUID/Client ID unit
-    // tests.
+    testGetLease6DuidIaidSubnetIdSize();
 }
 
 /// @brief Lease4 update tests
 ///
 /// Checks that we are able to update a lease in the database.
 TEST_F(MySqlLeaseMgrTest, updateLease4) {
-    // Get the leases to be used for the test and add them to the database.
-    vector<Lease4Ptr> leases = createLeases4();
-    for (int i = 0; i < leases.size(); ++i) {
-        EXPECT_TRUE(lmptr_->addLease(leases[i]));
-    }
-
-    // Modify some fields in lease 1 (not the address) and update it.
-    ++leases[1]->subnet_id_;
-    leases[1]->valid_lft_ *= 2;
-    leases[1]->hostname_ = "modified.hostname.";
-    leases[1]->fqdn_fwd_ = !leases[1]->fqdn_fwd_;
-    leases[1]->fqdn_rev_ = !leases[1]->fqdn_rev_;;
-    lmptr_->updateLease4(leases[1]);
-
-    // ... and check what is returned is what is expected.
-    Lease4Ptr l_returned = lmptr_->getLease4(ioaddress4_[1]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[1], l_returned);
-
-    // Alter the lease again and check.
-    ++leases[1]->subnet_id_;
-    leases[1]->cltt_ += 6;
-    lmptr_->updateLease4(leases[1]);
-
-    // Explicitly clear the returned pointer before getting new data to ensure
-    // that the new data is returned.
-    l_returned.reset();
-    l_returned = lmptr_->getLease4(ioaddress4_[1]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[1], l_returned);
-
-    // Check we can do an update without changing data.
-    lmptr_->updateLease4(leases[1]);
-    l_returned.reset();
-    l_returned = lmptr_->getLease4(ioaddress4_[1]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[1], l_returned);
-
-    // Try to update the lease with the too long hostname.
-    leases[1]->hostname_.assign(256, 'a');
-    EXPECT_THROW(lmptr_->updateLease4(leases[1]), isc::dhcp::DbOperationError);
-
-    // Try updating a lease not in the database.
-    lmptr_->deleteLease(ioaddress4_[2]);
-    EXPECT_THROW(lmptr_->updateLease4(leases[2]), isc::dhcp::NoSuchLease);
+    testUpdateLease4();
 }
 
 /// @brief Lease6 update tests
 ///
 /// Checks that we are able to update a lease in the database.
 TEST_F(MySqlLeaseMgrTest, updateLease6) {
-    // 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
-
-    // Add a lease to the database and check that the lease is there.
-    EXPECT_TRUE(lmptr_->addLease(leases[1]));
-    lmptr_->commit();
-
-    Lease6Ptr l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[1], l_returned);
-
-    // Modify some fields in lease 1 (not the address) and update it.
-    ++leases[1]->iaid_;
-    leases[1]->type_ = Lease::TYPE_PD;
-    leases[1]->valid_lft_ *= 2;
-    leases[1]->hostname_ = "modified.hostname.v6.";
-    leases[1]->fqdn_fwd_ = !leases[1]->fqdn_fwd_;
-    leases[1]->fqdn_rev_ = !leases[1]->fqdn_rev_;;
-    lmptr_->updateLease6(leases[1]);
-    lmptr_->commit();
-
-    // ... and check what is returned is what is expected.
-    l_returned.reset();
-    l_returned = lmptr_->getLease6(Lease::TYPE_PD, ioaddress6_[1]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[1], l_returned);
-
-    // Alter the lease again and check.
-    ++leases[1]->iaid_;
-    leases[1]->type_ = Lease::TYPE_TA;
-    leases[1]->cltt_ += 6;
-    leases[1]->prefixlen_ = 93;
-    lmptr_->updateLease6(leases[1]);
-
-    l_returned.reset();
-    l_returned = lmptr_->getLease6(Lease::TYPE_TA, ioaddress6_[1]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[1], l_returned);
-
-    // Check we can do an update without changing data.
-    lmptr_->updateLease6(leases[1]);
-    l_returned.reset();
-    l_returned = lmptr_->getLease6(Lease::TYPE_TA, ioaddress6_[1]);
-    ASSERT_TRUE(l_returned);
-    detailCompareLease(leases[1], l_returned);
-
-    // Try to update the lease with the too long hostname.
-    leases[1]->hostname_.assign(256, 'a');
-    EXPECT_THROW(lmptr_->updateLease6(leases[1]), isc::dhcp::DbOperationError);
-
-    // Try updating a lease not in the database.
-    EXPECT_THROW(lmptr_->updateLease6(leases[2]), isc::dhcp::NoSuchLease);
+    testUpdateLease6();
 }
 
 }; // Of anonymous namespace

src/lib/dhcpsrv/tests/test_utils.cc

@@ -1,4 +1,4 @@
-// Copyright (C) 2012-2013 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2012-2014 Internet Systems Consortium, Inc. ("ISC")
 //
 // Permission to use, copy, modify, and/or distribute this software for any
 // purpose with or without fee is hereby granted, provided that the above
@@ -24,24 +24,6 @@ namespace isc {
 namespace dhcp {
 namespace test {
 
-// IPv4 and IPv6 addresses used in the tests
-const char* ADDRESS4[] = {
-    "192.0.2.0", "192.0.2.1", "192.0.2.2", "192.0.2.3",
-    "192.0.2.4", "192.0.2.5", "192.0.2.6", "192.0.2.7",
-    NULL
-};
-const char* ADDRESS6[] = {
-    "2001:db8::0", "2001:db8::1", "2001:db8::2", "2001:db8::3",
-    "2001:db8::4", "2001:db8::5", "2001:db8::6", "2001:db8::7",
-    NULL
-};
-
-// Lease types that correspond to ADDRESS6 leases
-static const Lease::Type LEASETYPE6[] = {
-    Lease::TYPE_NA, Lease::TYPE_TA, Lease::TYPE_PD, Lease::TYPE_NA,
-    Lease::TYPE_TA, Lease::TYPE_PD, Lease::TYPE_NA, Lease::TYPE_TA
-};
-
 void
 detailCompareLease(const Lease4Ptr& first, const Lease4Ptr& second) {
     // Compare address strings.  Comparison of address objects is not used, as
@@ -98,486 +80,6 @@ detailCompareLease(const Lease6Ptr& first, const Lease6Ptr& second) {
     EXPECT_EQ(first->hostname_, second->hostname_);
 }
 
-GenericLeaseMgrTest::GenericLeaseMgrTest()
-    : lmptr_(NULL) {
-    // Initialize address strings and IOAddresses
-    for (int i = 0; ADDRESS4[i] != NULL; ++i) {
-        string addr(ADDRESS4[i]);
-        straddress4_.push_back(addr);
-        IOAddress ioaddr(addr);
-        ioaddress4_.push_back(ioaddr);
-    }
-
-    for (int i = 0; ADDRESS6[i] != NULL; ++i) {
-        string addr(ADDRESS6[i]);
-        straddress6_.push_back(addr);
-        IOAddress ioaddr(addr);
-        ioaddress6_.push_back(ioaddr);
-
-        /// Let's create different lease types. We use LEASETYPE6 values as
-        /// a template
-        leasetype6_.push_back(LEASETYPE6[i]);
-    }
-}
-
-GenericLeaseMgrTest::~GenericLeaseMgrTest() {
-    // Does nothing. The derived classes are expected to clean up, i.e.
-    // remove the lmptr_ pointer.
-}
-
-/// @brief Initialize Lease4 Fields
-///
-/// Returns a pointer to a Lease4 structure.  Different values are put into
-/// the lease according to the address passed.
-///
-/// This is just a convenience function for the test methods.
-///
-/// @param address Address to use for the initialization
-///
-/// @return Lease4Ptr.  This will not point to anything if the
-///         initialization failed (e.g. unknown address).
-Lease4Ptr
-GenericLeaseMgrTest::initializeLease4(std::string address) {
-    Lease4Ptr lease(new Lease4());
-
-    // Set the address of the lease
-    lease->addr_ = IOAddress(address);
-
-    // Initialize unused fields.
-    lease->ext_ = 0;                            // Not saved
-    lease->t1_ = 0;                             // Not saved
-    lease->t2_ = 0;                             // Not saved
-    lease->fixed_ = false;                      // Unused
-    lease->comments_ = std::string("");         // Unused
-
-    // Set other parameters.  For historical reasons, address 0 is not used.
-    if (address == straddress4_[0]) {
-        lease->hwaddr_ = vector<uint8_t>(6, 0x08);
-        lease->client_id_ = ClientIdPtr(new ClientId(vector<uint8_t>(8, 0x42)));
-        lease->valid_lft_ = 8677;
-        lease->cltt_ = 168256;
-        lease->subnet_id_ = 23;
-        lease->fqdn_rev_ = true;
-        lease->fqdn_fwd_ = false;
-        lease->hostname_ = "myhost.example.com.";
-
-        } else if (address == straddress4_[1]) {
-        lease->hwaddr_ = vector<uint8_t>(6, 0x19);
-        lease->client_id_ = ClientIdPtr(
-            new ClientId(vector<uint8_t>(8, 0x53)));
-        lease->valid_lft_ = 3677;
-        lease->cltt_ = 123456;
-        lease->subnet_id_ = 73;
-        lease->fqdn_rev_ = true;
-        lease->fqdn_fwd_ = true;
-        lease->hostname_ = "myhost.example.com.";
-
-    } else if (address == straddress4_[2]) {
-        lease->hwaddr_ = vector<uint8_t>(6, 0x2a);
-        lease->client_id_ = ClientIdPtr(new ClientId(vector<uint8_t>(8, 0x64)));
-        lease->valid_lft_ = 5412;
-        lease->cltt_ = 234567;
-        lease->subnet_id_ = 73;                         // Same as lease 1
-        lease->fqdn_rev_ = false;
-        lease->fqdn_fwd_ = false;
-        lease->hostname_ = "";
-
-    } else if (address == straddress4_[3]) {
-        lease->hwaddr_ = vector<uint8_t>(6, 0x19);      // Same as lease 1
-        lease->client_id_ = ClientIdPtr(
-            new ClientId(vector<uint8_t>(8, 0x75)));
-
-        // The times used in the next tests are deliberately restricted - we
-        // should be able to cope with valid lifetimes up to 0xffffffff.
-        //  However, this will lead to overflows.
-        // @TODO: test overflow conditions when code has been fixed
-        lease->valid_lft_ = 7000;
-        lease->cltt_ = 234567;
-        lease->subnet_id_ = 37;
-        lease->fqdn_rev_ = true;
-        lease->fqdn_fwd_ = true;
-        lease->hostname_ = "otherhost.example.com.";
-
-    } else if (address == straddress4_[4]) {
-        lease->hwaddr_ = vector<uint8_t>(6, 0x4c);
-        // Same ClientId as straddr4_[1]
-        lease->client_id_ = ClientIdPtr(
-            new ClientId(vector<uint8_t>(8, 0x53)));    // Same as lease 1
-        lease->valid_lft_ = 7736;
-        lease->cltt_ = 222456;
-        lease->subnet_id_ = 85;
-        lease->fqdn_rev_ = true;
-        lease->fqdn_fwd_ = true;
-        lease->hostname_ = "otherhost.example.com.";
-
-    } else if (address == straddress4_[5]) {
-        lease->hwaddr_ = vector<uint8_t>(6, 0x19);      // Same as lease 1
-        // Same ClientId and IAID as straddress4_1
-        lease->client_id_ = ClientIdPtr(
-            new ClientId(vector<uint8_t>(8, 0x53)));    // Same as lease 1
-        lease->valid_lft_ = 7832;
-        lease->cltt_ = 227476;
-        lease->subnet_id_ = 175;
-        lease->fqdn_rev_ = false;
-        lease->fqdn_fwd_ = false;
-        lease->hostname_ = "otherhost.example.com.";
-    } else if (address == straddress4_[6]) {
-        lease->hwaddr_ = vector<uint8_t>(6, 0x6e);
-        // Same ClientId as straddress4_1
-        lease->client_id_ = ClientIdPtr(
-            new ClientId(vector<uint8_t>(8, 0x53)));    // Same as lease 1
-        lease->valid_lft_ = 1832;
-        lease->cltt_ = 627476;
-        lease->subnet_id_ = 112;
-        lease->fqdn_rev_ = false;
-        lease->fqdn_fwd_ = true;
-        lease->hostname_ = "myhost.example.com.";
-
-    } else if (address == straddress4_[7]) {
-        lease->hwaddr_ = vector<uint8_t>();             // Empty
-        lease->client_id_ = ClientIdPtr();              // Empty
-        lease->valid_lft_ = 7975;
-        lease->cltt_ = 213876;
-        lease->subnet_id_ = 19;
-        lease->fqdn_rev_ = true;
-        lease->fqdn_fwd_ = true;
-        lease->hostname_ = "myhost.example.com.";
-
-    } else {
-        // Unknown address, return an empty pointer.
-        lease.reset();
-
-    }
-
-    return (lease);
-}
-
-/// @brief Initialize Lease6 Fields
-///
-/// Returns a pointer to a Lease6 structure.  Different values are put into
-/// the lease according to the address passed.
-///
-/// This is just a convenience function for the test methods.
-///
-/// @param address Address to use for the initialization
-///
-/// @return Lease6Ptr.  This will not point to anything if the initialization
-///         failed (e.g. unknown address).
-Lease6Ptr
-GenericLeaseMgrTest::initializeLease6(std::string address) {
-    Lease6Ptr lease(new Lease6());
-
-    // Set the address of the lease
-    lease->addr_ = IOAddress(address);
-
-    // Initialize unused fields.
-    lease->t1_ = 0;                             // Not saved
-    lease->t2_ = 0;                             // Not saved
-    lease->fixed_ = false;                      // Unused
-    lease->comments_ = std::string("");         // Unused
-
-    // Set other parameters.  For historical reasons, address 0 is not used.
-    if (address == straddress6_[0]) {
-        lease->type_ = leasetype6_[0];
-        lease->prefixlen_ = 4;
-        lease->iaid_ = 142;
-        lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x77)));
-        lease->preferred_lft_ = 900;
-        lease->valid_lft_ = 8677;
-        lease->cltt_ = 168256;
-        lease->subnet_id_ = 23;
-        lease->fqdn_fwd_ = true;
-        lease->fqdn_rev_ = true;
-        lease->hostname_ = "myhost.example.com.";
-
-    } else if (address == straddress6_[1]) {
-        lease->type_ = leasetype6_[1];
-        lease->prefixlen_ = 0;
-        lease->iaid_ = 42;
-        lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x42)));
-        lease->preferred_lft_ = 3600;
-        lease->valid_lft_ = 3677;
-        lease->cltt_ = 123456;
-        lease->subnet_id_ = 73;
-        lease->fqdn_fwd_ = false;
-        lease->fqdn_rev_ = true;
-        lease->hostname_ = "myhost.example.com.";
-
-    } else if (address == straddress6_[2]) {
-        lease->type_ = leasetype6_[2];
-        lease->prefixlen_ = 7;
-        lease->iaid_ = 89;
-        lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x3a)));
-        lease->preferred_lft_ = 1800;
-        lease->valid_lft_ = 5412;
-        lease->cltt_ = 234567;
-        lease->subnet_id_ = 73;                     // Same as lease 1
-        lease->fqdn_fwd_ = false;
-        lease->fqdn_rev_ = false;
-        lease->hostname_ = "myhost.example.com.";
-
-    } else if (address == straddress6_[3]) {
-        lease->type_ = leasetype6_[3];
-        lease->prefixlen_ = 28;
-        lease->iaid_ = 0xfffffffe;
-        vector<uint8_t> duid;
-        for (uint8_t i = 31; i < 126; ++i) {
-            duid.push_back(i);
-        }
-        lease->duid_ = DuidPtr(new DUID(duid));
-
-        // The times used in the next tests are deliberately restricted - we
-        // should be able to cope with valid lifetimes up to 0xffffffff.
-        //  However, this will lead to overflows.
-        // @TODO: test overflow conditions when code has been fixed
-        lease->preferred_lft_ = 7200;
-        lease->valid_lft_ = 7000;
-        lease->cltt_ = 234567;
-        lease->subnet_id_ = 37;
-        lease->fqdn_fwd_ = true;
-        lease->fqdn_rev_ = false;
-        lease->hostname_ = "myhost.example.com.";
-
-    } else if (address == straddress6_[4]) {
-        // Same DUID and IAID as straddress6_1
-        lease->type_ = leasetype6_[4];
-        lease->prefixlen_ = 15;
-        lease->iaid_ = 42;
-        lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x42)));
-        lease->preferred_lft_ = 4800;
-        lease->valid_lft_ = 7736;
-        lease->cltt_ = 222456;
-        lease->subnet_id_ = 671;
-        lease->fqdn_fwd_ = true;
-        lease->fqdn_rev_ = true;
-        lease->hostname_ = "otherhost.example.com.";
-
-    } else if (address == straddress6_[5]) {
-        // Same DUID and IAID as straddress6_1
-        lease->type_ = leasetype6_[5];
-        lease->prefixlen_ = 24;
-        lease->iaid_ = 42;                          // Same as lease 4
-        lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x42)));
-        // Same as lease 4
-        lease->preferred_lft_ = 5400;
-        lease->valid_lft_ = 7832;
-        lease->cltt_ = 227476;
-        lease->subnet_id_ = 175;
-        lease->fqdn_fwd_ = false;
-        lease->fqdn_rev_ = true;
-        lease->hostname_ = "hostname.example.com.";
-
-    } else if (address == straddress6_[6]) {
-        // Same DUID as straddress6_1
-        lease->type_ = leasetype6_[6];
-        lease->prefixlen_ = 24;
-        lease->iaid_ = 93;
-        lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x42)));
-        // Same as lease 4
-        lease->preferred_lft_ = 5400;
-        lease->valid_lft_ = 1832;
-        lease->cltt_ = 627476;
-        lease->subnet_id_ = 112;
-        lease->fqdn_fwd_ = false;
-        lease->fqdn_rev_ = true;
-        lease->hostname_ = "hostname.example.com.";
-
-    } else if (address == straddress6_[7]) {
-        // Same IAID as straddress6_1
-        lease->type_ = leasetype6_[7];
-        lease->prefixlen_ = 24;
-        lease->iaid_ = 42;
-        lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0xe5)));
-        lease->preferred_lft_ = 5600;
-        lease->valid_lft_ = 7975;
-        lease->cltt_ = 213876;
-        lease->subnet_id_ = 19;
-        lease->fqdn_fwd_ = false;
-        lease->fqdn_rev_ = true;
-        lease->hostname_ = "hostname.example.com.";
-
-    } else {
-        // Unknown address, return an empty pointer.
-        lease.reset();
-
-    }
-
-    return (lease);
-}
-
-/// @brief Check Leases present and different
-///
-/// Checks a vector of lease pointers and ensures that all the leases
-/// they point to are present and different.  If not, a GTest assertion
-/// will fail.
-///
-/// @param leases Vector of pointers to leases
-template <typename T>
-void GenericLeaseMgrTest::checkLeasesDifferent(const std::vector<T>& leases) const {
-
-    // Check they were created
-    for (int i = 0; i < leases.size(); ++i) {
-        ASSERT_TRUE(leases[i]);
-    }
-
-    // Check they are different
-    for (int i = 0; i < (leases.size() - 1); ++i) {
-        for (int j = (i + 1); j < leases.size(); ++j) {
-            stringstream s;
-            s << "Comparing leases " << i << " & " << j << " for equality";
-            SCOPED_TRACE(s.str());
-            EXPECT_TRUE(*leases[i] != *leases[j]);
-        }
-    }
-}
-
-/// @brief Creates leases for the test
-///
-/// Creates all leases for the test and checks that they are different.
-///
-/// @return vector<Lease4Ptr> Vector of pointers to leases
-vector<Lease4Ptr>
-GenericLeaseMgrTest::createLeases4() {
-
-    // Create leases for each address
-    vector<Lease4Ptr> leases;
-    for (int i = 0; i < straddress4_.size(); ++i) {
-        leases.push_back(initializeLease4(straddress4_[i]));
-    }
-    EXPECT_EQ(8, leases.size());
-
-    // Check all were created and that they are different.
-    checkLeasesDifferent(leases);
-
-    return (leases);
-}
-
-/// @brief Creates leases for the test
-///
-/// Creates all leases for the test and checks that they are different.
-///
-/// @return vector<Lease6Ptr> Vector of pointers to leases
-vector<Lease6Ptr>
-GenericLeaseMgrTest::createLeases6() {
-
-    // Create leases for each address
-    vector<Lease6Ptr> leases;
-    for (int i = 0; i < straddress6_.size(); ++i) {
-        leases.push_back(initializeLease6(straddress6_[i]));
-    }
-    EXPECT_EQ(8, leases.size());
-
-    // Check all were created and that they are different.
-    checkLeasesDifferent(leases);
-
-    return (leases);
-}
-
-void
-GenericLeaseMgrTest::testGetLease4ClientId() {
-    // Let's initialize a specific lease ...
-    Lease4Ptr lease = initializeLease4(straddress4_[1]);
-    EXPECT_TRUE(lmptr_->addLease(lease));
-    Lease4Collection returned = lmptr_->getLease4(*lease->client_id_);
-
-    ASSERT_EQ(1, 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());
-}
-
-void
-GenericLeaseMgrTest::testGetLease4NullClientId() {
-    // Let's initialize a specific lease ... But this time
-    // We keep its client id for further lookup and
-    // We clearly 'reset' it ...
-    Lease4Ptr leaseA = initializeLease4(straddress4_[4]);
-    ClientIdPtr client_id = leaseA->client_id_;
-    leaseA->client_id_ = ClientIdPtr();
-    ASSERT_TRUE(lmptr_->addLease(leaseA));
-
-    Lease4Collection returned = lmptr_->getLease4(*client_id);
-    // Shouldn't have our previous lease ...
-    ASSERT_TRUE(returned.empty());
-
-    // Add another lease with the non-NULL client id, and make sure that the
-    // lookup will not break due to existence of both leases with non-NULL and
-    // NULL client ids.
-    Lease4Ptr leaseB = initializeLease4(straddress4_[0]);
-    // Shouldn't throw any null pointer exception
-    ASSERT_TRUE(lmptr_->addLease(leaseB));
-    // Try to get the lease.
-    returned = lmptr_->getLease4(*client_id);
-    ASSERT_TRUE(returned.empty());
-
-    // Let's make it more interesting and add another lease with NULL client id.
-    Lease4Ptr leaseC = initializeLease4(straddress4_[5]);
-    leaseC->client_id_.reset();
-    ASSERT_TRUE(lmptr_->addLease(leaseC));
-    returned = lmptr_->getLease4(*client_id);
-    ASSERT_TRUE(returned.empty());
-
-    // But getting the lease with non-NULL client id should be successful.
-    returned = lmptr_->getLease4(*leaseB->client_id_);
-    ASSERT_EQ(1, returned.size());
-}
-
-void
-GenericLeaseMgrTest::testGetLease4HWAddr() {
-    // Let's initialize two different leases 4 and just add the first ...
-    Lease4Ptr leaseA = initializeLease4(straddress4_[5]);
-    HWAddr hwaddrA(leaseA->hwaddr_, HTYPE_ETHER);
-    HWAddr hwaddrB(vector<uint8_t>(6, 0x80), HTYPE_ETHER);
-
-    EXPECT_TRUE(lmptr_->addLease(leaseA));
-
-    // we should not have a lease, with this MAC Addr
-    Lease4Collection returned = lmptr_->getLease4(hwaddrB);
-    ASSERT_EQ(0, returned.size());
-
-    // But with this one
-    returned = lmptr_->getLease4(hwaddrA);
-    ASSERT_EQ(1, returned.size());
-}
-
-void
-GenericLeaseMgrTest::testGetLease4ClientIdHWAddrSubnetId() {
-    Lease4Ptr leaseA = initializeLease4(straddress4_[4]);
-    Lease4Ptr leaseB = initializeLease4(straddress4_[5]);
-    Lease4Ptr leaseC = initializeLease4(straddress4_[6]);
-    // Set NULL client id for one of the leases. This is to make sure that such
-    // a lease may coexist with other leases with non NULL client id.
-    leaseC->client_id_.reset();
-
-    HWAddr hwaddrA(leaseA->hwaddr_, HTYPE_ETHER);
-    HWAddr hwaddrB(leaseB->hwaddr_, HTYPE_ETHER);
-    HWAddr hwaddrC(leaseC->hwaddr_, HTYPE_ETHER);
-    EXPECT_TRUE(lmptr_->addLease(leaseA));
-    EXPECT_TRUE(lmptr_->addLease(leaseB));
-    EXPECT_TRUE(lmptr_->addLease(leaseC));
-    // First case we should retrieve our lease
-    Lease4Ptr lease = lmptr_->getLease4(*leaseA->client_id_, hwaddrA, leaseA->subnet_id_);
-    detailCompareLease(lease, leaseA);
-    // Retrieve the other lease.
-    lease = lmptr_->getLease4(*leaseB->client_id_, hwaddrB, leaseB->subnet_id_);
-    detailCompareLease(lease, leaseB);
-    // The last lease has NULL client id so we will use a different getLease4 function
-    // which doesn't require client id (just a hwaddr and subnet id).
-    lease = lmptr_->getLease4(hwaddrC, leaseC->subnet_id_);
-    detailCompareLease(lease, leaseC);
-
-    // An attempt to retrieve the lease with non matching lease parameters should
-    // result in NULL pointer being returned.
-    lease = lmptr_->getLease4(*leaseA->client_id_, hwaddrB, leaseA->subnet_id_);
-    EXPECT_FALSE(lease);
-    lease = lmptr_->getLease4(*leaseA->client_id_, hwaddrA, leaseB->subnet_id_);
-    EXPECT_FALSE(lease);
-}
-
-
-};
-};
-};
+}; // namespace test
+}; // namespace dhcp
+}; // namespace isc

src/lib/dhcpsrv/tests/test_utils.h

@@ -1,4 +1,4 @@
-// Copyright (C) 2012-2013 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2012-2014 Internet Systems Consortium, Inc. ("ISC")
 //
 // Permission to use, copy, modify, and/or distribute this software for any
 // purpose with or without fee is hereby granted, provided that the above
@@ -43,93 +43,8 @@ detailCompareLease(const Lease6Ptr& first, const Lease6Ptr& second);
 void
 detailCompareLease(const Lease4Ptr& first, const Lease4Ptr& second);
 
-/// @brief Test Fixture class with utility functions for LeaseMgr backends
-///
-/// It contains utility functions, like dummy lease creation.
-/// All concrete LeaseMgr test classes should be derived from it.
-class GenericLeaseMgrTest : public ::testing::Test {
-public:
-
-    /// @brief Default constructor.
-    GenericLeaseMgrTest();
-
-    /// @brief Virtual destructor.
-    virtual ~GenericLeaseMgrTest();
-
-    /// @brief Initialize Lease4 Fields
-    ///
-    /// Returns a pointer to a Lease4 structure.  Different values are put into
-    /// the lease according to the address passed.
-    ///
-    /// This is just a convenience function for the test methods.
-    ///
-    /// @param address Address to use for the initialization
-    ///
-    /// @return Lease4Ptr.  This will not point to anything if the
-    ///         initialization failed (e.g. unknown address).
-    Lease4Ptr initializeLease4(std::string address);
-
-    /// @brief Initialize Lease6 Fields
-    ///
-    /// Returns a pointer to a Lease6 structure.  Different values are put into
-    /// the lease according to the address passed.
-    ///
-    /// This is just a convenience function for the test methods.
-    ///
-    /// @param address Address to use for the initialization
-    ///
-    /// @return Lease6Ptr.  This will not point to anything if the initialization
-    ///         failed (e.g. unknown address).
-    Lease6Ptr initializeLease6(std::string address);
-
-    /// @brief Check Leases present and different
-    ///
-    /// Checks a vector of lease pointers and ensures that all the leases
-    /// they point to are present and different.  If not, a GTest assertion
-    /// will fail.
-    ///
-    /// @param leases Vector of pointers to leases
-    template <typename T>
-    void checkLeasesDifferent(const std::vector<T>& leases) const;
-
-    /// @brief Creates leases for the test
-    ///
-    /// Creates all leases for the test and checks that they are different.
-    ///
-    /// @return vector<Lease4Ptr> Vector of pointers to leases
-    std::vector<Lease4Ptr> createLeases4();
-
-    /// @brief Creates leases for the test
-    ///
-    /// Creates all leases for the test and checks that they are different.
-    ///
-    /// @return vector<Lease6Ptr> Vector of pointers to leases
-    std::vector<Lease6Ptr> createLeases6();
-
-    /// @brief Test lease retrieval using client id.
-    void testGetLease4ClientId();
-
-    /// @brief Test lease retrieval when leases with NULL client id are present.
-    void testGetLease4NullClientId();
-
-    /// @brief Test lease retrieval using HW address.
-    void testGetLease4HWAddr();
-
-    /// @brief Test lease retrieval using client id, HW address and subnet id.
-    void testGetLease4ClientIdHWAddrSubnetId();
-
-    // Member variables
-    std::vector<std::string>  straddress4_;   ///< String forms of IPv4 addresses
-    std::vector<isc::asiolink::IOAddress> ioaddress4_;  ///< IOAddress forms of IPv4 addresses
-    std::vector<std::string>  straddress6_;   ///< String forms of IPv6 addresses
-    std::vector<Lease::Type> leasetype6_; ///< Lease types
-    std::vector<isc::asiolink::IOAddress> ioaddress6_;  ///< IOAddress forms of IPv6 addresses
-
-    LeaseMgr* lmptr_;                     ///< Pointer to the lease manager
-};
-
-};
-};
-};
+}; // namespace test
+}; // namespace dhcp
+}; // namespace isc
 
 #endif