diff options
| author | Thomas Kemmer <tkemmer@computer.org> | 2014-11-23 19:05:57 +0100 |
|---|---|---|
| committer | Thomas Kemmer <tkemmer@computer.org> | 2014-11-23 19:14:26 +0100 |
| commit | 3c5883496177b654a81e98b5c77007455d8ee4a6 (patch) | |
| tree | e64d5ff0b776e0418f43c44709379a0dba4acd02 /test_ipaddress.py | |
| parent | 283f8c5177e82d52506ed85cd97f53699bf14028 (diff) | |
| download | ipaddress-3c5883496177b654a81e98b5c77007455d8ee4a6.tar.gz | |
Add Python 3.2 support.
Diffstat (limited to 'test_ipaddress.py')
| -rw-r--r-- | test_ipaddress.py | 1126 |
1 files changed, 564 insertions, 562 deletions
diff --git a/test_ipaddress.py b/test_ipaddress.py index 8e8a7c1..f0aee8f 100644 --- a/test_ipaddress.py +++ b/test_ipaddress.py @@ -3,6 +3,8 @@ """Unittest for ipaddress module.""" +from __future__ import unicode_literals + import unittest import re import contextlib @@ -74,10 +76,10 @@ class CommonTestMixin: def test_empty_address(self): with self.assertAddressError("Address cannot be empty"): - self.factory(u"") + self.factory("") def test_floats_rejected(self): - with self.assertAddressError(re.escape(repr(u"1.0"))): + with self.assertAddressError(re.escape(repr("1.0"))): self.factory(1.0) def test_not_an_index_issue15559(self): @@ -92,16 +94,16 @@ class CommonTestMixin: class CommonTestMixin_v4(CommonTestMixin): def test_leading_zeros(self): - self.assertInstancesEqual(u"000.000.000.000", u"0.0.0.0") - self.assertInstancesEqual(u"192.168.000.001", u"192.168.0.1") + self.assertInstancesEqual("000.000.000.000", "0.0.0.0") + self.assertInstancesEqual("192.168.000.001", "192.168.0.1") def test_int(self): - self.assertInstancesEqual(0, u"0.0.0.0") - self.assertInstancesEqual(3232235521, u"192.168.0.1") + self.assertInstancesEqual(0, "0.0.0.0") + self.assertInstancesEqual(3232235521, "192.168.0.1") def test_packed(self): - self.assertInstancesEqual(_compat_bytes_fromhex(u"00000000"), u"0.0.0.0") - self.assertInstancesEqual(_compat_bytes_fromhex(u"c0a80001"), u"192.168.0.1") + self.assertInstancesEqual(_compat_bytes_fromhex("00000000"), "0.0.0.0") + self.assertInstancesEqual(_compat_bytes_fromhex("c0a80001"), "192.168.0.1") def test_negative_ints_rejected(self): msg = "-1 (< 0) is not permitted as an IPv4 address" @@ -126,20 +128,20 @@ class CommonTestMixin_v4(CommonTestMixin): class CommonTestMixin_v6(CommonTestMixin): def test_leading_zeros(self): - self.assertInstancesEqual(u"0000::0000", u"::") - self.assertInstancesEqual(u"000::c0a8:0001", u"::c0a8:1") + self.assertInstancesEqual("0000::0000", "::") + self.assertInstancesEqual("000::c0a8:0001", "::c0a8:1") def test_int(self): - self.assertInstancesEqual(0, u"::") - self.assertInstancesEqual(3232235521, u"::c0a8:1") + self.assertInstancesEqual(0, "::") + self.assertInstancesEqual(3232235521, "::c0a8:1") def test_packed(self): - addr = (b'\0' * 12) + _compat_bytes_fromhex(u"00000000") - self.assertInstancesEqual(addr, u"::") - addr = (b'\0' * 12) + _compat_bytes_fromhex(u"c0a80001") - self.assertInstancesEqual(addr, u"::c0a8:1") - addr = _compat_bytes_fromhex(u"c0a80001") + (b'\0' * 12) - self.assertInstancesEqual(addr, u"c0a8:1::") + addr = (b'\0' * 12) + _compat_bytes_fromhex("00000000") + self.assertInstancesEqual(addr, "::") + addr = (b'\0' * 12) + _compat_bytes_fromhex("c0a80001") + self.assertInstancesEqual(addr, "::c0a8:1") + addr = _compat_bytes_fromhex("c0a80001") + (b'\0' * 12) + self.assertInstancesEqual(addr, "c0a8:1::") def test_negative_ints_rejected(self): msg = "-1 (< 0) is not permitted as an IPv6 address" @@ -167,7 +169,7 @@ class AddressTestCase_v4(BaseTestCase, CommonTestMixin_v4): factory = ipaddress.IPv4Address def test_network_passed_as_address(self): - addr = u"127.0.0.1/24" + addr = "127.0.0.1/24" with self.assertAddressError("Unexpected '/' in %r", addr): ipaddress.IPv4Address(addr) @@ -176,29 +178,29 @@ class AddressTestCase_v4(BaseTestCase, CommonTestMixin_v4): with self.assertAddressError("Expected 4 octets in %r", addr): ipaddress.IPv4Address(addr) - assertBadSplit(u"127.0.1") - assertBadSplit(u"42.42.42.42.42") - assertBadSplit(u"42.42.42") - assertBadSplit(u"42.42") - assertBadSplit(u"42") - assertBadSplit(u"42..42.42.42") - assertBadSplit(u"42.42.42.42.") - assertBadSplit(u"42.42.42.42...") - assertBadSplit(u".42.42.42.42") - assertBadSplit(u"...42.42.42.42") - assertBadSplit(u"016.016.016") - assertBadSplit(u"016.016") - assertBadSplit(u"016") - assertBadSplit(u"000") - assertBadSplit(u"0x0a.0x0a.0x0a") - assertBadSplit(u"0x0a.0x0a") - assertBadSplit(u"0x0a") - assertBadSplit(u".") - assertBadSplit(u"bogus") - assertBadSplit(u"bogus.com") - assertBadSplit(u"1000") - assertBadSplit(u"1000000000000000") - assertBadSplit(u"192.168.0.1.com") + assertBadSplit("127.0.1") + assertBadSplit("42.42.42.42.42") + assertBadSplit("42.42.42") + assertBadSplit("42.42") + assertBadSplit("42") + assertBadSplit("42..42.42.42") + assertBadSplit("42.42.42.42.") + assertBadSplit("42.42.42.42...") + assertBadSplit(".42.42.42.42") + assertBadSplit("...42.42.42.42") + assertBadSplit("016.016.016") + assertBadSplit("016.016") + assertBadSplit("016") + assertBadSplit("000") + assertBadSplit("0x0a.0x0a.0x0a") + assertBadSplit("0x0a.0x0a") + assertBadSplit("0x0a") + assertBadSplit(".") + assertBadSplit("bogus") + assertBadSplit("bogus.com") + assertBadSplit("1000") + assertBadSplit("1000000000000000") + assertBadSplit("192.168.0.1.com") def test_empty_octet(self): def assertBadOctet(addr): @@ -206,8 +208,8 @@ class AddressTestCase_v4(BaseTestCase, CommonTestMixin_v4): addr): ipaddress.IPv4Address(addr) - assertBadOctet(u"42..42.42") - assertBadOctet(u"...") + assertBadOctet("42..42.42") + assertBadOctet("...") def test_invalid_characters(self): def assertBadOctet(addr, octet): @@ -215,15 +217,15 @@ class AddressTestCase_v4(BaseTestCase, CommonTestMixin_v4): with self.assertAddressError(re.escape(msg)): ipaddress.IPv4Address(addr) - assertBadOctet(u"0x0a.0x0a.0x0a.0x0a", u"0x0a") - assertBadOctet(u"0xa.0x0a.0x0a.0x0a", u"0xa") - assertBadOctet(u"42.42.42.-0", u"-0") - assertBadOctet(u"42.42.42.+0", u"+0") - assertBadOctet(u"42.42.42.-42", u"-42") - assertBadOctet(u"+1.+2.+3.4", u"+1") - assertBadOctet(u"1.2.3.4e0", u"4e0") - assertBadOctet(u"1.2.3.4::", u"4::") - assertBadOctet(u"1.a.2.3", u"a") + assertBadOctet("0x0a.0x0a.0x0a.0x0a", "0x0a") + assertBadOctet("0xa.0x0a.0x0a.0x0a", "0xa") + assertBadOctet("42.42.42.-0", "-0") + assertBadOctet("42.42.42.+0", "+0") + assertBadOctet("42.42.42.-42", "-42") + assertBadOctet("+1.+2.+3.4", "+1") + assertBadOctet("1.2.3.4e0", "4e0") + assertBadOctet("1.2.3.4::", "4::") + assertBadOctet("1.a.2.3", "a") def test_octal_decimal_ambiguity(self): def assertBadOctet(addr, octet): @@ -231,8 +233,8 @@ class AddressTestCase_v4(BaseTestCase, CommonTestMixin_v4): with self.assertAddressError(re.escape(msg % (octet, addr))): ipaddress.IPv4Address(addr) - assertBadOctet(u"016.016.016.016", u"016") - assertBadOctet(u"001.000.008.016", u"008") + assertBadOctet("016.016.016.016", "016") + assertBadOctet("001.000.008.016", "008") def test_octet_length(self): def assertBadOctet(addr, octet): @@ -240,8 +242,8 @@ class AddressTestCase_v4(BaseTestCase, CommonTestMixin_v4): with self.assertAddressError(re.escape(msg % (octet, addr))): ipaddress.IPv4Address(addr) - assertBadOctet(u"0000.000.000.000", u"0000") - assertBadOctet(u"12345.67899.-54321.-98765", u"12345") + assertBadOctet("0000.000.000.000", "0000") + assertBadOctet("12345.67899.-54321.-98765", "12345") def test_octet_limit(self): def assertBadOctet(addr, octet): @@ -249,8 +251,8 @@ class AddressTestCase_v4(BaseTestCase, CommonTestMixin_v4): with self.assertAddressError(re.escape(msg)): ipaddress.IPv4Address(addr) - assertBadOctet(u"257.0.0.0", 257) - assertBadOctet(u"192.168.0.999", 999) + assertBadOctet("257.0.0.0", 257) + assertBadOctet("192.168.0.999", 999) def test_bytes_message(self): with self.assertAddressError(r'bytes'): @@ -263,7 +265,7 @@ class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6): factory = ipaddress.IPv6Address def test_network_passed_as_address(self): - addr = u"::1/24" + addr = "::1/24" with self.assertAddressError("Unexpected '/' in %r", addr): ipaddress.IPv6Address(addr) @@ -273,9 +275,9 @@ class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6): with self.assertAddressError(msg, addr): ipaddress.IPv6Address(addr) - assertBadSplit(u":") - assertBadSplit(u":1") - assertBadSplit(u"FEDC:9878") + assertBadSplit(":") + assertBadSplit(":1") + assertBadSplit("FEDC:9878") def test_bad_address_split_v6_too_many_colons(self): def assertBadSplit(addr): @@ -283,12 +285,12 @@ class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6): with self.assertAddressError(msg, addr): ipaddress.IPv6Address(addr) - assertBadSplit(u"9:8:7:6:5:4:3::2:1") - assertBadSplit(u"10:9:8:7:6:5:4:3:2:1") - assertBadSplit(u"::8:7:6:5:4:3:2:1") - assertBadSplit(u"8:7:6:5:4:3:2:1::") + assertBadSplit("9:8:7:6:5:4:3::2:1") + assertBadSplit("10:9:8:7:6:5:4:3:2:1") + assertBadSplit("::8:7:6:5:4:3:2:1") + assertBadSplit("8:7:6:5:4:3:2:1::") # A trailing IPv4 address is two parts - assertBadSplit(u"10:9:8:7:6:5:4:3:42.42.42.42") + assertBadSplit("10:9:8:7:6:5:4:3:42.42.42.42") def test_bad_address_split_v6_too_many_parts(self): def assertBadSplit(addr): @@ -296,12 +298,12 @@ class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6): with self.assertAddressError(msg, addr): ipaddress.IPv6Address(addr) - assertBadSplit(u"3ffe:0:0:0:0:0:0:0:1") - assertBadSplit(u"9:8:7:6:5:4:3:2:1") - assertBadSplit(u"7:6:5:4:3:2:1") + assertBadSplit("3ffe:0:0:0:0:0:0:0:1") + assertBadSplit("9:8:7:6:5:4:3:2:1") + assertBadSplit("7:6:5:4:3:2:1") # A trailing IPv4 address is two parts - assertBadSplit(u"9:8:7:6:5:4:3:42.42.42.42") - assertBadSplit(u"7:6:5:4:3:42.42.42.42") + assertBadSplit("9:8:7:6:5:4:3:42.42.42.42") + assertBadSplit("7:6:5:4:3:42.42.42.42") def test_bad_address_split_v6_too_many_parts_with_double_colon(self): def assertBadSplit(addr): @@ -309,7 +311,7 @@ class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6): with self.assertAddressError(msg, addr): ipaddress.IPv6Address(addr) - assertBadSplit(u"1:2:3:4::5:6:7:8") + assertBadSplit("1:2:3:4::5:6:7:8") def test_bad_address_split_v6_repeated_double_colon(self): def assertBadSplit(addr): @@ -317,16 +319,16 @@ class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6): with self.assertAddressError(msg, addr): ipaddress.IPv6Address(addr) - assertBadSplit(u"3ffe::1::1") - assertBadSplit(u"1::2::3::4:5") - assertBadSplit(u"2001::db:::1") - assertBadSplit(u"3ffe::1::") - assertBadSplit(u"::3ffe::1") - assertBadSplit(u":3ffe::1::1") - assertBadSplit(u"3ffe::1::1:") - assertBadSplit(u":3ffe::1::1:") - assertBadSplit(u":::") - assertBadSplit(u'2001:db8:::1') + assertBadSplit("3ffe::1::1") + assertBadSplit("1::2::3::4:5") + assertBadSplit("2001::db:::1") + assertBadSplit("3ffe::1::") + assertBadSplit("::3ffe::1") + assertBadSplit(":3ffe::1::1") + assertBadSplit("3ffe::1::1:") + assertBadSplit(":3ffe::1::1:") + assertBadSplit(":::") + assertBadSplit('2001:db8:::1') def test_bad_address_split_v6_leading_colon(self): def assertBadSplit(addr): @@ -334,10 +336,10 @@ class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6): with self.assertAddressError(msg, addr): ipaddress.IPv6Address(addr) - assertBadSplit(u":2001:db8::1") - assertBadSplit(u":1:2:3:4:5:6:7") - assertBadSplit(u":1:2:3:4:5:6:") - assertBadSplit(u":6:5:4:3:2:1::") + assertBadSplit(":2001:db8::1") + assertBadSplit(":1:2:3:4:5:6:7") + assertBadSplit(":1:2:3:4:5:6:") + assertBadSplit(":6:5:4:3:2:1::") def test_bad_address_split_v6_trailing_colon(self): def assertBadSplit(addr): @@ -345,24 +347,24 @@ class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6): with self.assertAddressError(msg, addr): ipaddress.IPv6Address(addr) - assertBadSplit(u"2001:db8::1:") - assertBadSplit(u"1:2:3:4:5:6:7:") - assertBadSplit(u"::1.2.3.4:") - assertBadSplit(u"::7:6:5:4:3:2:") + assertBadSplit("2001:db8::1:") + assertBadSplit("1:2:3:4:5:6:7:") + assertBadSplit("::1.2.3.4:") + assertBadSplit("::7:6:5:4:3:2:") def test_bad_v4_part_in(self): def assertBadAddressPart(addr, v4_error): with self.assertAddressError("%s in %r", v4_error, addr): ipaddress.IPv6Address(addr) - assertBadAddressPart(u"3ffe::1.net", "Expected 4 octets in u?'1.net'") - assertBadAddressPart(u"3ffe::127.0.1", + assertBadAddressPart("3ffe::1.net", "Expected 4 octets in u?'1.net'") + assertBadAddressPart("3ffe::127.0.1", "Expected 4 octets in u?'127.0.1'") - assertBadAddressPart(u"::1.2.3", + assertBadAddressPart("::1.2.3", "Expected 4 octets in u?'1.2.3'") - assertBadAddressPart(u"::1.2.3.4.5", + assertBadAddressPart("::1.2.3.4.5", "Expected 4 octets in u?'1.2.3.4.5'") - assertBadAddressPart(u"3ffe::1.1.1.net", + assertBadAddressPart("3ffe::1.1.1.net", "Only decimal digits permitted in u?'net' " "in u?'1.1.1.net'") @@ -372,12 +374,12 @@ class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6): with self.assertAddressError(re.escape(msg)): ipaddress.IPv6Address(addr) - assertBadPart(u"3ffe::goog", u"goog") - assertBadPart(u"3ffe::-0", u"-0") - assertBadPart(u"3ffe::+0", u"+0") - assertBadPart(u"3ffe::-1", u"-1") - assertBadPart(u"1.2.3.4::", u"1.2.3.4") - assertBadPart(u'1234:axy::b', u"axy") + assertBadPart("3ffe::goog", "goog") + assertBadPart("3ffe::-0", "-0") + assertBadPart("3ffe::+0", "+0") + assertBadPart("3ffe::-1", "-1") + assertBadPart("1.2.3.4::", "1.2.3.4") + assertBadPart('1234:axy::b', "axy") def test_part_length(self): def assertBadPart(addr, part): @@ -385,10 +387,10 @@ class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6): with self.assertAddressError(msg, part, addr): ipaddress.IPv6Address(addr) - assertBadPart(u"::00000", u"00000") - assertBadPart(u"3ffe::10000", u"10000") - assertBadPart(u"02001:db8::", u"02001") - assertBadPart(u'2001:888888::1', u"888888") + assertBadPart("::00000", "00000") + assertBadPart("3ffe::10000", "10000") + assertBadPart("02001:db8::", "02001") + assertBadPart('2001:888888::1', "888888") def test_bytes_message(self): with self.assertAddressError(r'bytes'): @@ -401,7 +403,7 @@ class NetmaskTestMixin_v4(CommonTestMixin_v4): """Input validation on interfaces and networks is very similar""" def test_split_netmask(self): - addr = u"1.2.3.4/32/24" + addr = "1.2.3.4/32/24" with self.assertAddressError("Only one '/' permitted in %r" % addr): self.factory(addr) @@ -410,13 +412,13 @@ class NetmaskTestMixin_v4(CommonTestMixin_v4): with self.assertAddressError(details): self.factory(addr) - assertBadAddress(u"/", "Address cannot be empty") - assertBadAddress(u"/8", "Address cannot be empty") - assertBadAddress(u"bogus", "Expected 4 octets") - assertBadAddress(u"google.com", "Expected 4 octets") - assertBadAddress(u"10/8", "Expected 4 octets") - assertBadAddress(u"::1.2.3.4", "Only decimal digits") - assertBadAddress(u"1.2.3.256", re.escape(u"256 (> 255)")) + assertBadAddress("/", "Address cannot be empty") + assertBadAddress("/8", "Address cannot be empty") + assertBadAddress("bogus", "Expected 4 octets") + assertBadAddress("google.com", "Expected 4 octets") + assertBadAddress("10/8", "Expected 4 octets") + assertBadAddress("::1.2.3.4", "Only decimal digits") + assertBadAddress("1.2.3.256", re.escape("256 (> 255)")) def test_netmask_errors(self): def assertBadNetmask(addr, netmask): @@ -424,12 +426,12 @@ class NetmaskTestMixin_v4(CommonTestMixin_v4): with self.assertNetmaskError(msg % netmask): self.factory("%s/%s" % (addr, netmask)) - assertBadNetmask(u"1.2.3.4", "") - assertBadNetmask(u"1.2.3.4", u"33") - assertBadNetmask(u"1.2.3.4", u"254.254.255.256") - assertBadNetmask(u"1.1.1.1", u"254.xyz.2.3") - assertBadNetmask(u"1.1.1.1", u"240.255.0.0") - assertBadNetmask(u"1.1.1.1", "pudding") + assertBadNetmask("1.2.3.4", "") + assertBadNetmask("1.2.3.4", "33") + assertBadNetmask("1.2.3.4", "254.254.255.256") + assertBadNetmask("1.1.1.1", "254.xyz.2.3") + assertBadNetmask("1.1.1.1", "240.255.0.0") + assertBadNetmask("1.1.1.1", "pudding") class InterfaceTestCase_v4(BaseTestCase, NetmaskTestMixin_v4): factory = ipaddress.IPv4Interface @@ -442,7 +444,7 @@ class NetmaskTestMixin_v6(CommonTestMixin_v6): """Input validation on interfaces and networks is very similar""" def test_split_netmask(self): - addr = u"cafe:cafe::/128/190" + addr = "cafe:cafe::/128/190" with self.assertAddressError("Only one '/' permitted in %r" % addr): self.factory(addr) @@ -451,12 +453,12 @@ class NetmaskTestMixin_v6(CommonTestMixin_v6): with self.assertAddressError(details): self.factory(addr) - assertBadAddress(u"/", "Address cannot be empty") - assertBadAddress(u"/8", "Address cannot be empty") - assertBadAddress(u"google.com", "At least 3 parts") - assertBadAddress(u"1.2.3.4", "At least 3 parts") - assertBadAddress(u"10/8", "At least 3 parts") - assertBadAddress(u"1234:axy::b", "Only hex digits") + assertBadAddress("/", "Address cannot be empty") + assertBadAddress("/8", "Address cannot be empty") + assertBadAddress("google.com", "At least 3 parts") + assertBadAddress("1.2.3.4", "At least 3 parts") + assertBadAddress("10/8", "At least 3 parts") + assertBadAddress("1234:axy::b", "Only hex digits") def test_netmask_errors(self): def assertBadNetmask(addr, netmask): @@ -464,11 +466,11 @@ class NetmaskTestMixin_v6(CommonTestMixin_v6): with self.assertNetmaskError(msg % netmask): self.factory("%s/%s" % (addr, netmask)) - assertBadNetmask(u"::1", "") - assertBadNetmask(u"::1", u"::1") - assertBadNetmask(u"::1", u"1::") - assertBadNetmask(u"::1", u"129") - assertBadNetmask(u"::1", "pudding") + assertBadNetmask("::1", "") + assertBadNetmask("::1", "::1") + assertBadNetmask("::1", "1::") + assertBadNetmask("::1", "129") + assertBadNetmask("::1", "pudding") class InterfaceTestCase_v6(BaseTestCase, NetmaskTestMixin_v6): factory = ipaddress.IPv6Interface @@ -481,7 +483,7 @@ class FactoryFunctionErrors(BaseTestCase): def assertFactoryError(self, factory, kind): """Ensure a clean ValueError with the expected message""" - addr = u"camelot" + addr = "camelot" msg = '%r does not appear to be an IPv4 or IPv6 %s' with self.assertCleanError(ValueError, msg, addr, kind): factory(addr) @@ -566,10 +568,10 @@ class ComparisonTests(unittest.TestCase): def test_incompatible_versions(self): # These should always raise TypeError - v4addr = ipaddress.ip_address(u'1.1.1.1') - v4net = ipaddress.ip_network(u'1.1.1.1') - v6addr = ipaddress.ip_address(u'::1') - v6net = ipaddress.ip_address(u'::1') + v4addr = ipaddress.ip_address('1.1.1.1') + v4net = ipaddress.ip_network('1.1.1.1') + v6addr = ipaddress.ip_address('::1') + v6net = ipaddress.ip_address('::1') self.assertRaises(TypeError, v4addr.__lt__, v6addr) self.assertRaises(TypeError, v4addr.__gt__, v6addr) @@ -586,32 +588,32 @@ class ComparisonTests(unittest.TestCase): class IpaddrUnitTest(unittest.TestCase): def setUp(self): - self.ipv4_address = ipaddress.IPv4Address(u'1.2.3.4') - self.ipv4_interface = ipaddress.IPv4Interface(u'1.2.3.4/24') - self.ipv4_network = ipaddress.IPv4Network(u'1.2.3.0/24') - #self.ipv4_hostmask = ipaddress.IPv4Interface(u'10.0.0.1/0.255.255.255') + self.ipv4_address = ipaddress.IPv4Address('1.2.3.4') + self.ipv4_interface = ipaddress.IPv4Interface('1.2.3.4/24') + self.ipv4_network = ipaddress.IPv4Network('1.2.3.0/24') + #self.ipv4_hostmask = ipaddress.IPv4Interface('10.0.0.1/0.255.255.255') self.ipv6_address = ipaddress.IPv6Interface( - u'2001:658:22a:cafe:200:0:0:1') + '2001:658:22a:cafe:200:0:0:1') self.ipv6_interface = ipaddress.IPv6Interface( - u'2001:658:22a:cafe:200:0:0:1/64') - self.ipv6_network = ipaddress.IPv6Network(u'2001:658:22a:cafe::/64') + '2001:658:22a:cafe:200:0:0:1/64') + self.ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/64') def testRepr(self): - self.assertTrue(re.match(u"IPv4Interface\(u?'1.2.3.4/32'\)", - repr(ipaddress.IPv4Interface(u'1.2.3.4')))) - self.assertTrue(re.match(u"IPv6Interface\(u?'::1/128'\)", - repr(ipaddress.IPv6Interface(u'::1')))) + self.assertTrue(re.match("IPv4Interface\(u?'1.2.3.4/32'\)", + repr(ipaddress.IPv4Interface('1.2.3.4')))) + self.assertTrue(re.match("IPv6Interface\(u?'::1/128'\)", + repr(ipaddress.IPv6Interface('::1')))) # issue57 def testAddressIntMath(self): - self.assertEqual(ipaddress.IPv4Address(u'1.1.1.1') + 255, - ipaddress.IPv4Address(u'1.1.2.0')) - self.assertEqual(ipaddress.IPv4Address(u'1.1.1.1') - 256, - ipaddress.IPv4Address(u'1.1.0.1')) - self.assertEqual(ipaddress.IPv6Address(u'::1') + (2**16 - 2), - ipaddress.IPv6Address(u'::ffff')) - self.assertEqual(ipaddress.IPv6Address(u'::ffff') - (2**16 - 2), - ipaddress.IPv6Address(u'::1')) + self.assertEqual(ipaddress.IPv4Address('1.1.1.1') + 255, + ipaddress.IPv4Address('1.1.2.0')) + self.assertEqual(ipaddress.IPv4Address('1.1.1.1') - 256, + ipaddress.IPv4Address('1.1.0.1')) + self.assertEqual(ipaddress.IPv6Address('::1') + (2**16 - 2), + ipaddress.IPv6Address('::ffff')) + self.assertEqual(ipaddress.IPv6Address('::ffff') - (2**16 - 2), + ipaddress.IPv6Address('::1')) def testInvalidIntToBytes(self): self.assertRaises(ValueError, ipaddress.v4_int_to_packed, -1) @@ -623,11 +625,11 @@ class IpaddrUnitTest(unittest.TestCase): def testInternals(self): first, last = ipaddress._find_address_range([ - ipaddress.IPv4Address(u'10.10.10.10'), - ipaddress.IPv4Address(u'10.10.10.12')]) + ipaddress.IPv4Address('10.10.10.10'), + ipaddress.IPv4Address('10.10.10.12')]) self.assertEqual(first, last) self.assertEqual(128, ipaddress._count_righthand_zero_bits(0, 128)) - self.assertTrue(re.match(u"IPv4Network\(u?'1.2.3.0/24'\)", repr(self.ipv4_network))) + self.assertTrue(re.match("IPv4Network\(u?'1.2.3.0/24'\)", repr(self.ipv4_network))) def testMissingAddressVersion(self): class Broken(ipaddress._BaseAddress): @@ -646,27 +648,27 @@ class IpaddrUnitTest(unittest.TestCase): def testMissingAddressClass(self): class Broken(ipaddress._BaseNetwork): pass - broken = Broken(u'127.0.0.1') + broken = Broken('127.0.0.1') with self.assertRaisesRegex(NotImplementedError, "Broken.*address"): broken._address_class def testGetNetwork(self): self.assertEqual(int(self.ipv4_network.network_address), 16909056) - self.assertEqual(_compat_str(self.ipv4_network.network_address), u'1.2.3.0') + self.assertEqual(_compat_str(self.ipv4_network.network_address), '1.2.3.0') self.assertEqual(int(self.ipv6_network.network_address), 42540616829182469433403647294022090752) self.assertEqual(_compat_str(self.ipv6_network.network_address), - u'2001:658:22a:cafe::') + '2001:658:22a:cafe::') self.assertEqual(_compat_str(self.ipv6_network.hostmask), - u'::ffff:ffff:ffff:ffff') + '::ffff:ffff:ffff:ffff') def testIpFromInt(self): self.assertEqual(self.ipv4_interface._ip, ipaddress.IPv4Interface(16909060)._ip) - ipv4 = ipaddress.ip_network(u'1.2.3.4') - ipv6 = ipaddress.ip_network(u'2001:658:22a:cafe:200:0:0:1') + ipv4 = ipaddress.ip_network('1.2.3.4') + ipv6 = ipaddress.ip_network('2001:658:22a:cafe:200:0:0:1') self.assertEqual(ipv4, ipaddress.ip_network(int(ipv4.network_address))) self.assertEqual(ipv6, ipaddress.ip_network(int(ipv6.network_address))) @@ -683,72 +685,72 @@ class IpaddrUnitTest(unittest.TestCase): address = ipaddress.ip_address self.assertEqual(self.ipv4_interface._ip, ipaddress.ip_interface(b'\x01\x02\x03\x04')._ip) - self.assertEqual(address(u'255.254.253.252'), + self.assertEqual(address('255.254.253.252'), address(b'\xff\xfe\xfd\xfc')) self.assertEqual(self.ipv6_interface.ip, ipaddress.ip_interface( b'\x20\x01\x06\x58\x02\x2a\xca\xfe' b'\x02\x00\x00\x00\x00\x00\x00\x01').ip) - self.assertEqual(address(u'ffff:2:3:4:ffff::'), + self.assertEqual(address('ffff:2:3:4:ffff::'), address(b'\xff\xff\x00\x02\x00\x03\x00\x04' + b'\xff\xff' + b'\x00' * 6)) - self.assertEqual(address(u'::'), + self.assertEqual(address('::'), address(b'\x00' * 16)) def testGetIp(self): self.assertEqual(int(self.ipv4_interface.ip), 16909060) - self.assertEqual(_compat_str(self.ipv4_interface.ip), u'1.2.3.4') + self.assertEqual(_compat_str(self.ipv4_interface.ip), '1.2.3.4') self.assertEqual(int(self.ipv6_interface.ip), 42540616829182469433547762482097946625) self.assertEqual(_compat_str(self.ipv6_interface.ip), - u'2001:658:22a:cafe:200::1') + '2001:658:22a:cafe:200::1') def testGetNetmask(self): self.assertEqual(int(self.ipv4_network.netmask), 4294967040) - self.assertEqual(_compat_str(self.ipv4_network.netmask), u'255.255.255.0') + self.assertEqual(_compat_str(self.ipv4_network.netmask), '255.255.255.0') self.assertEqual(int(self.ipv6_network.netmask), 340282366920938463444927863358058659840) self.assertEqual(self.ipv6_network.prefixlen, 64) def testZeroNetmask(self): - ipv4_zero_netmask = ipaddress.IPv4Interface(u'1.2.3.4/0') + ipv4_zero_netmask = ipaddress.IPv4Interface('1.2.3.4/0') self.assertEqual(int(ipv4_zero_netmask.network.netmask), 0) self.assertTrue(ipv4_zero_netmask.network._is_valid_netmask( _compat_str(0))) - self.assertTrue(ipv4_zero_netmask._is_valid_netmask(u'0')) - self.assertTrue(ipv4_zero_netmask._is_valid_netmask(u'0.0.0.0')) - self.assertFalse(ipv4_zero_netmask._is_valid_netmask(u'invalid')) + self.assertTrue(ipv4_zero_netmask._is_valid_netmask('0')) + self.assertTrue(ipv4_zero_netmask._is_valid_netmask('0.0.0.0')) + self.assertFalse(ipv4_zero_netmask._is_valid_netmask('invalid')) - ipv6_zero_netmask = ipaddress.IPv6Interface(u'::1/0') + ipv6_zero_netmask = ipaddress.IPv6Interface('::1/0') self.assertEqual(int(ipv6_zero_netmask.network.netmask), 0) self.assertTrue(ipv6_zero_netmask.network._is_valid_netmask( _compat_str(0))) def testIPv4NetAndHostmasks(self): net = self.ipv4_network - self.assertFalse(net._is_valid_netmask(u'invalid')) - self.assertTrue(net._is_valid_netmask(u'128.128.128.128')) - self.assertFalse(net._is_valid_netmask(u'128.128.128.127')) - self.assertFalse(net._is_valid_netmask(u'128.128.128.255')) - self.assertTrue(net._is_valid_netmask(u'255.128.128.128')) - - self.assertFalse(net._is_hostmask(u'invalid')) - self.assertTrue(net._is_hostmask(u'128.255.255.255')) - self.assertFalse(net._is_hostmask(u'255.255.255.255')) - self.assertFalse(net._is_hostmask(u'1.2.3.4')) - - net = ipaddress.IPv4Network(u'127.0.0.0/0.0.0.255') + self.assertFalse(net._is_valid_netmask('invalid')) + self.assertTrue(net._is_valid_netmask('128.128.128.128')) + self.assertFalse(net._is_valid_netmask('128.128.128.127')) + self.assertFalse(net._is_valid_netmask('128.128.128.255')) + self.assertTrue(net._is_valid_netmask('255.128.128.128')) + + self.assertFalse(net._is_hostmask('invalid')) + self.assertTrue(net._is_hostmask('128.255.255.255')) + self.assertFalse(net._is_hostmask('255.255.255.255')) + self.assertFalse(net._is_hostmask('1.2.3.4')) + + net = ipaddress.IPv4Network('127.0.0.0/0.0.0.255') self.assertEqual(24, net.prefixlen) def testGetBroadcast(self): self.assertEqual(int(self.ipv4_network.broadcast_address), 16909311) - self.assertEqual(_compat_str(self.ipv4_network.broadcast_address), u'1.2.3.255') + self.assertEqual(_compat_str(self.ipv4_network.broadcast_address), '1.2.3.255') self.assertEqual(int(self.ipv6_network.broadcast_address), 42540616829182469451850391367731642367) self.assertEqual(_compat_str(self.ipv6_network.broadcast_address), - u'2001:658:22a:cafe:ffff:ffff:ffff:ffff') + '2001:658:22a:cafe:ffff:ffff:ffff:ffff') def testGetPrefixlen(self): self.assertEqual(self.ipv4_interface.network.prefixlen, 24) @@ -757,25 +759,25 @@ class IpaddrUnitTest(unittest.TestCase): def testGetSupernet(self): self.assertEqual(self.ipv4_network.supernet().prefixlen, 23) self.assertEqual(_compat_str(self.ipv4_network.supernet().network_address), - u'1.2.2.0') + '1.2.2.0') self.assertEqual( - ipaddress.IPv4Interface(u'0.0.0.0/0').network.supernet(), - ipaddress.IPv4Network(u'0.0.0.0/0')) + ipaddress.IPv4Interface('0.0.0.0/0').network.supernet(), + ipaddress.IPv4Network('0.0.0.0/0')) self.assertEqual(self.ipv6_network.supernet().prefixlen, 63) self.assertEqual(_compat_str(self.ipv6_network.supernet().network_address), - u'2001:658:22a:cafe::') - self.assertEqual(ipaddress.IPv6Interface(u'::0/0').network.supernet(), - ipaddress.IPv6Network(u'::0/0')) + '2001:658:22a:cafe::') + self.assertEqual(ipaddress.IPv6Interface('::0/0').network.supernet(), + ipaddress.IPv6Network('::0/0')) def testGetSupernet3(self): self.assertEqual(self.ipv4_network.supernet(3).prefixlen, 21) self.assertEqual(_compat_str(self.ipv4_network.supernet(3).network_address), - u'1.2.0.0') + '1.2.0.0') self.assertEqual(self.ipv6_network.supernet(3).prefixlen, 61) self.assertEqual(_compat_str(self.ipv6_network.supernet(3).network_address), - u'2001:658:22a:caf8::') + '2001:658:22a:caf8::') def testGetSupernet4(self): self.assertRaises(ValueError, self.ipv4_network.supernet, @@ -795,13 +797,13 @@ class IpaddrUnitTest(unittest.TestCase): def testHosts(self): hosts = list(self.ipv4_network.hosts()) self.assertEqual(254, len(hosts)) - self.assertEqual(ipaddress.IPv4Address(u'1.2.3.1'), hosts[0]) - self.assertEqual(ipaddress.IPv4Address(u'1.2.3.254'), hosts[-1]) + self.assertEqual(ipaddress.IPv4Address('1.2.3.1'), hosts[0]) + self.assertEqual(ipaddress.IPv4Address('1.2.3.254'), hosts[-1]) # special case where only 1 bit is left for address - self.assertEqual([ipaddress.IPv4Address(u'2.0.0.0'), - ipaddress.IPv4Address(u'2.0.0.1')], - list(ipaddress.ip_network(u'2.0.0.0/31').hosts())) + self.assertEqual([ipaddress.IPv4Address('2.0.0.0'), + ipaddress.IPv4Address('2.0.0.1')], + list(ipaddress.ip_network('2.0.0.0/31').hosts())) def testFancySubnetting(self): self.assertEqual(sorted(self.ipv4_network.subnets(prefixlen_diff=3)), @@ -823,40 +825,40 @@ class IpaddrUnitTest(unittest.TestCase): self.assertEqual(list(self.ipv4_network.subnets())[0].prefixlen, 25) self.assertEqual(_compat_str(list( self.ipv4_network.subnets())[0].network_address), - u'1.2.3.0') + '1.2.3.0') self.assertEqual(_compat_str(list( self.ipv4_network.subnets())[1].network_address), - u'1.2.3.128') + '1.2.3.128') self.assertEqual(list(self.ipv6_network.subnets())[0].prefixlen, 65) def testGetSubnetForSingle32(self): - ip = ipaddress.IPv4Network(u'1.2.3.4/32') + ip = ipaddress.IPv4Network('1.2.3.4/32') subnets1 = [_compat_str(x) for x in ip.subnets()] subnets2 = [_compat_str(x) for x in ip.subnets(2)] - self.assertEqual(subnets1, [u'1.2.3.4/32']) + self.assertEqual(subnets1, ['1.2.3.4/32']) self.assertEqual(subnets1, subnets2) def testGetSubnetForSingle128(self): - ip = ipaddress.IPv6Network(u'::1/128') + ip = ipaddress.IPv6Network('::1/128') subnets1 = [_compat_str(x) for x in ip.subnets()] subnets2 = [_compat_str(x) for x in ip.subnets(2)] - self.assertEqual(subnets1, [u'::1/128']) + self.assertEqual(subnets1, ['::1/128']) self.assertEqual(subnets1, subnets2) def testSubnet2(self): ips = [str(x) for x in self.ipv4_network.subnets(2)] self.assertEqual( ips, - [u'1.2.3.0/26', u'1.2.3.64/26', u'1.2.3.128/26', u'1.2.3.192/26']) + ['1.2.3.0/26', '1.2.3.64/26', '1.2.3.128/26', '1.2.3.192/26']) ipsv6 = [str(x) for x in self.ipv6_network.subnets(2)] self.assertEqual( ipsv6, - [u'2001:658:22a:cafe::/66', - u'2001:658:22a:cafe:4000::/66', - u'2001:658:22a:cafe:8000::/66', - u'2001:658:22a:cafe:c000::/66']) + ['2001:658:22a:cafe::/66', + '2001:658:22a:cafe:4000::/66', + '2001:658:22a:cafe:8000::/66', + '2001:658:22a:cafe:c000::/66']) def testSubnetFailsForLargeCidrDiff(self): self.assertRaises(ValueError, list, @@ -897,176 +899,176 @@ class IpaddrUnitTest(unittest.TestCase): 36893488147419103232) def testContains(self): - self.assertTrue(ipaddress.IPv4Interface(u'1.2.3.128/25') in + self.assertTrue(ipaddress.IPv4Interface('1.2.3.128/25') in self.ipv4_network) - self.assertFalse(ipaddress.IPv4Interface(u'1.2.4.1/24') in + self.assertFalse(ipaddress.IPv4Interface('1.2.4.1/24') in self.ipv4_network) # We can test addresses and string as well. - addr1 = ipaddress.IPv4Address(u'1.2.3.37') + addr1 = ipaddress.IPv4Address('1.2.3.37') self.assertTrue(addr1 in self.ipv4_network) # issue 61, bad network comparison on like-ip'd network objects # with identical broadcast addresses. - self.assertFalse(ipaddress.IPv4Network(u'1.1.0.0/16').__contains__( - ipaddress.IPv4Network(u'1.0.0.0/15'))) + self.assertFalse(ipaddress.IPv4Network('1.1.0.0/16').__contains__( + ipaddress.IPv4Network('1.0.0.0/15'))) def testNth(self): - self.assertEqual(_compat_str(self.ipv4_network[5]), u'1.2.3.5') + self.assertEqual(_compat_str(self.ipv4_network[5]), '1.2.3.5') self.assertRaises(IndexError, self.ipv4_network.__getitem__, 256) self.assertEqual(_compat_str(self.ipv6_network[5]), - u'2001:658:22a:cafe::5') + '2001:658:22a:cafe::5') def testGetitem(self): # http://code.google.com/p/ipaddr-py/issues/detail?id=15 - addr = ipaddress.IPv4Network(u'172.31.255.128/255.255.255.240') + addr = ipaddress.IPv4Network('172.31.255.128/255.255.255.240') self.assertEqual(28, addr.prefixlen) addr_list = list(addr) - self.assertEqual(u'172.31.255.128', str(addr_list[0])) - self.assertEqual(u'172.31.255.128', str(addr[0])) - self.assertEqual(u'172.31.255.143', str(addr_list[-1])) - self.assertEqual(u'172.31.255.143', str(addr[-1])) + self.assertEqual('172.31.255.128', str(addr_list[0])) + self.assertEqual('172.31.255.128', str(addr[0])) + self.assertEqual('172.31.255.143', str(addr_list[-1])) + self.assertEqual('172.31.255.143', str(addr[-1])) self.assertEqual(addr_list[-1], addr[-1]) def testEqual(self): self.assertTrue(self.ipv4_interface == - ipaddress.IPv4Interface(u'1.2.3.4/24')) + ipaddress.IPv4Interface('1.2.3.4/24')) self.assertFalse(self.ipv4_interface == - ipaddress.IPv4Interface(u'1.2.3.4/23')) + ipaddress.IPv4Interface('1.2.3.4/23')) self.assertFalse(self.ipv4_interface == - ipaddress.IPv6Interface(u'::1.2.3.4/24')) - self.assertFalse(self.ipv4_interface == u'') + ipaddress.IPv6Interface('::1.2.3.4/24')) + self.assertFalse(self.ipv4_interface == '') self.assertFalse(self.ipv4_interface == []) self.assertFalse(self.ipv4_interface == 2) self.assertTrue(self.ipv6_interface == - ipaddress.IPv6Interface(u'2001:658:22a:cafe:200::1/64')) + ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64')) self.assertFalse(self.ipv6_interface == - ipaddress.IPv6Interface(u'2001:658:22a:cafe:200::1/63')) + ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63')) self.assertFalse(self.ipv6_interface == - ipaddress.IPv4Interface(u'1.2.3.4/23')) - self.assertFalse(self.ipv6_interface == u'') + ipaddress.IPv4Interface('1.2.3.4/23')) + self.assertFalse(self.ipv6_interface == '') self.assertFalse(self.ipv6_interface == []) self.assertFalse(self.ipv6_interface == 2) def testNotEqual(self): self.assertFalse(self.ipv4_interface != - ipaddress.IPv4Interface(u'1.2.3.4/24')) + ipaddress.IPv4Interface('1.2.3.4/24')) self.assertTrue(self.ipv4_interface != - ipaddress.IPv4Interface(u'1.2.3.4/23')) + ipaddress.IPv4Interface('1.2.3.4/23')) self.assertTrue(self.ipv4_interface != - ipaddress.IPv6Interface(u'::1.2.3.4/24')) - self.assertTrue(self.ipv4_interface != u'') + ipaddress.IPv6Interface('::1.2.3.4/24')) + self.assertTrue(self.ipv4_interface != '') self.assertTrue(self.ipv4_interface != []) self.assertTrue(self.ipv4_interface != 2) self.assertTrue(self.ipv4_address != - ipaddress.IPv4Address(u'1.2.3.5')) - self.assertTrue(self.ipv4_address != u'') + ipaddress.IPv4Address('1.2.3.5')) + self.assertTrue(self.ipv4_address != '') self.assertTrue(self.ipv4_address != []) self.assertTrue(self.ipv4_address != 2) self.assertFalse(self.ipv6_interface != - ipaddress.IPv6Interface(u'2001:658:22a:cafe:200::1/64')) + ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64')) self.assertTrue(self.ipv6_interface != - ipaddress.IPv6Interface(u'2001:658:22a:cafe:200::1/63')) + ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63')) self.assertTrue(self.ipv6_interface != - ipaddress.IPv4Interface(u'1.2.3.4/23')) - self.assertTrue(self.ipv6_interface != u'') + ipaddress.IPv4Interface('1.2.3.4/23')) + self.assertTrue(self.ipv6_interface != '') self.assertTrue(self.ipv6_interface != []) self.assertTrue(self.ipv6_interface != 2) self.assertTrue(self.ipv6_address != - ipaddress.IPv4Address(u'1.2.3.4')) - self.assertTrue(self.ipv6_address != u'') + ipaddress.IPv4Address('1.2.3.4')) + self.assertTrue(self.ipv6_address != '') self.assertTrue(self.ipv6_address != []) self.assertTrue(self.ipv6_address != 2) def testSlash32Constructor(self): self.assertEqual(_compat_str(ipaddress.IPv4Interface( - u'1.2.3.4/255.255.255.255')), u'1.2.3.4/32') + '1.2.3.4/255.255.255.255')), '1.2.3.4/32') def testSlash128Constructor(self): - self.assertEqual(_compat_str(ipaddress.IPv6Interface(u'::1/128')), - u'::1/128') + self.assertEqual(_compat_str(ipaddress.IPv6Interface('::1/128')), + '::1/128') def testSlash0Constructor(self): - self.assertEqual(_compat_str(ipaddress.IPv4Interface(u'1.2.3.4/0.0.0.0')), - u'1.2.3.4/0') + self.assertEqual(_compat_str(ipaddress.IPv4Interface('1.2.3.4/0.0.0.0')), + '1.2.3.4/0') def testCollapsing(self): # test only IP addresses including some duplicates - ip1 = ipaddress.IPv4Address(u'1.1.1.0') - ip2 = ipaddress.IPv4Address(u'1.1.1.1') - ip3 = ipaddress.IPv4Address(u'1.1.1.2') - ip4 = ipaddress.IPv4Address(u'1.1.1.3') - ip5 = ipaddress.IPv4Address(u'1.1.1.4') - ip6 = ipaddress.IPv4Address(u'1.1.1.0') + ip1 = ipaddress.IPv4Address('1.1.1.0') + ip2 = ipaddress.IPv4Address('1.1.1.1') + ip3 = ipaddress.IPv4Address('1.1.1.2') + ip4 = ipaddress.IPv4Address('1.1.1.3') + ip5 = ipaddress.IPv4Address('1.1.1.4') + ip6 = ipaddress.IPv4Address('1.1.1.0') # check that addreses are subsumed properly. collapsed = ipaddress.collapse_addresses( [ip1, ip2, ip3, ip4, ip5, ip6]) self.assertEqual(list(collapsed), - [ipaddress.IPv4Network(u'1.1.1.0/30'), - ipaddress.IPv4Network(u'1.1.1.4/32')]) + [ipaddress.IPv4Network('1.1.1.0/30'), + ipaddress.IPv4Network('1.1.1.4/32')]) # test a mix of IP addresses and networks including some duplicates - ip1 = ipaddress.IPv4Address(u'1.1.1.0') - ip2 = ipaddress.IPv4Address(u'1.1.1.1') - ip3 = ipaddress.IPv4Address(u'1.1.1.2') - ip4 = ipaddress.IPv4Address(u'1.1.1.3') - #ip5 = ipaddress.IPv4Interface(u'1.1.1.4/30') - #ip6 = ipaddress.IPv4Interface(u'1.1.1.4/30') + ip1 = ipaddress.IPv4Address('1.1.1.0') + ip2 = ipaddress.IPv4Address('1.1.1.1') + ip3 = ipaddress.IPv4Address('1.1.1.2') + ip4 = ipaddress.IPv4Address('1.1.1.3') + #ip5 = ipaddress.IPv4Interface('1.1.1.4/30') + #ip6 = ipaddress.IPv4Interface('1.1.1.4/30') # check that addreses are subsumed properly. collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4]) self.assertEqual(list(collapsed), - [ipaddress.IPv4Network(u'1.1.1.0/30')]) + [ipaddress.IPv4Network('1.1.1.0/30')]) # test only IP networks - ip1 = ipaddress.IPv4Network(u'1.1.0.0/24') - ip2 = ipaddress.IPv4Network(u'1.1.1.0/24') - ip3 = ipaddress.IPv4Network(u'1.1.2.0/24') - ip4 = ipaddress.IPv4Network(u'1.1.3.0/24') - ip5 = ipaddress.IPv4Network(u'1.1.4.0/24') + ip1 = ipaddress.IPv4Network('1.1.0.0/24') + ip2 = ipaddress.IPv4Network('1.1.1.0/24') + ip3 = ipaddress.IPv4Network('1.1.2.0/24') + ip4 = ipaddress.IPv4Network('1.1.3.0/24') + ip5 = ipaddress.IPv4Network('1.1.4.0/24') # stored in no particular order b/c we want CollapseAddr to call # [].sort - ip6 = ipaddress.IPv4Network(u'1.1.0.0/22') + ip6 = ipaddress.IPv4Network('1.1.0.0/22') # check that addreses are subsumed properly. collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4, ip5, ip6]) self.assertEqual(list(collapsed), - [ipaddress.IPv4Network(u'1.1.0.0/22'), - ipaddress.IPv4Network(u'1.1.4.0/24')]) + [ipaddress.IPv4Network('1.1.0.0/22'), + ipaddress.IPv4Network('1.1.4.0/24')]) # test that two addresses are supernet'ed properly collapsed = ipaddress.collapse_addresses([ip1, ip2]) self.assertEqual(list(collapsed), - [ipaddress.IPv4Network(u'1.1.0.0/23')]) + [ipaddress.IPv4Network('1.1.0.0/23')]) # test same IP networks - ip_same1 = ip_same2 = ipaddress.IPv4Network(u'1.1.1.1/32') + ip_same1 = ip_same2 = ipaddress.IPv4Network('1.1.1.1/32') self.assertEqual(list(ipaddress.collapse_addresses( [ip_same1, ip_same2])), [ip_same1]) # test same IP addresses - ip_same1 = ip_same2 = ipaddress.IPv4Address(u'1.1.1.1') + ip_same1 = ip_same2 = ipaddress.IPv4Address('1.1.1.1') self.assertEqual(list(ipaddress.collapse_addresses( [ip_same1, ip_same2])), - [ipaddress.ip_network(u'1.1.1.1/32')]) - ip1 = ipaddress.IPv6Network(u'2001::/100') - ip2 = ipaddress.IPv6Network(u'2001::/120') - ip3 = ipaddress.IPv6Network(u'2001::/96') + [ipaddress.ip_network('1.1.1.1/32')]) + ip1 = ipaddress.IPv6Network('2001::/100') + ip2 = ipaddress.IPv6Network('2001::/120') + ip3 = ipaddress.IPv6Network('2001::/96') # test that ipv6 addresses are subsumed properly. collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3]) self.assertEqual(list(collapsed), [ip3]) # the toejam test addr_tuples = [ - (ipaddress.ip_address(u'1.1.1.1'), - ipaddress.ip_address(u'::1')), - (ipaddress.IPv4Network(u'1.1.0.0/24'), - ipaddress.IPv6Network(u'2001::/120')), - (ipaddress.IPv4Network(u'1.1.0.0/32'), - ipaddress.IPv6Network(u'2001::/128')), + (ipaddress.ip_address('1.1.1.1'), + ipaddress.ip_address('::1')), + (ipaddress.IPv4Network('1.1.0.0/24'), + ipaddress.IPv6Network('2001::/120')), + (ipaddress.IPv4Network('1.1.0.0/32'), + ipaddress.IPv6Network('2001::/128')), ] for ip1, ip2 in addr_tuples: self.assertRaises(TypeError, ipaddress.collapse_addresses, @@ -1076,87 +1078,87 @@ class IpaddrUnitTest(unittest.TestCase): #ip = ipaddress.ip_address #ipnet = ipaddress.ip_network summarize = ipaddress.summarize_address_range - ip1 = ipaddress.ip_address(u'1.1.1.0') - ip2 = ipaddress.ip_address(u'1.1.1.255') + ip1 = ipaddress.ip_address('1.1.1.0') + ip2 = ipaddress.ip_address('1.1.1.255') # summarize works only for IPv4 & IPv6 class IPv7Address(ipaddress.IPv6Address): @property def version(self): return 7 - ip_invalid1 = IPv7Address(u'::1') - ip_invalid2 = IPv7Address(u'::1') + ip_invalid1 = IPv7Address('::1') + ip_invalid2 = IPv7Address('::1') self.assertRaises(ValueError, list, summarize(ip_invalid1, ip_invalid2)) # test that a summary over ip4 & ip6 fails self.assertRaises(TypeError, list, - summarize(ip1, ipaddress.IPv6Address(u'::1'))) + summarize(ip1, ipaddress.IPv6Address('::1'))) # test a /24 is summarized properly self.assertEqual(list(summarize(ip1, ip2))[0], - ipaddress.ip_network(u'1.1.1.0/24')) + ipaddress.ip_network('1.1.1.0/24')) # test an IPv4 range that isn't on a network byte boundary - ip2 = ipaddress.ip_address(u'1.1.1.8') + ip2 = ipaddress.ip_address('1.1.1.8') self.assertEqual(list(summarize(ip1, ip2)), - [ipaddress.ip_network(u'1.1.1.0/29'), - ipaddress.ip_network(u'1.1.1.8')]) + [ipaddress.ip_network('1.1.1.0/29'), + ipaddress.ip_network('1.1.1.8')]) # all! ip1 = ipaddress.IPv4Address(0) ip2 = ipaddress.IPv4Address(ipaddress.IPv4Address._ALL_ONES) - self.assertEqual([ipaddress.IPv4Network(u'0.0.0.0/0')], + self.assertEqual([ipaddress.IPv4Network('0.0.0.0/0')], list(summarize(ip1, ip2))) - ip1 = ipaddress.ip_address(u'1::') - ip2 = ipaddress.ip_address(u'1:ffff:ffff:ffff:ffff:ffff:ffff:ffff') + ip1 = ipaddress.ip_address('1::') + ip2 = ipaddress.ip_address('1:ffff:ffff:ffff:ffff:ffff:ffff:ffff') # test a IPv6 is sumamrized properly self.assertEqual(list(summarize(ip1, ip2))[0], - ipaddress.ip_network(u'1::/16')) + ipaddress.ip_network('1::/16')) # test an IPv6 range that isn't on a network byte boundary - ip2 = ipaddress.ip_address(u'2::') + ip2 = ipaddress.ip_address('2::') self.assertEqual(list(summarize(ip1, ip2)), - [ipaddress.ip_network(u'1::/16'), - ipaddress.ip_network(u'2::/128')]) + [ipaddress.ip_network('1::/16'), + ipaddress.ip_network('2::/128')]) # test exception raised when first is greater than last self.assertRaises(ValueError, list, - summarize(ipaddress.ip_address(u'1.1.1.0'), - ipaddress.ip_address(u'1.1.0.0'))) + summarize(ipaddress.ip_address('1.1.1.0'), + ipaddress.ip_address('1.1.0.0'))) # test exception raised when first and last aren't IP addresses self.assertRaises(TypeError, list, - summarize(ipaddress.ip_network(u'1.1.1.0'), - ipaddress.ip_network(u'1.1.0.0'))) + summarize(ipaddress.ip_network('1.1.1.0'), + ipaddress.ip_network('1.1.0.0'))) self.assertRaises(TypeError, list, - summarize(ipaddress.ip_network(u'1.1.1.0'), - ipaddress.ip_network(u'1.1.0.0'))) + summarize(ipaddress.ip_network('1.1.1.0'), + ipaddress.ip_network('1.1.0.0'))) # test exception raised when first and last are not same version self.assertRaises(TypeError, list, - summarize(ipaddress.ip_address(u'::'), - ipaddress.ip_network(u'1.1.0.0'))) + summarize(ipaddress.ip_address('::'), + ipaddress.ip_network('1.1.0.0'))) def testAddressComparison(self): - self.assertTrue(ipaddress.ip_address(u'1.1.1.1') <= - ipaddress.ip_address(u'1.1.1.1')) - self.assertTrue(ipaddress.ip_address(u'1.1.1.1') <= - ipaddress.ip_address(u'1.1.1.2')) - self.assertTrue(ipaddress.ip_address(u'::1') <= - ipaddress.ip_address(u'::1')) - self.assertTrue(ipaddress.ip_address(u'::1') <= - ipaddress.ip_address(u'::2')) + self.assertTrue(ipaddress.ip_address('1.1.1.1') <= + ipaddress.ip_address('1.1.1.1')) + self.assertTrue(ipaddress.ip_address('1.1.1.1') <= + ipaddress.ip_address('1.1.1.2')) + self.assertTrue(ipaddress.ip_address('::1') <= + ipaddress.ip_address('::1')) + self.assertTrue(ipaddress.ip_address('::1') <= + ipaddress.ip_address('::2')) def testInterfaceComparison(self): - self.assertTrue(ipaddress.ip_interface(u'1.1.1.1') <= - ipaddress.ip_interface(u'1.1.1.1')) - self.assertTrue(ipaddress.ip_interface(u'1.1.1.1') <= - ipaddress.ip_interface(u'1.1.1.2')) - self.assertTrue(ipaddress.ip_interface(u'::1') <= - ipaddress.ip_interface(u'::1')) - self.assertTrue(ipaddress.ip_interface(u'::1') <= - ipaddress.ip_interface(u'::2')) + self.assertTrue(ipaddress.ip_interface('1.1.1.1') <= + ipaddress.ip_interface('1.1.1.1')) + self.assertTrue(ipaddress.ip_interface('1.1.1.1') <= + ipaddress.ip_interface('1.1.1.2')) + self.assertTrue(ipaddress.ip_interface('::1') <= + ipaddress.ip_interface('::1')) + self.assertTrue(ipaddress.ip_interface('::1') <= + ipaddress.ip_interface('::2')) def testNetworkComparison(self): # ip1 and ip2 have the same network address - ip1 = ipaddress.IPv4Network(u'1.1.1.0/24') - ip2 = ipaddress.IPv4Network(u'1.1.1.0/32') - ip3 = ipaddress.IPv4Network(u'1.1.2.0/24') + ip1 = ipaddress.IPv4Network('1.1.1.0/24') + ip2 = ipaddress.IPv4Network('1.1.1.0/32') + ip3 = ipaddress.IPv4Network('1.1.2.0/24') self.assertTrue(ip1 < ip3) self.assertTrue(ip3 > ip2) @@ -1171,9 +1173,9 @@ class IpaddrUnitTest(unittest.TestCase): self.assertEqual(ip3.compare_networks(ip1), 1) self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key()) - ip1 = ipaddress.IPv6Network(u'2001:2000::/96') - ip2 = ipaddress.IPv6Network(u'2001:2001::/96') - ip3 = ipaddress.IPv6Network(u'2001:ffff:2000::/96') + ip1 = ipaddress.IPv6Network('2001:2000::/96') + ip2 = ipaddress.IPv6Network('2001:2001::/96') + ip3 = ipaddress.IPv6Network('2001:ffff:2000::/96') self.assertTrue(ip1 < ip3) self.assertTrue(ip3 > ip2) @@ -1185,33 +1187,33 @@ class IpaddrUnitTest(unittest.TestCase): self.assertRaises(TypeError, self.ipv4_network.compare_networks, self.ipv6_network) - ipv6 = ipaddress.IPv6Interface(u'::/0') - ipv4 = ipaddress.IPv4Interface(u'0.0.0.0/0') + ipv6 = ipaddress.IPv6Interface('::/0') + ipv4 = ipaddress.IPv4Interface('0.0.0.0/0') self.assertRaises(TypeError, ipv4.__lt__, ipv6) self.assertRaises(TypeError, ipv4.__gt__, ipv6) self.assertRaises(TypeError, ipv6.__lt__, ipv4) self.assertRaises(TypeError, ipv6.__gt__, ipv4) # Regression test for issue 19. - ip1 = ipaddress.ip_network(u'10.1.2.128/25') + ip1 = ipaddress.ip_network('10.1.2.128/25') self.assertFalse(ip1 < ip1) self.assertFalse(ip1 > ip1) - ip2 = ipaddress.ip_network(u'10.1.3.0/24') + ip2 = ipaddress.ip_network('10.1.3.0/24') self.assertTrue(ip1 < ip2) self.assertFalse(ip2 < ip1) self.assertFalse(ip1 > ip2) self.assertTrue(ip2 > ip1) - ip3 = ipaddress.ip_network(u'10.1.3.0/25') + ip3 = ipaddress.ip_network('10.1.3.0/25') self.assertTrue(ip2 < ip3) self.assertFalse(ip3 < ip2) self.assertFalse(ip2 > ip3) self.assertTrue(ip3 > ip2) # Regression test for issue 28. - ip1 = ipaddress.ip_network(u'10.10.10.0/31') - ip2 = ipaddress.ip_network(u'10.10.10.0') - ip3 = ipaddress.ip_network(u'10.10.10.2/31') - ip4 = ipaddress.ip_network(u'10.10.10.2') + ip1 = ipaddress.ip_network('10.10.10.0/31') + ip2 = ipaddress.ip_network('10.10.10.0') + ip3 = ipaddress.ip_network('10.10.10.2/31') + ip4 = ipaddress.ip_network('10.10.10.2') sorted = [ip1, ip2, ip3, ip4] unsorted = [ip2, ip4, ip1, ip3] unsorted.sort() @@ -1220,54 +1222,54 @@ class IpaddrUnitTest(unittest.TestCase): unsorted.sort() self.assertEqual(sorted, unsorted) self.assertRaises(TypeError, ip1.__lt__, - ipaddress.ip_address(u'10.10.10.0')) + ipaddress.ip_address('10.10.10.0')) self.assertRaises(TypeError, ip2.__lt__, - ipaddress.ip_address(u'10.10.10.0')) + ipaddress.ip_address('10.10.10.0')) # <=, >= - self.assertTrue(ipaddress.ip_network(u'1.1.1.1') <= - ipaddress.ip_network(u'1.1.1.1')) - self.assertTrue(ipaddress.ip_network(u'1.1.1.1') <= - ipaddress.ip_network(u'1.1.1.2')) - self.assertFalse(ipaddress.ip_network(u'1.1.1.2') <= - ipaddress.ip_network(u'1.1.1.1')) - self.assertTrue(ipaddress.ip_network(u'::1') <= - ipaddress.ip_network(u'::1')) - self.assertTrue(ipaddress.ip_network(u'::1') <= - ipaddress.ip_network(u'::2')) - self.assertFalse(ipaddress.ip_network(u'::2') <= - ipaddress.ip_network(u'::1')) + self.assertTrue(ipaddress.ip_network('1.1.1.1') <= + ipaddress.ip_network('1.1.1.1')) + self.assertTrue(ipaddress.ip_network('1.1.1.1') <= + ipaddress.ip_network('1.1.1.2')) + self.assertFalse(ipaddress.ip_network('1.1.1.2') <= + ipaddress.ip_network('1.1.1.1')) + self.assertTrue(ipaddress.ip_network('::1') <= + ipaddress.ip_network('::1')) + self.assertTrue(ipaddress.ip_network('::1') <= + ipaddress.ip_network('::2')) + self.assertFalse(ipaddress.ip_network('::2') <= + ipaddress.ip_network('::1')) def testStrictNetworks(self): - self.assertRaises(ValueError, ipaddress.ip_network, u'192.168.1.1/24') - self.assertRaises(ValueError, ipaddress.ip_network, u'::1/120') + self.assertRaises(ValueError, ipaddress.ip_network, '192.168.1.1/24') + self.assertRaises(ValueError, ipaddress.ip_network, '::1/120') def testOverlaps(self): - other = ipaddress.IPv4Network(u'1.2.3.0/30') - other2 = ipaddress.IPv4Network(u'1.2.2.0/24') - other3 = ipaddress.IPv4Network(u'1.2.2.64/26') + other = ipaddress.IPv4Network('1.2.3.0/30') + other2 = ipaddress.IPv4Network('1.2.2.0/24') + other3 = ipaddress.IPv4Network('1.2.2.64/26') self.assertTrue(self.ipv4_network.overlaps(other)) self.assertFalse(self.ipv4_network.overlaps(other2)) self.assertTrue(other2.overlaps(other3)) def testEmbeddedIpv4(self): - ipv4_string = u'192.168.0.1' + ipv4_string = '192.168.0.1' ipv4 = ipaddress.IPv4Interface(ipv4_string) - v4compat_ipv6 = ipaddress.IPv6Interface(u'::%s' % ipv4_string) + v4compat_ipv6 = ipaddress.IPv6Interface('::%s' % ipv4_string) self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip)) - v4mapped_ipv6 = ipaddress.IPv6Interface(u'::ffff:%s' % ipv4_string) + v4mapped_ipv6 = ipaddress.IPv6Interface('::ffff:%s' % ipv4_string) self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip) self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface, - u'2001:1.1.1.1:1.1.1.1') + '2001:1.1.1.1:1.1.1.1') # Issue 67: IPv6 with embedded IPv4 address not recognized. def testIPv6AddressTooLarge(self): # RFC4291 2.5.5.2 - self.assertEqual(ipaddress.ip_address(u'::FFFF:192.0.2.1'), - ipaddress.ip_address(u'::FFFF:c000:201')) + self.assertEqual(ipaddress.ip_address('::FFFF:192.0.2.1'), + ipaddress.ip_address('::FFFF:c000:201')) # RFC4291 2.2 (part 3) x::d.d.d.d - self.assertEqual(ipaddress.ip_address(u'FFFF::192.0.2.1'), - ipaddress.ip_address(u'FFFF::c000:201')) + self.assertEqual(ipaddress.ip_address('FFFF::192.0.2.1'), + ipaddress.ip_address('FFFF::c000:201')) def testIPVersion(self): self.assertEqual(self.ipv4_address.version, 4) @@ -1280,27 +1282,27 @@ class IpaddrUnitTest(unittest.TestCase): def testPacked(self): self.assertEqual(self.ipv4_address.packed, b'\x01\x02\x03\x04') - self.assertEqual(ipaddress.IPv4Interface(u'255.254.253.252').packed, + self.assertEqual(ipaddress.IPv4Interface('255.254.253.252').packed, b'\xff\xfe\xfd\xfc') self.assertEqual(self.ipv6_address.packed, b'\x20\x01\x06\x58\x02\x2a\xca\xfe' b'\x02\x00\x00\x00\x00\x00\x00\x01') - self.assertEqual(ipaddress.IPv6Interface(u'ffff:2:3:4:ffff::').packed, + self.assertEqual(ipaddress.IPv6Interface('ffff:2:3:4:ffff::').packed, b'\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff' + b'\x00' * 6) - self.assertEqual(ipaddress.IPv6Interface(u'::1:0:0:0:0').packed, + self.assertEqual(ipaddress.IPv6Interface('::1:0:0:0:0').packed, b'\x00' * 6 + b'\x00\x01' + b'\x00' * 8) def testIpStrFromPrefixlen(self): - ipv4 = ipaddress.IPv4Interface(u'1.2.3.4/24') - self.assertEqual(ipv4._ip_string_from_prefix(), u'255.255.255.0') - self.assertEqual(ipv4._ip_string_from_prefix(28), u'255.255.255.240') + ipv4 = ipaddress.IPv4Interface('1.2.3.4/24') + self.assertEqual(ipv4._ip_string_from_prefix(), '255.255.255.0') + self.assertEqual(ipv4._ip_string_from_prefix(28), '255.255.255.240') def testIpType(self): - ipv4net = ipaddress.ip_network(u'1.2.3.4') - ipv4addr = ipaddress.ip_address(u'1.2.3.4') - ipv6net = ipaddress.ip_network(u'::1.2.3.4') - ipv6addr = ipaddress.ip_address(u'::1.2.3.4') + ipv4net = ipaddress.ip_network('1.2.3.4') + ipv4addr = ipaddress.ip_address('1.2.3.4') + ipv6net = ipaddress.ip_network('::1.2.3.4') + ipv6addr = ipaddress.ip_address('::1.2.3.4') self.assertEqual(ipaddress.IPv4Network, type(ipv4net)) self.assertEqual(ipaddress.IPv4Address, type(ipv4addr)) self.assertEqual(ipaddress.IPv6Network, type(ipv6net)) @@ -1309,173 +1311,173 @@ class IpaddrUnitTest(unittest.TestCase): def testReservedIpv4(self): # test networks self.assertEqual(True, ipaddress.ip_interface( - u'224.1.1.1/31').is_multicast) - self.assertEqual(False, ipaddress.ip_network(u'240.0.0.0').is_multicast) - self.assertEqual(True, ipaddress.ip_network(u'240.0.0.0').is_reserved) + '224.1.1.1/31').is_multicast) + self.assertEqual(False, ipaddress.ip_network('240.0.0.0').is_multicast) + self.assertEqual(True, ipaddress.ip_network('240.0.0.0').is_reserved) self.assertEqual(True, ipaddress.ip_interface( - u'192.168.1.1/17').is_private) - self.assertEqual(False, ipaddress.ip_network(u'192.169.0.0').is_private) + '192.168.1.1/17').is_private) + self.assertEqual(False, ipaddress.ip_network('192.169.0.0').is_private) self.assertEqual(True, ipaddress.ip_network( - u'10.255.255.255').is_private) - self.assertEqual(False, ipaddress.ip_network(u'11.0.0.0').is_private) - self.assertEqual(False, ipaddress.ip_network(u'11.0.0.0').is_reserved) + '10.255.255.255').is_private) + self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_private) + self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_reserved) self.assertEqual(True, ipaddress.ip_network( - u'172.31.255.255').is_private) - self.assertEqual(False, ipaddress.ip_network(u'172.32.0.0').is_private) + '172.31.255.255').is_private) + self.assertEqual(False, ipaddress.ip_network('172.32.0.0').is_private) self.assertEqual(True, - ipaddress.ip_network(u'169.254.1.0/24').is_link_local) + ipaddress.ip_network('169.254.1.0/24').is_link_local) self.assertEqual(True, ipaddress.ip_interface( - u'169.254.100.200/24').is_link_local) + '169.254.100.200/24').is_link_local) self.assertEqual(False, ipaddress.ip_interface( - u'169.255.100.200/24').is_link_local) + '169.255.100.200/24').is_link_local) self.assertEqual(True, ipaddress.ip_network( - u'127.100.200.254/32').is_loopback) + '127.100.200.254/32').is_loopback) self.assertEqual(True, ipaddress.ip_network( - u'127.42.0.0/16').is_loopback) - self.assertEqual(False, ipaddress.ip_network(u'128.0.0.0').is_loopback) + '127.42.0.0/16').is_loopback) + self.assertEqual(False, ipaddress.ip_network('128.0.0.0').is_loopback) # test addresses - self.assertEqual(True, ipaddress.ip_address(u'0.0.0.0').is_unspecified) - self.assertEqual(True, ipaddress.ip_address(u'224.1.1.1').is_multicast) - self.assertEqual(False, ipaddress.ip_address(u'240.0.0.0').is_multicast) - self.assertEqual(True, ipaddress.ip_address(u'240.0.0.1').is_reserved) + self.assertEqual(True, ipaddress.ip_address('0.0.0.0').is_unspecified) + self.assertEqual(True, ipaddress.ip_address('224.1.1.1').is_multicast) + self.assertEqual(False, ipaddress.ip_address('240.0.0.0').is_multicast) + self.assertEqual(True, ipaddress.ip_address('240.0.0.1').is_reserved) self.assertEqual(False, - ipaddress.ip_address(u'239.255.255.255').is_reserved) + ipaddress.ip_address('239.255.255.255').is_reserved) - self.assertEqual(True, ipaddress.ip_address(u'192.168.1.1').is_private) - self.assertEqual(False, ipaddress.ip_address(u'192.169.0.0').is_private) + self.assertEqual(True, ipaddress.ip_address('192.168.1.1').is_private) + self.assertEqual(False, ipaddress.ip_address('192.169.0.0').is_private) self.assertEqual(True, ipaddress.ip_address( - u'10.255.255.255').is_private) - self.assertEqual(False, ipaddress.ip_address(u'11.0.0.0').is_private) + '10.255.255.255').is_private) + self.assertEqual(False, ipaddress.ip_address('11.0.0.0').is_private) self.assertEqual(True, ipaddress.ip_address( - u'172.31.255.255').is_private) - self.assertEqual(False, ipaddress.ip_address(u'172.32.0.0').is_private) + '172.31.255.255').is_private) + self.assertEqual(False, ipaddress.ip_address('172.32.0.0').is_private) self.assertEqual(True, - ipaddress.ip_address(u'169.254.100.200').is_link_local) + ipaddress.ip_address('169.254.100.200').is_link_local) self.assertEqual(False, - ipaddress.ip_address(u'169.255.100.200').is_link_local) + ipaddress.ip_address('169.255.100.200').is_link_local) self.assertEqual(True, - ipaddress.ip_address(u'127.100.200.254').is_loopback) - self.assertEqual(True, ipaddress.ip_address(u'127.42.0.0').is_loopback) - self.assertEqual(False, ipaddress.ip_address(u'128.0.0.0').is_loopback) - self.assertEqual(True, ipaddress.ip_network(u'0.0.0.0').is_unspecified) + ipaddress.ip_address('127.100.200.254').is_loopback) + self.assertEqual(True, ipaddress.ip_address('127.42.0.0').is_loopback) + self.assertEqual(False, ipaddress.ip_address('128.0.0.0').is_loopback) + self.assertEqual(True, ipaddress.ip_network('0.0.0.0').is_unspecified) def testReservedIpv6(self): - self.assertEqual(True, ipaddress.ip_network(u'ffff::').is_multicast) + self.assertEqual(True, ipaddress.ip_network('ffff::').is_multicast) self.assertEqual(True, ipaddress.ip_network(2**128 - 1).is_multicast) - self.assertEqual(True, ipaddress.ip_network(u'ff00::').is_multicast) - self.assertEqual(False, ipaddress.ip_network(u'fdff::').is_multicast) + self.assertEqual(True, ipaddress.ip_network('ff00::').is_multicast) + self.assertEqual(False, ipaddress.ip_network('fdff::').is_multicast) - self.assertEqual(True, ipaddress.ip_network(u'fecf::').is_site_local) + self.assertEqual(True, ipaddress.ip_network('fecf::').is_site_local) self.assertEqual(True, ipaddress.ip_network( - u'feff:ffff:ffff:ffff::').is_site_local) + 'feff:ffff:ffff:ffff::').is_site_local) self.assertEqual(False, ipaddress.ip_network( - u'fbf:ffff::').is_site_local) - self.assertEqual(False, ipaddress.ip_network(u'ff00::').is_site_local) + 'fbf:ffff::').is_site_local) + self.assertEqual(False, ipaddress.ip_network('ff00::').is_site_local) - self.assertEqual(True, ipaddress.ip_network(u'fc00::').is_private) + self.assertEqual(True, ipaddress.ip_network('fc00::').is_private) self.assertEqual(True, ipaddress.ip_network( - u'fc00:ffff:ffff:ffff::').is_private) - self.assertEqual(False, ipaddress.ip_network(u'fbff:ffff::').is_private) - self.assertEqual(False, ipaddress.ip_network(u'fe00::').is_private) + 'fc00:ffff:ffff:ffff::').is_private) + self.assertEqual(False, ipaddress.ip_network('fbff:ffff::').is_private) + self.assertEqual(False, ipaddress.ip_network('fe00::').is_private) - self.assertEqual(True, ipaddress.ip_network(u'fea0::').is_link_local) + self.assertEqual(True, ipaddress.ip_network('fea0::').is_link_local) self.assertEqual(True, ipaddress.ip_network( - u'febf:ffff::').is_link_local) + 'febf:ffff::').is_link_local) self.assertEqual(False, ipaddress.ip_network( - u'fe7f:ffff::').is_link_local) - self.assertEqual(False, ipaddress.ip_network(u'fec0::').is_link_local) + 'fe7f:ffff::').is_link_local) + self.assertEqual(False, ipaddress.ip_network('fec0::').is_link_local) - self.assertEqual(True, ipaddress.ip_interface(u'0:0::0:01').is_loopback) - self.assertEqual(False, ipaddress.ip_interface(u'::1/127').is_loopback) - self.assertEqual(False, ipaddress.ip_network(u'::').is_loopback) - self.assertEqual(False, ipaddress.ip_network(u'::2').is_loopback) + self.assertEqual(True, ipaddress.ip_interface('0:0::0:01').is_loopback) + self.assertEqual(False, ipaddress.ip_interface('::1/127').is_loopback) + self.assertEqual(False, ipaddress.ip_network('::').is_loopback) + self.assertEqual(False, ipaddress.ip_network('::2').is_loopback) - self.assertEqual(True, ipaddress.ip_network(u'0::0').is_unspecified) - self.assertEqual(False, ipaddress.ip_network(u'::1').is_unspecified) - self.assertEqual(False, ipaddress.ip_network(u'::/127').is_unspecified) + self.assertEqual(True, ipaddress.ip_network('0::0').is_unspecified) + self.assertEqual(False, ipaddress.ip_network('::1').is_unspecified) + self.assertEqual(False, ipaddress.ip_network('::/127').is_unspecified) # test addresses - self.assertEqual(True, ipaddress.ip_address(u'ffff::').is_multicast) + self.assertEqual(True, ipaddress.ip_address('ffff::').is_multicast) self.assertEqual(True, ipaddress.ip_address(2**128 - 1).is_multicast) - self.assertEqual(True, ipaddress.ip_address(u'ff00::').is_multicast) - self.assertEqual(False, ipaddress.ip_address(u'fdff::').is_multicast) + self.assertEqual(True, ipaddress.ip_address('ff00::').is_multicast) + self.assertEqual(False, ipaddress.ip_address('fdff::').is_multicast) - self.assertEqual(True, ipaddress.ip_address(u'fecf::').is_site_local) + self.assertEqual(True, ipaddress.ip_address('fecf::').is_site_local) self.assertEqual(True, ipaddress.ip_address( - u'feff:ffff:ffff:ffff::').is_site_local) + 'feff:ffff:ffff:ffff::').is_site_local) self.assertEqual(False, ipaddress.ip_address( - u'fbf:ffff::').is_site_local) - self.assertEqual(False, ipaddress.ip_address(u'ff00::').is_site_local) + 'fbf:ffff::').is_site_local) + self.assertEqual(False, ipaddress.ip_address('ff00::').is_site_local) - self.assertEqual(True, ipaddress.ip_address(u'fc00::').is_private) + self.assertEqual(True, ipaddress.ip_address('fc00::').is_private) self.assertEqual(True, ipaddress.ip_address( - u'fc00:ffff:ffff:ffff::').is_private) - self.assertEqual(False, ipaddress.ip_address(u'fbff:ffff::').is_private) - self.assertEqual(False, ipaddress.ip_address(u'fe00::').is_private) + 'fc00:ffff:ffff:ffff::').is_private) + self.assertEqual(False, ipaddress.ip_address('fbff:ffff::').is_private) + self.assertEqual(False, ipaddress.ip_address('fe00::').is_private) - self.assertEqual(True, ipaddress.ip_address(u'fea0::').is_link_local) + self.assertEqual(True, ipaddress.ip_address('fea0::').is_link_local) self.assertEqual(True, ipaddress.ip_address( - u'febf:ffff::').is_link_local) + 'febf:ffff::').is_link_local) self.assertEqual(False, ipaddress.ip_address( - u'fe7f:ffff::').is_link_local) - self.assertEqual(False, ipaddress.ip_address(u'fec0::').is_link_local) + 'fe7f:ffff::').is_link_local) + self.assertEqual(False, ipaddress.ip_address('fec0::').is_link_local) - self.assertEqual(True, ipaddress.ip_address(u'0:0::0:01').is_loopback) - self.assertEqual(True, ipaddress.ip_address(u'::1').is_loopback) - self.assertEqual(False, ipaddress.ip_address(u'::2').is_loopback) + self.assertEqual(True, ipaddress.ip_address('0:0::0:01').is_loopback) + self.assertEqual(True, ipaddress.ip_address('::1').is_loopback) + self.assertEqual(False, ipaddress.ip_address('::2').is_loopback) - self.assertEqual(True, ipaddress.ip_address(u'0::0').is_unspecified) - self.assertEqual(False, ipaddress.ip_address(u'::1').is_unspecified) + self.assertEqual(True, ipaddress.ip_address('0::0').is_unspecified) + self.assertEqual(False, ipaddress.ip_address('::1').is_unspecified) # some generic IETF reserved addresses - self.assertEqual(True, ipaddress.ip_address(u'100::').is_reserved) - self.assertEqual(True, ipaddress.ip_network(u'4000::1/128').is_reserved) + self.assertEqual(True, ipaddress.ip_address('100::').is_reserved) + self.assertEqual(True, ipaddress.ip_network('4000::1/128').is_reserved) def testIpv4Mapped(self): self.assertEqual( - ipaddress.ip_address(u'::ffff:192.168.1.1').ipv4_mapped, - ipaddress.ip_address(u'192.168.1.1')) - self.assertEqual(ipaddress.ip_address(u'::c0a8:101').ipv4_mapped, None) - self.assertEqual(ipaddress.ip_address(u'::ffff:c0a8:101').ipv4_mapped, - ipaddress.ip_address(u'192.168.1.1')) + ipaddress.ip_address('::ffff:192.168.1.1').ipv4_mapped, + ipaddress.ip_address('192.168.1.1')) + self.assertEqual(ipaddress.ip_address('::c0a8:101').ipv4_mapped, None) + self.assertEqual(ipaddress.ip_address('::ffff:c0a8:101').ipv4_mapped, + ipaddress.ip_address('192.168.1.1')) def testAddrExclude(self): - addr1 = ipaddress.ip_network(u'10.1.1.0/24') - addr2 = ipaddress.ip_network(u'10.1.1.0/26') - addr3 = ipaddress.ip_network(u'10.2.1.0/24') - addr4 = ipaddress.ip_address(u'10.1.1.0') - addr5 = ipaddress.ip_network(u'2001:db8::0/32') + addr1 = ipaddress.ip_network('10.1.1.0/24') + addr2 = ipaddress.ip_network('10.1.1.0/26') + addr3 = ipaddress.ip_network('10.2.1.0/24') + addr4 = ipaddress.ip_address('10.1.1.0') + addr5 = ipaddress.ip_network('2001:db8::0/32') self.assertEqual(sorted(list(addr1.address_exclude(addr2))), - [ipaddress.ip_network(u'10.1.1.64/26'), - ipaddress.ip_network(u'10.1.1.128/25')]) + [ipaddress.ip_network('10.1.1.64/26'), + ipaddress.ip_network('10.1.1.128/25')]) self.assertRaises(ValueError, list, addr1.address_exclude(addr3)) self.assertRaises(TypeError, list, addr1.address_exclude(addr4)) self.assertRaises(TypeError, list, addr1.address_exclude(addr5)) self.assertEqual(list(addr1.address_exclude(addr1)), []) def testHash(self): - self.assertEqual(hash(ipaddress.ip_interface(u'10.1.1.0/24')), - hash(ipaddress.ip_interface(u'10.1.1.0/24'))) - self.assertEqual(hash(ipaddress.ip_network(u'10.1.1.0/24')), - hash(ipaddress.ip_network(u'10.1.1.0/24'))) - self.assertEqual(hash(ipaddress.ip_address(u'10.1.1.0')), - hash(ipaddress.ip_address(u'10.1.1.0'))) + self.assertEqual(hash(ipaddress.ip_interface('10.1.1.0/24')), + hash(ipaddress.ip_interface('10.1.1.0/24'))) + self.assertEqual(hash(ipaddress.ip_network('10.1.1.0/24')), + hash(ipaddress.ip_network('10.1.1.0/24'))) + self.assertEqual(hash(ipaddress.ip_address('10.1.1.0')), + hash(ipaddress.ip_address('10.1.1.0'))) # i70 - self.assertEqual(hash(ipaddress.ip_address(u'1.2.3.4')), + self.assertEqual(hash(ipaddress.ip_address('1.2.3.4')), hash(ipaddress.ip_address( - int(ipaddress.ip_address(u'1.2.3.4')._ip)))) - ip1 = ipaddress.ip_address(u'10.1.1.0') - ip2 = ipaddress.ip_address(u'1::') + int(ipaddress.ip_address('1.2.3.4')._ip)))) + ip1 = ipaddress.ip_address('10.1.1.0') + ip2 = ipaddress.ip_address('1::') dummy = {} dummy[self.ipv4_address] = None dummy[self.ipv6_address] = None @@ -1486,7 +1488,7 @@ class IpaddrUnitTest(unittest.TestCase): def testIPBases(self): net = self.ipv4_network - self.assertEqual(u'1.2.3.0/24', net.compressed) + self.assertEqual('1.2.3.0/24', net.compressed) self.assertEqual( net._ip_int_from_prefix(24), net._ip_int_from_prefix(None)) @@ -1498,27 +1500,27 @@ class IpaddrUnitTest(unittest.TestCase): def testIPv6NetworkHelpers(self): net = self.ipv6_network - self.assertEqual(u'2001:658:22a:cafe::/64', net.with_prefixlen) - self.assertEqual(u'2001:658:22a:cafe::/ffff:ffff:ffff:ffff::', + self.assertEqual('2001:658:22a:cafe::/64', net.with_prefixlen) + self.assertEqual('2001:658:22a:cafe::/ffff:ffff:ffff:ffff::', net.with_netmask) - self.assertEqual(u'2001:658:22a:cafe::/::ffff:ffff:ffff:ffff', + self.assertEqual('2001:658:22a:cafe::/::ffff:ffff:ffff:ffff', net.with_hostmask) - self.assertEqual(u'2001:658:22a:cafe::/64', str(net)) + self.assertEqual('2001:658:22a:cafe::/64', str(net)) def testIPv4NetworkHelpers(self): net = self.ipv4_network - self.assertEqual(u'1.2.3.0/24', net.with_prefixlen) - self.assertEqual(u'1.2.3.0/255.255.255.0', net.with_netmask) - self.assertEqual(u'1.2.3.0/0.0.0.255', net.with_hostmask) - self.assertEqual(u'1.2.3.0/24', str(net)) + self.assertEqual('1.2.3.0/24', net.with_prefixlen) + self.assertEqual('1.2.3.0/255.255.255.0', net.with_netmask) + self.assertEqual('1.2.3.0/0.0.0.255', net.with_hostmask) + self.assertEqual('1.2.3.0/24', str(net)) def testCopyConstructor(self): - addr1 = ipaddress.ip_network(u'10.1.1.0/24') + addr1 = ipaddress.ip_network('10.1.1.0/24') addr2 = ipaddress.ip_network(addr1) - addr3 = ipaddress.ip_interface(u'2001:658:22a:cafe:200::1/64') + addr3 = ipaddress.ip_interface('2001:658:22a:cafe:200::1/64') addr4 = ipaddress.ip_interface(addr3) - addr5 = ipaddress.IPv4Address(u'1.1.1.1') - addr6 = ipaddress.IPv6Address(u'2001:658:22a:cafe:200::1') + addr5 = ipaddress.IPv4Address('1.1.1.1') + addr6 = ipaddress.IPv6Address('2001:658:22a:cafe:200::1') self.assertEqual(addr1, addr2) self.assertEqual(addr3, addr4) @@ -1527,46 +1529,46 @@ class IpaddrUnitTest(unittest.TestCase): def testCompressIPv6Address(self): test_addresses = { - u'1:2:3:4:5:6:7:8': u'1:2:3:4:5:6:7:8/128', - u'2001:0:0:4:0:0:0:8': u'2001:0:0:4::8/128', - u'2001:0:0:4:5:6:7:8': u'2001::4:5:6:7:8/128', - u'2001:0:3:4:5:6:7:8': u'2001:0:3:4:5:6:7:8/128', - u'2001:0:3:4:5:6:7:8': u'2001:0:3:4:5:6:7:8/128', - u'0:0:3:0:0:0:0:ffff': u'0:0:3::ffff/128', - u'0:0:0:4:0:0:0:ffff': u'::4:0:0:0:ffff/128', - u'0:0:0:0:5:0:0:ffff': u'::5:0:0:ffff/128', - u'1:0:0:4:0:0:7:8': u'1::4:0:0:7:8/128', - u'0:0:0:0:0:0:0:0': u'::/128', - u'0:0:0:0:0:0:0:0/0': u'::/0', - u'0:0:0:0:0:0:0:1': u'::1/128', - u'2001:0658:022a:cafe:0000:0000:0000:0000/66': - u'2001:658:22a:cafe::/66', - u'::1.2.3.4': u'::102:304/128', - u'1:2:3:4:5:ffff:1.2.3.4': u'1:2:3:4:5:ffff:102:304/128', - u'::7:6:5:4:3:2:1': u'0:7:6:5:4:3:2:1/128', - u'::7:6:5:4:3:2:0': u'0:7:6:5:4:3:2:0/128', - u'7:6:5:4:3:2:1::': u'7:6:5:4:3:2:1:0/128', - u'0:6:5:4:3:2:1::': u'0:6:5:4:3:2:1:0/128', + '1:2:3:4:5:6:7:8': '1:2:3:4:5:6:7:8/128', + '2001:0:0:4:0:0:0:8': '2001:0:0:4::8/128', + '2001:0:0:4:5:6:7:8': '2001::4:5:6:7:8/128', + '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128', + '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128', + '0:0:3:0:0:0:0:ffff': '0:0:3::ffff/128', + '0:0:0:4:0:0:0:ffff': '::4:0:0:0:ffff/128', + '0:0:0:0:5:0:0:ffff': '::5:0:0:ffff/128', + '1:0:0:4:0:0:7:8': '1::4:0:0:7:8/128', + '0:0:0:0:0:0:0:0': '::/128', + '0:0:0:0:0:0:0:0/0': '::/0', + '0:0:0:0:0:0:0:1': '::1/128', + '2001:0658:022a:cafe:0000:0000:0000:0000/66': + '2001:658:22a:cafe::/66', + '::1.2.3.4': '::102:304/128', + '1:2:3:4:5:ffff:1.2.3.4': '1:2:3:4:5:ffff:102:304/128', + '::7:6:5:4:3:2:1': '0:7:6:5:4:3:2:1/128', + '::7:6:5:4:3:2:0': '0:7:6:5:4:3:2:0/128', + '7:6:5:4:3:2:1::': '7:6:5:4:3:2:1:0/128', + '0:6:5:4:3:2:1::': '0:6:5:4:3:2:1:0/128', } for uncompressed, compressed in list(test_addresses.items()): self.assertEqual(compressed, str(ipaddress.IPv6Interface( uncompressed))) def testExplodeShortHandIpStr(self): - addr1 = ipaddress.IPv6Interface(u'2001::1') - addr2 = ipaddress.IPv6Address(u'2001:0:5ef5:79fd:0:59d:a0e5:ba1') - addr3 = ipaddress.IPv6Network(u'2001::/96') - addr4 = ipaddress.IPv4Address(u'192.168.178.1') - self.assertEqual(u'2001:0000:0000:0000:0000:0000:0000:0001/128', + addr1 = ipaddress.IPv6Interface('2001::1') + addr2 = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1') + addr3 = ipaddress.IPv6Network('2001::/96') + addr4 = ipaddress.IPv4Address('192.168.178.1') + self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0001/128', addr1.exploded) - self.assertEqual(u'0000:0000:0000:0000:0000:0000:0000:0001/128', - ipaddress.IPv6Interface(u'::1/128').exploded) + self.assertEqual('0000:0000:0000:0000:0000:0000:0000:0001/128', + ipaddress.IPv6Interface('::1/128').exploded) # issue 77 - self.assertEqual(u'2001:0000:5ef5:79fd:0000:059d:a0e5:0ba1', + self.assertEqual('2001:0000:5ef5:79fd:0000:059d:a0e5:0ba1', addr2.exploded) - self.assertEqual(u'2001:0000:0000:0000:0000:0000:0000:0000/96', + self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0000/96', addr3.exploded) - self.assertEqual(u'192.168.178.1', addr4.exploded) + self.assertEqual('192.168.178.1', addr4.exploded) def testIntRepresentation(self): self.assertEqual(16909060, int(self.ipv4_address)) @@ -1578,89 +1580,89 @@ class IpaddrUnitTest(unittest.TestCase): self.assertEqual(ipaddress.IPv6Network(1).version, 6) def testWithStar(self): - self.assertEqual(self.ipv4_interface.with_prefixlen, u"1.2.3.4/24") + self.assertEqual(self.ipv4_interface.with_prefixlen, "1.2.3.4/24") self.assertEqual(self.ipv4_interface.with_netmask, - u"1.2.3.4/255.255.255.0") + "1.2.3.4/255.255.255.0") self.assertEqual(self.ipv4_interface.with_hostmask, - u"1.2.3.4/0.0.0.255") + "1.2.3.4/0.0.0.255") self.assertEqual(self.ipv6_interface.with_prefixlen, - u'2001:658:22a:cafe:200::1/64') + '2001:658:22a:cafe:200::1/64') self.assertEqual(self.ipv6_interface.with_netmask, - u'2001:658:22a:cafe:200::1/ffff:ffff:ffff:ffff::') + '2001:658:22a:cafe:200::1/ffff:ffff:ffff:ffff::') # this probably don't make much sense, but it's included for # compatibility with ipv4 self.assertEqual(self.ipv6_interface.with_hostmask, - u'2001:658:22a:cafe:200::1/::ffff:ffff:ffff:ffff') + '2001:658:22a:cafe:200::1/::ffff:ffff:ffff:ffff') def testNetworkElementCaching(self): # V4 - make sure we're empty - self.assertFalse(u'network_address' in self.ipv4_network._cache) - self.assertFalse(u'broadcast_address' in self.ipv4_network._cache) - self.assertFalse(u'hostmask' in self.ipv4_network._cache) + self.assertFalse('network_address' in self.ipv4_network._cache) + self.assertFalse('broadcast_address' in self.ipv4_network._cache) + self.assertFalse('hostmask' in self.ipv4_network._cache) # V4 - populate and test self.assertEqual(self.ipv4_network.network_address, - ipaddress.IPv4Address(u'1.2.3.0')) + ipaddress.IPv4Address('1.2.3.0')) self.assertEqual(self.ipv4_network.broadcast_address, - ipaddress.IPv4Address(u'1.2.3.255')) + ipaddress.IPv4Address('1.2.3.255')) self.assertEqual(self.ipv4_network.hostmask, - ipaddress.IPv4Address(u'0.0.0.255')) + ipaddress.IPv4Address('0.0.0.255')) # V4 - check we're cached - self.assertTrue(u'broadcast_address' in self.ipv4_network._cache) - self.assertTrue(u'hostmask' in self.ipv4_network._cache) + self.assertTrue('broadcast_address' in self.ipv4_network._cache) + self.assertTrue('hostmask' in self.ipv4_network._cache) # V6 - make sure we're empty - self.assertFalse(u'broadcast_address' in self.ipv6_network._cache) - self.assertFalse(u'hostmask' in self.ipv6_network._cache) + self.assertFalse('broadcast_address' in self.ipv6_network._cache) + self.assertFalse('hostmask' in self.ipv6_network._cache) # V6 - populate and test self.assertEqual(self.ipv6_network.network_address, - ipaddress.IPv6Address(u'2001:658:22a:cafe::')) + ipaddress.IPv6Address('2001:658:22a:cafe::')) self.assertEqual(self.ipv6_interface.network.network_address, - ipaddress.IPv6Address(u'2001:658:22a:cafe::')) + ipaddress.IPv6Address('2001:658:22a:cafe::')) self.assertEqual( self.ipv6_network.broadcast_address, - ipaddress.IPv6Address(u'2001:658:22a:cafe:ffff:ffff:ffff:ffff')) + ipaddress.IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff')) self.assertEqual(self.ipv6_network.hostmask, - ipaddress.IPv6Address(u'::ffff:ffff:ffff:ffff')) + ipaddress.IPv6Address('::ffff:ffff:ffff:ffff')) self.assertEqual( self.ipv6_interface.network.broadcast_address, - ipaddress.IPv6Address(u'2001:658:22a:cafe:ffff:ffff:ffff:ffff')) + ipaddress.IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff')) self.assertEqual(self.ipv6_interface.network.hostmask, - ipaddress.IPv6Address(u'::ffff:ffff:ffff:ffff')) + ipaddress.IPv6Address('::ffff:ffff:ffff:ffff')) # V6 - check we're cached - self.assertTrue(u'broadcast_address' in self.ipv6_network._cache) - self.assertTrue(u'hostmask' in self.ipv6_network._cache) + self.assertTrue('broadcast_address' in self.ipv6_network._cache) + self.assertTrue('hostmask' in self.ipv6_network._cache) self.assertTrue( - u'broadcast_address' in self.ipv6_interface.network._cache) - self.assertTrue(u'hostmask' in self.ipv6_interface.network._cache) + 'broadcast_address' in self.ipv6_interface.network._cache) + self.assertTrue('hostmask' in self.ipv6_interface.network._cache) def testTeredo(self): # stolen from wikipedia - server = ipaddress.IPv4Address(u'65.54.227.120') - client = ipaddress.IPv4Address(u'192.0.2.45') - teredo_addr = u'2001:0000:4136:e378:8000:63bf:3fff:fdd2' + server = ipaddress.IPv4Address('65.54.227.120') + client = ipaddress.IPv4Address('192.0.2.45') + teredo_addr = '2001:0000:4136:e378:8000:63bf:3fff:fdd2' self.assertEqual((server, client), ipaddress.ip_address(teredo_addr).teredo) - bad_addr = u'2000::4136:e378:8000:63bf:3fff:fdd2' + bad_addr = '2000::4136:e378:8000:63bf:3fff:fdd2' self.assertFalse(ipaddress.ip_address(bad_addr).teredo) - bad_addr = u'2001:0001:4136:e378:8000:63bf:3fff:fdd2' + bad_addr = '2001:0001:4136:e378:8000:63bf:3fff:fdd2' self.assertFalse(ipaddress.ip_address(bad_addr).teredo) # i77 - teredo_addr = ipaddress.IPv6Address(u'2001:0:5ef5:79fd:0:59d:a0e5:ba1') - self.assertEqual((ipaddress.IPv4Address(u'94.245.121.253'), - ipaddress.IPv4Address(u'95.26.244.94')), + teredo_addr = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1') + self.assertEqual((ipaddress.IPv4Address('94.245.121.253'), + ipaddress.IPv4Address('95.26.244.94')), teredo_addr.teredo) def testsixtofour(self): - sixtofouraddr = ipaddress.ip_address(u'2002:ac1d:2d64::1') - bad_addr = ipaddress.ip_address(u'2000:ac1d:2d64::1') - self.assertEqual(ipaddress.IPv4Address(u'172.29.45.100'), + sixtofouraddr = ipaddress.ip_address('2002:ac1d:2d64::1') + bad_addr = ipaddress.ip_address('2000:ac1d:2d64::1') + self.assertEqual(ipaddress.IPv4Address('172.29.45.100'), sixtofouraddr.sixtofour) self.assertFalse(bad_addr.sixtofour) @@ -1694,7 +1696,7 @@ if not hasattr(BaseTestCase, 'assertRaisesRegex'): expected_regex = self.expected_regex if not expected_regex.search(str(exc_value)): - raise AssertionError(u'"{}" does not match "{}"'.format( + raise AssertionError('"{}" does not match "{}"'.format( expected_regex.pattern, str(exc_value))) return True @@ -1714,11 +1716,11 @@ if not hasattr(BaseTestCase, 'assertIn'): # Test for https://github.com/phihag/ipaddress/pull/6 class Python2RangeTest(unittest.TestCase): def test_network_hosts(self): - net = ipaddress.ip_network(u'::/0') + net = ipaddress.ip_network('::/0') next(net.hosts()) # This should not throw OverflowError def test_network_iter(self): - net = ipaddress.ip_network(u'::/0') + net = ipaddress.ip_network('::/0') next(iter(net)) # This should not throw OverflowError |