}
}
+// This test verifies that an IPv6 subnet can be added to a shared network.
+// It also verifies that two subnets with the same ID can't be added to
+// a shared network and that a single subnet can't be added to two different
+// shared subnets.
+TEST(SharedNetwork6Test, addSubnet6) {
+ // First, create a network.
+ SharedNetwork6Ptr network(new SharedNetwork6());
+
+ // Try to add null pointer. It should throw.
+ Subnet6Ptr subnet;
+ ASSERT_THROW(network->add(subnet), BadValue);
+
+ // Create a valid subnet. It should now be added successfully.
+ subnet.reset(new Subnet6(IOAddress("2001:db8:1::"), 64, 10, 20, 30, 40,
+ SubnetID(15)));
+ ASSERT_NO_THROW(network->add(subnet));
+ ASSERT_EQ(1, network->getAllSubnets()->size());
+
+ // Retrieve the subnet from the network and make sure it is returned
+ // as expected.
+ Subnet6Ptr returned_subnet = network->getAllSubnets()->front();
+ ASSERT_TRUE(returned_subnet);
+ EXPECT_EQ(subnet->getID(), returned_subnet->getID());
+ SharedNetwork6Ptr network1;
+ subnet->getSharedNetwork(network1);
+ ASSERT_TRUE(network1);
+ EXPECT_TRUE(network1 == network);
+
+ // Create another subnet with the same ID. Adding a network with the
+ // same ID should cause an error.
+ Subnet6Ptr subnet2(new Subnet6(IOAddress("3000::"), 16, 10, 20, 30, 40,
+ SubnetID(15)));
+ ASSERT_THROW(network->add(subnet), DuplicateSubnetID);
+
+ // Create another network and try to add a subnet to it. It should fail
+ // because the subnet is already associated with the first network.
+ SharedNetwork6Ptr network2(new SharedNetwork6());
+ ASSERT_THROW(network2->add(subnet), InvalidOperation);
+}
+
+// This test verifies that it is possible to remove a specified subnet.
+TEST(SharedNetwork6Test, delSubnet6) {
+ // Create two subnets and add them to the shared network.
+ Subnet6Ptr subnet1(new Subnet6(IOAddress("2001:db8:1::"), 64, 10, 20, 30,
+ 40, SubnetID(1)));
+ Subnet6Ptr subnet2(new Subnet6(IOAddress("3000::"), 16, 10, 20, 30, 40,
+ SubnetID(2)));
+
+ SharedNetwork6Ptr network(new SharedNetwork6());
+ ASSERT_NO_THROW(network->add(subnet1));
+ ASSERT_NO_THROW(network->add(subnet2));
+
+ // Make sure they have been added successfully.
+ ASSERT_EQ(2, network->getAllSubnets()->size());
+
+ // Try to remove a subnet that doesn't exist in this shared network.
+ // It should cause an error.
+ ASSERT_THROW(network->del(SubnetID(5)), BadValue);
+
+ // Now delete the subnet that exists.
+ ASSERT_NO_THROW(network->del(subnet1->getID()));
+ // We should be left with only one subnet.
+ ASSERT_EQ(1, network->getAllSubnets()->size());
+ Subnet6Ptr subnet_returned = network->getAllSubnets()->front();
+ ASSERT_TRUE(subnet_returned);
+ EXPECT_EQ(subnet2->getID(), subnet_returned->getID());
+
+ // Check that shared network has been cleared for the removed subnet.
+ SharedNetwork6Ptr network1;
+ subnet1->getSharedNetwork(network1);
+ EXPECT_FALSE(network1);
+
+ // Remove another subnet and make sure there are no subnets left.
+ ASSERT_NO_THROW(network->del(subnet2->getID()));
+ EXPECT_EQ(0, network->getAllSubnets()->size());
+
+ // The network pointer should be cleared for this second subnet too.
+ SharedNetwork6Ptr network2;
+ subnet1->getSharedNetwork(network2);
+ EXPECT_FALSE(network2);
+}
+
+// This test verifies that it is possible to iterate over the subnets
+// associated with a particular shared network.
+TEST(SharedNetwork6Test, getNextSubnet) {
+ SharedNetwork6Ptr network(new SharedNetwork6());
+
+ // Create three subnets.
+ Subnet6Ptr subnet1(new Subnet6(IOAddress("2001:db8:1::"), 64, 10, 20, 30,
+ 40, SubnetID(1)));
+ Subnet6Ptr subnet2(new Subnet6(IOAddress("3000::"), 16, 10, 20, 30, 40,
+ SubnetID(2)));
+ Subnet6Ptr subnet3(new Subnet6(IOAddress("2001:db8:2::"), 64, 10, 20, 30,
+ 40, SubnetID(3)));
+ std::vector<Subnet6Ptr> subnets;
+ subnets.push_back(subnet1);
+ subnets.push_back(subnet2);
+ subnets.push_back(subnet3);
+
+ // Subnets have unique IDs so they should successfully be added to the
+ // network.
+ for (auto i = 0; i < subnets.size(); ++i) {
+ ASSERT_NO_THROW(network->add(subnets[i]))
+ << "failed to add subnet with id " << subnets[i]->getID()
+ << " to shared network";
+ }
+
+ // Collect networks associated with our subnets in the vector.
+ std::vector<SharedNetwork6Ptr> networks;
+ for (auto i = 0; i < subnets.size(); ++i) {
+ SharedNetwork6Ptr network;
+ subnets[i]->getSharedNetwork(network);
+ ASSERT_TRUE(network) << "failed to retrieve shared network for a"
+ << " subnet id " << subnets[i]->getID();
+ networks.push_back(network);
+ }
+
+ // All subnets should be associated with the same network.
+ for (auto i = 1; i < networks.size(); ++i) {
+ EXPECT_TRUE(networks[0] == networks[i]);
+ }
+
+ // Perform the test 3 times where each subnet belonging to the shared
+ // network is treated as a "first" subnet in the call to getNextSubnet.
+ for (auto i = 0; i < subnets.size(); ++i) {
+ Subnet6Ptr s = subnets[i];
+
+ // Iterate over the subnets starting from the subnet with index i.
+ for (auto j = 0; j < subnets.size(); ++j) {
+ // Get next subnet (following the one currently in s).
+ s = networks[0]->getNextSubnet(subnets[i], s);
+ // The last iteration should return empty pointer to indicate end of
+ // the subnets within shared network. If we're not at last iteration
+ // check that the subnet identifier of the returned subnet is valid.
+ if (j < subnets.size() - 1) {
+ ASSERT_TRUE(s) << "retrieving next subnet failed for pair of"
+ " indexes (i, j) = (" << i << ", " << j << ")";
+ const auto expected_subnet_id = (i + j + 1) % subnets.size() + 1;
+ EXPECT_EQ(expected_subnet_id, s->getID());
+ } else {
+ // Null subnet returned for a last iteration.
+ ASSERT_FALSE(s) << "expected null pointer to be returned as"
+ " next subnet for pair of indexes (i, j) = ("
+ << i << ", " << j << ")";
+ }
+ }
+ }
+}
+
} // end of anonymous namespace
projects / thirdparty / kea.git / commitdiff
