public void FewestConsecutiveSubnetsFor_Input_Null_ThrowsArgumentNullException_Test(IPAddress alpha,
IPAddress beta)
{
// Act
// Assert
Assert.Throws <ArgumentNullException>(() => SubnetUtilities.FewestConsecutiveSubnetsFor(alpha, beta));
}
public void FewestConsecutiveSubnetsFor_MissMatchAddressFamilies_ThrowsInvalidOperationException_Test(IPAddress alpha,
IPAddress beta)
{
// Act
// Assert
Assert.Throws <InvalidOperationException>(() => SubnetUtilities.FewestConsecutiveSubnetsFor(alpha, beta));
}
public void SmallestSubnet_NullInput_ReturnsNull_Test()
{
// Arrange
// Act
var result = SubnetUtilities.SmallestSubnet(null);
// Assert
Assert.Null(result);
}
public void FewestConsecutiveSubnetsForMissMatchAddressFamiliesTest(string alpha,
string beta)
{
// Arrange
var alphaAddress = IPAddress.Parse(alpha);
var betaAddress = IPAddress.Parse(beta);
// Assert
Assert.Throws <InvalidOperationException>(() => SubnetUtilities.FewestConsecutiveSubnetsFor(alphaAddress, betaAddress));
}
public void SmallestSubnet_EmptyInput_ReturnsNull_Test()
{
// Arrange
var subnets = Enumerable.Empty <Subnet>();
// Act
var result = SubnetUtilities.SmallestSubnet(subnets);
// Assert
Assert.Null(result);
}
public void LargestSubnetLargestOfNoneTest()
{
// Arrange
var subnets = new Subnet[] {};
// Act
var result = SubnetUtilities.LargestSubnet(subnets);
// Assert
Assert.IsNull(result);
}
public void FewestConsecutiveSubnetsFor_Example()
{
// Arrange
var left = IPAddress.Parse("192.168.1.3");
var right = IPAddress.Parse("192.168.1.5");
// Act
var result = SubnetUtilities.FewestConsecutiveSubnetsFor(left, right)
.ToArray();
// Assert
Assert.Equal(2, result.Length);
Assert.Contains(Subnet.Parse("192.168.1.4/31"), result);
Assert.Contains(Subnet.Parse("192.168.1.3/32"), result);
}
public void SmallestSubnet_Example()
{
// Arrange
var tall = Subnet.Parse("255.255.255.254/31"); // 2^1 = 2
var grande = Subnet.Parse("192.168.1.0/24"); // 2^8 = 256
var vente = Subnet.Parse("10.10.0.0/16"); // 2^16 = 65536
var trenta = Subnet.Parse("16.240.0.0/12"); // 2^20 = 1048576
var subnets = new[] { tall, grande, vente, trenta };
// Act
var result = SubnetUtilities.SmallestSubnet(subnets);
// Assert
Assert.Equal(tall, result);
}
public void SmallestSubnet_Single_ReturnSingle_Test()
{
// Arrange
var expected = new Subnet(IPAddress.Any, 16);
var subnets = new[]
{
expected
};
// Act
var result = SubnetUtilities.SmallestSubnet(subnets);
// Assert
Assert.Same(expected, result);
}
public void LargestSubnetLargestOfOneTest()
{
// Arrange
var expected = new Subnet(IPAddress.Any, 16);
var subnets = new[]
{
expected
};
// Act
var result = SubnetUtilities.LargestSubnet(subnets);
// Assert
Assert.AreSame(expected, result);
}
public void FewestConsecutiveSubnetsForTest(string alpha,
string beta,
string[] results)
{
var subnets = SubnetUtilities.FewestConsecutiveSubnetsFor(IPAddress.Parse(alpha), IPAddress.Parse(beta))
.ToList();
var subnetExpectedResults = results.Select(Subnet.Parse)
.ToList();
Assert.IsNotNull(subnets);
Assert.IsNotEmpty(subnets);
Assert.AreEqual(results.Length, subnets.Distinct()
.Count());
CollectionAssert.IsSubsetOf(subnets, subnetExpectedResults);
CollectionAssert.IsOrdered(subnets.Select(s => s.NetworkPrefixAddress), new DefaultIPAddressComparer());
}
public void SmallestSubnet_Ambiguous_ReturnsOneOfSmallest_Test()
{
// Arrange
var subnets = new[]
{
new Subnet(IPAddress.Any, 24),
new Subnet(IPAddress.Any, 32),
new Subnet(IPAddress.Any, 32),
new Subnet(IPAddress.Any, 16)
};
// Act
var result = SubnetUtilities.SmallestSubnet(subnets);
// Assert
Assert.Equal(new Subnet(IPAddress.Any, 32), result);
}
public void LargestSubnetAmbiguousLargestOfThreeOneTest()
{
// Arrange
var subnets = new[]
{
new Subnet(IPAddress.Any, 24),
new Subnet(IPAddress.Any, 16),
new Subnet(IPAddress.Any, 16),
new Subnet(IPAddress.Any, 32)
};
// Act
var result = SubnetUtilities.LargestSubnet(subnets);
// Assert
Assert.AreEqual(new Subnet(IPAddress.Any, 16), result);
}
public void LargestSubnet_ReturnsLargest_Test()
{
// Arrange
var expected = new Subnet(IPAddress.Any, 16);
var subnets = new[]
{
expected,
new Subnet(IPAddress.Any, 24),
new Subnet(IPAddress.Any, 32)
};
// Act
var result = SubnetUtilities.LargestSubnet(subnets);
// Assert
Assert.Same(expected, result);
}
public void SmallestSubnetSmallestOfThreeOneTest()
{
// Arrange
var expected = new Subnet(IPAddress.Any, 32);
var subnets = new[]
{
expected,
new Subnet(IPAddress.Any, 24),
new Subnet(IPAddress.Any, 16)
};
// Act
var result = SubnetUtilities.SmallestSubnet(subnets);
// Assert
Assert.AreSame(expected, result);
}
public void FewestConsecutiveSubnetsFor_Test(IEnumerable <Subnet> expected,
IPAddress left,
IPAddress right)
{
// Arrange
// Act
var result = SubnetUtilities.FewestConsecutiveSubnetsFor(left, right)
.ToList();
// Assert
Assert.NotNull(result);
Assert.NotEmpty(result);
Assert.All(result, Assert.NotNull);
var expectedList = expected.ToList();
// Assert.Equal(expectedList, result); // directly calling Assert.Equals results in unexpected behavior; unwinding equality explicitly
Assert.Equal(expectedList.Count, result.Count);
Assert.All(expectedList, subnet => Assert.Contains(subnet, result));
Assert.All(result, subnet => Assert.Contains(subnet, expectedList));
Assert.True(result.SequenceEqual(new SortedSet <Subnet>(result, new DefaultIPAddressRangeComparer())));
}
public void FewestConsecutiveSubnetsForNullBetaTest()
{
Assert.Throws <ArgumentNullException>(() => SubnetUtilities.FewestConsecutiveSubnetsFor(IPAddress.Any, null));
}
