Example #1
0
class TestIPv6Address(unittest.TestCase, TestAddress):

    ipv4AddressStr = None
    ipv4AddressInt = None

    def setUp(self):
        self.addressVersion = 6
        self.addressLength = 16
        self.addressStr = '2001:db8::1428:57ab'
        self.addressInt = 42540766411282592856903984951992014763L
        self.addressLinkLocalStr = "fe80::1"
        self.addressLoopbackStr = "::1"
        self.addressMulticastStr = "ff00::1"
        self.addressPrivateStr = "fc00::1"
        self.addressReservedStr = "::1"
        self.addressUnspecifiedStr = "::"
        self.address = Address(self.addressStr)
        self.ipv4AddressStr = "100.110.120.130"
        self.ipv4AddressInt = 1684961410

    def test_factoryMethodAddress(self):
        self._addressInit(Address.makeV6(self.addressStr))

    def test_factoryMethodInt(self):
        self._addressInit(Address.makeV6(self.addressStr))

    def test_factoryMethodAddressError(self):
        self.assertRaises(ValueError, Address.makeV6, self.ipv4AddressStr)

    def test_factoryMethodIntError(self):
        self.assertRaises(ValueError, Address.makeV6, self.addressInt**8)

    def test_addNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__add__(Address(self.ipv4AddressStr)))

    def test_subNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__sub__(Address(self.ipv4AddressStr)))

    def test_ltNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__lt__(Address(self.ipv4AddressStr)))

    def test_gtNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__gt__(Address(self.ipv4AddressStr)))

    def test_leNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__le__(Address(self.ipv4AddressStr)))

    def test_geNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__ge__(Address(self.ipv4AddressStr)))

    def test_eqNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__eq__(Address(self.ipv4AddressStr)))

    def test_neNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__ne__(Address(self.ipv4AddressStr)))
Example #2
0
class TestIPv6Address(unittest.TestCase, TestAddress):

    ipv4AddressStr = None
    ipv4AddressInt = None

    def setUp(self):
        self.addressVersion = 6
        self.addressLength = 16
        self.addressStr = '2001:db8::1428:57ab'
        self.addressInt = 42540766411282592856903984951992014763L
        self.addressLinkLocalStr = "fe80::1"
        self.addressLoopbackStr = "::1"
        self.addressMulticastStr = "ff00::1"
        self.addressPrivateStr = "fc00::1"
        self.addressReservedStr = "::1"
        self.addressUnspecifiedStr = "::"
        self.address = Address(self.addressStr)
        self.ipv4AddressStr = "100.110.120.130"
        self.ipv4AddressInt = 1684961410

    def test_factoryMethodAddress(self):
        self._addressInit(Address.makeV6(self.addressStr))

    def test_factoryMethodInt(self):
        self._addressInit(Address.makeV6(self.addressStr))

    def test_factoryMethodAddressError(self):
        self.assertRaises(ValueError, Address.makeV6, self.ipv4AddressStr)

    def test_factoryMethodIntError(self):
        self.assertRaises(ValueError, Address.makeV6, self.addressInt ** 8)

    def test_addNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__add__(Address(self.ipv4AddressStr)))

    def test_subNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__sub__(Address(self.ipv4AddressStr)))

    def test_ltNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__lt__(Address(self.ipv4AddressStr)))

    def test_gtNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__gt__(Address(self.ipv4AddressStr)))

    def test_leNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__le__(Address(self.ipv4AddressStr)))

    def test_geNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__ge__(Address(self.ipv4AddressStr)))

    def test_eqNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__eq__(Address(self.ipv4AddressStr)))

    def test_neNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__ne__(Address(self.ipv4AddressStr)))
Example #3
0
class TestIPv4Address(unittest.TestCase, TestAddress):

    ipv6AddressStr = None
    ipv6AddressInt = None

    def setUp(self):
        self.addressVersion = 4
        self.addressLength = 4
        self.addressStr = '100.110.120.130'
        self.addressInt = 1684961410
        self.addressLinkLocalStr = "169.254.0.1"
        self.addressLoopbackStr = "127.0.0.1"
        self.addressMulticastStr = "224.0.0.1"
        self.addressPrivateStr = "192.168.0.1"
        self.addressReservedStr = "240.0.0.1"
        self.addressUnspecifiedStr = "0.0.0.0"
        self.address = Address(self.addressStr)
        self.ipv6AddressStr = "fe80:0000:0000:0000:021b:77ff:fbd6:7860"
        self.ipv6AddressInt = 338288524927261089654170743795120240736L

    def test_factoryMethodAddress(self):
        self._addressInit(Address.makeV4(self.addressStr))

    def test_factoryMethodInt(self):
        self._addressInit(Address.makeV4(self.addressStr))

    def test_factoryMethodAddressError(self):
        self.assertRaises(ValueError, Address.makeV4, self.ipv6AddressStr)

    def test_factoryMethodIntError(self):
        self.assertRaises(ValueError, Address.makeV4, self.ipv6AddressInt)

    def test_addNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__add__(Address(self.ipv6AddressStr)))

    def test_subNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__sub__(Address(self.ipv6AddressStr)))

    def test_ltNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__lt__(Address(self.ipv6AddressStr)))

    def test_gtNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__gt__(Address(self.ipv6AddressStr)))

    def test_leNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__le__(Address(self.ipv6AddressStr)))

    def test_geNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__ge__(Address(self.ipv6AddressStr)))

    def test_eqNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__eq__(Address(self.ipv6AddressStr)))

    def test_neNotSameVersionError(self):
        self.assertEquals(NotImplemented,
                          self.address.__ne__(Address(self.ipv6AddressStr)))
Example #4
0
class TestIPv4Address(unittest.TestCase, TestAddress):

    ipv6AddressStr = None
    ipv6AddressInt = None

    def setUp(self):
        self.addressVersion = 4
        self.addressLength = 4
        self.addressStr = '100.110.120.130'
        self.addressInt = 1684961410
        self.addressLinkLocalStr = "169.254.0.1"
        self.addressLoopbackStr = "127.0.0.1"
        self.addressMulticastStr = "224.0.0.1"
        self.addressPrivateStr = "192.168.0.1"
        self.addressReservedStr = "240.0.0.1"
        self.addressUnspecifiedStr = "0.0.0.0"
        self.address = Address(self.addressStr)
        self.ipv6AddressStr = "fe80:0000:0000:0000:021b:77ff:fbd6:7860"
        self.ipv6AddressInt = 338288524927261089654170743795120240736L

    def test_factoryMethodAddress(self):
        self._addressInit(Address.makeV4(self.addressStr))

    def test_factoryMethodInt(self):
        self._addressInit(Address.makeV4(self.addressStr))

    def test_factoryMethodAddressError(self):
        self.assertRaises(ValueError, Address.makeV4, self.ipv6AddressStr)

    def test_factoryMethodIntError(self):
        self.assertRaises(ValueError, Address.makeV4, self.ipv6AddressInt)

    def test_addNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__add__(Address(self.ipv6AddressStr)))

    def test_subNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__sub__(Address(self.ipv6AddressStr)))

    def test_ltNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__lt__(Address(self.ipv6AddressStr)))

    def test_gtNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__gt__(Address(self.ipv6AddressStr)))

    def test_leNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__le__(Address(self.ipv6AddressStr)))

    def test_geNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__ge__(Address(self.ipv6AddressStr)))

    def test_eqNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__eq__(Address(self.ipv6AddressStr)))

    def test_neNotSameVersionError(self):
        self.assertEquals(
            NotImplemented,
            self.address.__ne__(Address(self.ipv6AddressStr)))