public void IsValidNetworkPortion_ClassC_InValid_TooHigh()
{
// arrange
var inputAddr = new Ipv4Address(200, 1, 1, 1);
var inputNetworkPortion = 32;
// act
var result = _utils.IsValidNetworkPortion(inputAddr, inputNetworkPortion);
// assert
Assert.False(result);
}
public void IsLegalHostAddress_Illegal_Broadcast()
{
// arrange
var input = new Ipv4Address(192, 168, 1, 127);
ushort inputNetPortion = 25;
// act
var result = _utils.IsLegalHostAddress(input, inputNetPortion);
// assert
Assert.False(result);
}
public void IsLegalHostAddress_LegalC()
{
// arrange
var input = new Ipv4Address(192, 168, 1, 1);
ushort inputNetPortion = 24;
// act
var result = _utils.IsLegalHostAddress(input, inputNetPortion);
// assert
Assert.True(result);
}
public void IsLegalHostAddress_LegalA()
{
// arrange
var input = new Ipv4Address(20, 168, 0, 0);
ushort inputNetPortion = 8;
// act
var result = _utils.IsLegalHostAddress(input, inputNetPortion);
// assert
Assert.True(result);
}
public void IsValidNetworkPortion_ClassC_Valid2()
{
// arrange
var inputAddr = new Ipv4Address(200, 1, 1, 1);
var inputNetworkPortion = 28;
// act
var result = _utils.IsValidNetworkPortion(inputAddr, inputNetworkPortion);
// assert
Assert.True(result);
}
public void IsLegalHostAddress_Illegal_NetworkPortionTooHigh()
{
// arrange
var input = new Ipv4Address(125, 168, 1, 128);
ushort inputNetPortion = 40;
// act
var result = _utils.IsLegalHostAddress(input, inputNetPortion);
// assert
Assert.False(result);
}
public void IsLegalHostAddress_Illegal_Software()
{
// arrange
var input = new Ipv4Address(0, 168, 1, 128);
ushort inputNetPortion = 24;
// act
var result = _utils.IsLegalHostAddress(input, inputNetPortion);
// assert
Assert.False(result);
}
public void GetAddressRange_DocumentationAddressMax_2Range()
{
// arrange
var input = new Ipv4Address(198, 51, 100, 255);
var expected = new DocumentationIpv4Range();
// act
var result = _utils.GetAddressRange(input);
// assert
Assert.NotNull(result);
Assert.AreEqual(expected, result);
}
public void GetAddressRange_PrivateAddressMax_5Range()
{
// arrange
var input = new Ipv4Address(198, 19, 255, 255);
var expected = new PrivateIpv4Range();
// act
var result = _utils.GetAddressRange(input);
// assert
Assert.NotNull(result);
Assert.AreEqual(expected, result);
}
public void GetAddressRange_FutureAddressMin()
{
// arrange
var input = new Ipv4Address(240, 0, 0, 0);
var expected = new FutureIpv4Range();
// act
var result = _utils.GetAddressRange(input);
// assert
Assert.NotNull(result);
Assert.AreEqual(expected, result);
}
public void GetAddressRange_LinkLocalMax_4Range()
{
// arrange
var input = new Ipv4Address(169, 254, 255, 255);
var expected = new LinkLocalIpv4Range();
// act
var result = _utils.GetAddressRange(input);
// assert
Assert.NotNull(result);
Assert.AreEqual(expected, result);
}
public void GetAddressRange_LoopbackMax()
{
// arrange
var input = new Ipv4Address(127, 255, 255, 255);
var expected = new LoopbackIpv4Range();
// act
var result = _utils.GetAddressRange(input);
// assert
Assert.NotNull(result);
Assert.AreEqual(expected, result);
}
public void ToDecimal_Test()
{
// arrange
var expected = new ushort[] { 192, 0, 255, 127 };
var address = new Ipv4Address(expected[0], expected[1], expected[2], expected[3]);
// act
var result = address.ToDecimal();
// assert
Assert.NotNull(result);
Assert.True(expected.SequenceEqual(result));
}
public void GetAddressRange_LimitedBroadCastAddress()
{
// arrange
var input = new Ipv4Address(255, 255, 255, 255);
var expected = new LimitedBroadcastIpv4Range();
// act
var result = _utils.GetAddressRange(input);
// assert
Assert.NotNull(result);
Assert.AreEqual(expected, result);
}
public void GetAddressRange_PublicAddressMax_11Range()
{
// arrange
var input = new Ipv4Address(198, 51, 101, 0);
var expected = new PublicIpv4Range();
// act
var result = _utils.GetAddressRange(input);
// assert
Assert.NotNull(result);
Assert.AreEqual(expected, result);
}
public void GetAddressRange_SoftwareAddressMax()
{
// arrange
var input = new Ipv4Address(0, 255, 255, 255);
var expected = new SoftwareIpv4Range();
// act
var result = _utils.GetAddressRange(input);
// assert
Assert.NotNull(result);
Assert.AreEqual(expected, result);
}
public void GetAddressRange_DocumentationAddressMin_3Range()
{
// arrange
var input = new Ipv4Address(203, 0, 113, 0);
var expected = new DocumentationIpv4Range();
// act
var result = _utils.GetAddressRange(input);
// assert
Assert.NotNull(result);
Assert.AreEqual(expected, result);
}
public void GetAddressRange_Ipv6RelayAddressMax()
{
// arrange
var input = new Ipv4Address(192, 88, 99, 255);
var expected = new Ipv6Relay();
// act
var result = _utils.GetAddressRange(input);
// assert
Assert.NotNull(result);
Assert.AreEqual(expected, result);
}
public void GetAddressRange_PublicAddressMin_12Range()
{
// arrange
var input = new Ipv4Address(203, 0, 114, 0);
var expected = new PublicIpv4Range();
// act
var result = _utils.GetAddressRange(input);
// assert
Assert.NotNull(result);
Assert.AreEqual(expected, result);
}
public void GetNetworkAddress_BroadcastAddress()
{
// arrange
var inputAdr = new Ipv4Address(192, 168, 0, 63);
ushort networkPortion = 26;
var expected = new Ipv4Address(192, 168, 0, 0);
// act
var result = _manager.GetNetworkAddress(inputAdr, networkPortion);
// assert
Assert.NotNull(result);
Assert.True(expected.ToDecimal().SequenceEqual(result.ToDecimal()));
}
public static IPRange <Ipv4Address> Resolve(Ipv4Address address)
{
if (IsBetween(address, SoftwareMin, SoftwareMax))
{
return(new SoftwareIpv4Range());
}
if (IsBetween(address, Private1Min, Private1Max) ||
IsBetween(address, Private2Min, Private2Max) ||
IsBetween(address, Private3Min, Private3Max) ||
IsBetween(address, Private4Min, Private4Max) ||
IsBetween(address, Private5Min, Private5Max))
{
return(new PrivateIpv4Range());
}
if (IsBetween(address, LoopBackMin, LoopBackMax))
{
return(new LoopbackIpv4Range());
}
if (IsBetween(address, LinkLocalMin, LinkLocalMax))
{
return(new LinkLocalIpv4Range());
}
if (IsBetween(address, Ipv6RelayMin, Ipv6RelayMax))
{
return(new Ipv6Relay());
}
if (IsBetween(address, Documentation1Min, Documentation1Max) ||
IsBetween(address, Documentation2Min, Documentation2Max) ||
IsBetween(address, Documentation3Min, Documentation3Max))
{
return(new DocumentationIpv4Range());
}
if (IsBetween(address, MulticastMin, MulticastMax))
{
return(new MulticastIpv4Range());
}
if (IsBetween(address, FutureMin, FutureMax))
{
return(new FutureIpv4Range());
}
if (address == LimitedBroadcast)
{
return(new LimitedBroadcastIpv4Range());
}
return(new PublicIpv4Range());
}
public void Constructor_FromDecimal()
{
// arrange
ushort firstOctet = 192;
ushort secondOctet = 0;
ushort thirdOctet = 255;
ushort fourthOctet = 127;
// act
var address = new Ipv4Address(firstOctet, secondOctet, thirdOctet, fourthOctet);
// assert
Assert.NotNull(address);
Assert.AreEqual(firstOctet, address.FirstOctet);
Assert.AreEqual(secondOctet, address.SecondOctet);
Assert.AreEqual(thirdOctet, address.ThirdOctet);
Assert.AreEqual(fourthOctet, address.FourthOctet);
}
protected override int logic(string[] args)
{
string hostname = "TEST-W2K3"; // ... = Dns.GetHostName();
ICollection <Ipv4Quad> hostIpv4Quads = Ipv4Quad.From(Dns.GetHostEntry(hostname));
log("hostname: {0}", hostname);
foreach (Ipv4Quad hostIpv4Quad in hostIpv4Quads)
{
log("hostIpv4Quad: {0}", hostIpv4Quad);
}
log("--------------------");
Ipv4Quad ipv4Quad1 = new Ipv4Quad("192.168.71.25");
Ipv4Quad ipv4Quad2 = new Ipv4Quad("192.168.171.25");
log("ipv4Quad1: {0}", ipv4Quad1);
log("ipv4Quad2: {0}", ipv4Quad2);
ICollection <Ipv4Quad> ipv4Quads = Ipv4Quad.All();
foreach (Ipv4Quad ipv4Quad in ipv4Quads)
{
log("dotted quad: {0}", ipv4Quad);
}
ICollection <Ipv4Address> ipv4Addresses = Ipv4Address.All();
foreach (Ipv4Address ipv4Address in ipv4Addresses)
{
log("IPv4: {0}", ipv4Address);
if (ipv4Address.InSameSubnet(ipv4Quad1))
{
log("ipv4Quad1 is in the same subnet");
}
if (ipv4Address.InSameSubnet(ipv4Quad2))
{
log("ipv4Quad2 is in the same subnet");
}
if (ipv4Address.InSameSubnet(hostIpv4Quads))
{
log("{0} is in the same subnet", hostname);
}
}
return(base.logic(args));
}
public void ToBinary_Test()
{
// arrange
var utils = new Ipv4AddressUtils();
ushort firstOctet = 192;
ushort secondOctet = 0;
ushort thirdOctet = 255;
ushort fourthOctet = 127;
var expected = new List <bool>(utils.GetSingleOctetBinaryFromDecimal(firstOctet));
expected.AddRange(utils.GetSingleOctetBinaryFromDecimal(secondOctet));
expected.AddRange(utils.GetSingleOctetBinaryFromDecimal(thirdOctet));
expected.AddRange(utils.GetSingleOctetBinaryFromDecimal(fourthOctet));
var address = new Ipv4Address(192, 0, 255, 127);
// act
var result = address.ToBinary();
// assert
Assert.NotNull(result);
Assert.True(expected.SequenceEqual(result));
}
public void Constructor_FromBoolArray()
{
// arrange
var utils = new Ipv4AddressUtils();
ushort firstOctet = 192;
ushort secondOctet = 0;
ushort thirdOctet = 255;
ushort fourthOctet = 127;
var input = new List <bool>(utils.GetSingleOctetBinaryFromDecimal(firstOctet));
input.AddRange(utils.GetSingleOctetBinaryFromDecimal(secondOctet));
input.AddRange(utils.GetSingleOctetBinaryFromDecimal(thirdOctet));
input.AddRange(utils.GetSingleOctetBinaryFromDecimal(fourthOctet));
// act
Ipv4Address address = new Ipv4Address(input.ToArray());
// assert
Assert.NotNull(address);
Assert.AreEqual(firstOctet, address.FirstOctet);
Assert.AreEqual(secondOctet, address.SecondOctet);
Assert.AreEqual(thirdOctet, address.ThirdOctet);
Assert.AreEqual(fourthOctet, address.FourthOctet);
}
private static bool IsBetween(Ipv4Address address, Ipv4Address min, Ipv4Address max)
{
return(address >= min && address <= max);
}
