Пример #1
0
        public void TestMinimizeTunet()
        {
            var netsMust = new IPv4Network[]
            {
                new IPv4Network(IPv4Address.Parse("128.130.0.0"), 15),
                new IPv4Network(IPv4Address.Parse("192.35.240.0"), 22),
                new IPv4Network(IPv4Address.Parse("192.35.244.0"), 24),
                new IPv4Network(IPv4Address.Parse("193.170.72.0"), 21),
                new IPv4Network(IPv4Address.Parse("193.170.72.0"), 22),
                new IPv4Network(IPv4Address.Parse("193.170.76.0"), 23),
                new IPv4Network(IPv4Address.Parse("193.170.78.0"), 24),
                new IPv4Network(IPv4Address.Parse("193.170.79.0"), 24),
            };

            List <IPNetwork <IPv4Address> > netsMinimized = Minimize.MinimizeSubnets(netsMust,
                                                                                     (addr, mask) => new IPv4Network(addr, mask));

            foreach (IPNetwork <IPv4Address> minNet in netsMinimized)
            {
                for (IPv4Address addr = minNet.BaseAddress; addr.CompareTo(minNet.LastAddressOfSubnet) <= 0; addr = addr + 1)
                {
                    bool contained = false;
                    foreach (IPNetwork <IPv4Address> origNet in netsMust)
                    {
                        if (origNet.Contains(addr))
                        {
                            contained = true;
                            break;
                        }
                    }

                    if (!contained)
                    {
                        Assert.True(false, $"IP address {addr} in minimized net {minNet} not contained in any original net");
                    }
                }
            }

            foreach (IPNetwork <IPv4Address> origNet in netsMust)
            {
                for (IPv4Address addr = origNet.BaseAddress; addr.CompareTo(origNet.LastAddressOfSubnet) <= 0; addr = addr + 1)
                {
                    bool contained = false;
                    foreach (IPNetwork <IPv4Address> minNet in netsMinimized)
                    {
                        if (minNet.Contains(addr))
                        {
                            contained = true;
                            break;
                        }
                    }

                    if (!contained)
                    {
                        Assert.True(false, $"IP address {addr} in original net {origNet} not contained in any minimized net");
                    }
                }
            }
        }
Пример #2
0
        public void IPv4Adress_Compare(String small, String middle, String great)
        {
            IPv4Address smallestAddress = IPv4Address.FromString(small);
            IPv4Address middleAddress   = IPv4Address.FromString(middle);
            IPv4Address greatestAddress = IPv4Address.FromString(great);

            {
                Int32 firstResult  = smallestAddress.CompareTo(smallestAddress);
                Int32 secondResult = smallestAddress.CompareTo(middleAddress);
                Int32 thirdResult  = smallestAddress.CompareTo(greatestAddress);

                Assert.Equal(0, firstResult);
                Assert.True(secondResult < 0);
                Assert.True(thirdResult < 0);

                Assert.True(smallestAddress < middleAddress);
                Assert.True(smallestAddress < greatestAddress);

                Assert.False(smallestAddress > middleAddress);
                Assert.False(smallestAddress > greatestAddress);

#pragma warning disable CS1718 // Comparison made to same variable
                Assert.True(smallestAddress <= smallestAddress);
                Assert.True(smallestAddress >= smallestAddress);
#pragma warning restore CS1718 // Comparison made to same variable
            }

            {
                Int32 firstResult  = middleAddress.CompareTo(smallestAddress);
                Int32 secondResult = middleAddress.CompareTo(middleAddress);
                Int32 thirdResult  = middleAddress.CompareTo(greatestAddress);

                Assert.True(firstResult > 0);
                Assert.Equal(0, secondResult);
                Assert.True(thirdResult < 0);

                Assert.True(middleAddress > smallestAddress);
                Assert.True(middleAddress < greatestAddress);

                Assert.False(middleAddress > greatestAddress);
                Assert.False(middleAddress < smallestAddress);

#pragma warning disable CS1718 // Comparison made to same variable
                Assert.True(middleAddress <= middleAddress);
                Assert.True(middleAddress >= middleAddress);
#pragma warning restore CS1718 // Comparison made to same variable
            }

            {
                Int32 firstResult  = greatestAddress.CompareTo(smallestAddress);
                Int32 secondResult = greatestAddress.CompareTo(middleAddress);
                Int32 thirdResult  = greatestAddress.CompareTo(greatestAddress);

                Assert.True(firstResult > 0);
                Assert.True(secondResult > 0);
                Assert.Equal(0, thirdResult);

                Assert.True(greatestAddress > smallestAddress);
                Assert.True(greatestAddress > middleAddress);

                Assert.False(greatestAddress < smallestAddress);
                Assert.False(greatestAddress < middleAddress);



#pragma warning disable CS1718 // Comparison made to same variable
                Assert.True(greatestAddress <= greatestAddress);
                Assert.True(greatestAddress >= greatestAddress);
#pragma warning restore CS1718 // Comparison made to same variable
            }
        }