rename to ipaddress to avoid confusion with backwards-incompatible ipaddr

2 files changed, 410 insertions, 410 deletions

diff --git a/branches/3144/ipaddr.py b/branches/3144/ipaddress.py
index 5487d7a..ec53973 100644
--- a/branches/3144/ipaddr.py
+++ b/branches/3144/ipaddress.py
@@ -433,7 +433,7 @@ def get_mixed_type_key(obj):
         IPv4Address('1.1.1.1') <= IPv4Network('1.1.1.1/24')
 
     doesn't make any sense.  There are some times however, where you may wish
-    to have ipaddr sort these for you anyway. If you need to do this, you
+    to have ipaddress sort these for you anyway. If you need to do this, you
     can use this function as the key= argument to sorted().
 
     Args:
@@ -448,7 +448,7 @@ def get_mixed_type_key(obj):
         return obj._get_address_key()
     return NotImplemented
 
-class _IPAddrBase(object):
+class _IPAddressBase(object):
 
     """The mother class."""
 
@@ -472,7 +472,7 @@ class _IPAddrBase(object):
         return str(self)
 
 
-class _BaseAddress(_IPAddrBase):
+class _BaseAddress(_IPAddressBase):
 
     """A generic IP object.
 
@@ -562,7 +562,7 @@ class _BaseAddress(_IPAddrBase):
         raise NotImplementedError('BaseIP has no version')
 
 
-class _BaseInterface(_IPAddrBase):
+class _BaseInterface(_IPAddressBase):
 
     """A generic IP object.
 
@@ -1237,7 +1237,7 @@ class IPv4Address(_BaseV4, _BaseAddress):
                 IPv4Address('192.168.1.1')
 
         Raises:
-            AddressValueError: If ipaddr isn't a valid IPv4 address.
+            AddressValueError: If ipaddressisn't a valid IPv4 address.
 
         """
         _BaseAddress.__init__(self, address)
@@ -1309,7 +1309,7 @@ class IPv4Interface(_BaseV4, _BaseInterface):
                 IPv4Interface('192.168.1.1')
 
         Raises:
-            AddressValueError: If ipaddr isn't a valid IPv4 address.
+            AddressValueError: If ipaddressisn't a valid IPv4 address.
             NetmaskValueError: If the netmask isn't valid for
               an IPv4 address.
             ValueError: If strict was True and a network address was not
diff --git a/branches/3144/ipaddr_test.py b/branches/3144/ipaddress_test.py
index 0239550..a8ec9c5 100755
--- a/branches/3144/ipaddr_test.py
+++ b/branches/3144/ipaddress_test.py
@@ -15,15 +15,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Unittest for ipaddr module."""
+"""Unittest for ipaddressmodule."""
 
 
 import unittest
 import time
-import ipaddr
+import ipaddress
 
 # Compatibility function to cast str to bytes objects
-if ipaddr._compat_has_real_bytes:
+if ipaddress._compat_has_real_bytes:
     _cb = lambda bytestr: bytes(bytestr, 'charmap')
 else:
     _cb = str
@@ -31,10 +31,10 @@ else:
 class IpaddrUnitTest(unittest.TestCase):
 
     def setUp(self):
-        self.ipv4 = ipaddr.IPv4Interface('1.2.3.4/24')
-        self.ipv4_hostmask = ipaddr.IPv4Interface('10.0.0.1/0.255.255.255')
+        self.ipv4 = ipaddress.IPv4Interface('1.2.3.4/24')
+        self.ipv4_hostmask = ipaddress.IPv4Interface('10.0.0.1/0.255.255.255')
 
-        self.ipv6 = ipaddr.IPv6Interface('2001:658:22a:cafe:200:0:0:1/64')
+        self.ipv6 = ipaddress.IPv6Interface('2001:658:22a:cafe:200:0:0:1/64')
 
     def tearDown(self):
         del(self.ipv4)
@@ -44,33 +44,33 @@ class IpaddrUnitTest(unittest.TestCase):
 
     def testRepr(self):
         self.assertEqual("IPv4Interface('1.2.3.4/32')",
-                         repr(ipaddr.IPv4Interface('1.2.3.4')))
+                         repr(ipaddress.IPv4Interface('1.2.3.4')))
         self.assertEqual("IPv6Interface('::1/128')",
-                         repr(ipaddr.IPv6Interface('::1')))
+                         repr(ipaddress.IPv6Interface('::1')))
 
     def testAutoMasking(self):
-        addr1 = ipaddr.IPv4Interface('1.1.1.255/24')
-        addr1_masked = ipaddr.IPv4Interface('1.1.1.0/24')
+        addr1 = ipaddress.IPv4Interface('1.1.1.255/24')
+        addr1_masked = ipaddress.IPv4Interface('1.1.1.0/24')
         self.assertEqual(addr1_masked, addr1.masked())
 
-        addr2 = ipaddr.IPv6Interface('2000:cafe::efac:100/96')
-        addr2_masked = ipaddr.IPv6Interface('2000:cafe::/96')
+        addr2 = ipaddress.IPv6Interface('2000:cafe::efac:100/96')
+        addr2_masked = ipaddress.IPv6Interface('2000:cafe::/96')
         self.assertEqual(addr2_masked, addr2.masked())
 
     # issue57
     def testAddressIntMath(self):
-        self.assertEqual(ipaddr.IPv4Address('1.1.1.1') + 255,
-                         ipaddr.IPv4Address('1.1.2.0'))
-        self.assertEqual(ipaddr.IPv4Address('1.1.1.1') - 256,
-                         ipaddr.IPv4Address('1.1.0.1'))
-        self.assertEqual(ipaddr.IPv6Address('::1') + (2**16 - 2),
-                         ipaddr.IPv6Address('::ffff'))
-        self.assertEqual(ipaddr.IPv6Address('::ffff') - (2**16 - 2),
-                         ipaddr.IPv6Address('::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 testInvalidStrings(self):
         def AssertInvalidIP(ip_str):
-            self.assertRaises(ValueError, ipaddr.ip_address, ip_str)
+            self.assertRaises(ValueError, ipaddress.ip_address, ip_str)
         AssertInvalidIP("")
         AssertInvalidIP("016.016.016.016")
         AssertInvalidIP("016.016.016")
@@ -133,30 +133,30 @@ class IpaddrUnitTest(unittest.TestCase):
         AssertInvalidIP("1:2:3:4:5:6:7:")
         AssertInvalidIP(":1:2:3:4:5:6:")
 
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Interface, '')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Interface,
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv4Interface, '')
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv4Interface,
                           'google.com')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Interface,
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv4Interface,
                           '::1.2.3.4')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Interface, '')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Interface,
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface, '')
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
                           'google.com')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Interface,
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
                           '1.2.3.4')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Interface,
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
                           'cafe:cafe::/128/190')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Interface,
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
                           '1234:axy::b')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Address,
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Address,
                           '1234:axy::b')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Address,
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Address,
                           '2001:db8:::1')
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Address,
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Address,
                           '2001:888888::1')
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv4Address(1)._ip_int_from_string,
+        self.assertRaises(ipaddress.AddressValueError,
+                          ipaddress.IPv4Address(1)._ip_int_from_string,
                           '1.a.2.3')
-        self.assertEqual(False, ipaddr.IPv4Interface(1)._is_hostmask('1.a.2.3'))
+        self.assertEqual(False, ipaddress.IPv4Interface(1)._is_hostmask('1.a.2.3'))
 
     def testGetNetwork(self):
         self.assertEqual(int(self.ipv4.network_address), 16909056)
@@ -172,10 +172,10 @@ class IpaddrUnitTest(unittest.TestCase):
 
     def testBadVersionComparison(self):
         # These should always raise TypeError
-        v4addr = ipaddr.ip_address('1.1.1.1')
-        v4net = ipaddr.ip_network('1.1.1.1')
-        v6addr = ipaddr.ip_address('::1')
-        v6net = ipaddr.ip_address('::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)
@@ -188,10 +188,10 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertRaises(TypeError, v6net.__gt__, v4net)
 
     def testMixedTypeComparison(self):
-        v4addr = ipaddr.ip_address('1.1.1.1')
-        v4net = ipaddr.ip_network('1.1.1.1/32')
-        v6addr = ipaddr.ip_address('::1')
-        v6net = ipaddr.ip_network('::1/128')
+        v4addr = ipaddress.ip_address('1.1.1.1')
+        v4net = ipaddress.ip_network('1.1.1.1/32')
+        v6addr = ipaddress.ip_address('::1')
+        v6net = ipaddress.ip_network('::1/128')
 
         self.assertFalse(v4net.__contains__(v6net))
         self.assertFalse(v6net.__contains__(v4net))
@@ -208,42 +208,42 @@ class IpaddrUnitTest(unittest.TestCase):
 
         # with get_mixed_type_key, you can sort addresses and network.
         self.assertEqual([v4addr, v4net], sorted([v4net, v4addr],
-                                                 key=ipaddr.get_mixed_type_key))
+                                                 key=ipaddress.get_mixed_type_key))
         self.assertEqual([v6addr, v6net], sorted([v6net, v6addr],
-                                                 key=ipaddr.get_mixed_type_key))
+                                                 key=ipaddress.get_mixed_type_key))
 
     def testIpFromInt(self):
-        self.assertEqual(self.ipv4.ip, ipaddr.IPv4Interface(16909060).ip)
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv4Interface, 2**32)
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv4Interface, -1)
+        self.assertEqual(self.ipv4.ip, ipaddress.IPv4Interface(16909060).ip)
+        self.assertRaises(ipaddress.AddressValueError,
+                          ipaddress.IPv4Interface, 2**32)
+        self.assertRaises(ipaddress.AddressValueError,
+                          ipaddress.IPv4Interface, -1)
 
-        ipv4 = ipaddr.ip_network('1.2.3.4')
-        ipv6 = ipaddr.ip_network('2001:658:22a:cafe:200:0:0:1')
-        self.assertEqual(ipv4, ipaddr.ip_network(int(ipv4)))
-        self.assertEqual(ipv6, ipaddr.ip_network(int(ipv6)))
+        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)))
+        self.assertEqual(ipv6, ipaddress.ip_network(int(ipv6)))
 
         v6_int = 42540616829182469433547762482097946625
-        self.assertEqual(self.ipv6.ip, ipaddr.IPv6Interface(v6_int).ip)
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv6Interface, 2**128)
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv6Interface, -1)
+        self.assertEqual(self.ipv6.ip, ipaddress.IPv6Interface(v6_int).ip)
+        self.assertRaises(ipaddress.AddressValueError,
+                          ipaddress.IPv6Interface, 2**128)
+        self.assertRaises(ipaddress.AddressValueError,
+                          ipaddress.IPv6Interface, -1)
 
-        self.assertEqual(ipaddr.ip_network(self.ipv4.ip).version, 4)
-        self.assertEqual(ipaddr.ip_network(self.ipv6.ip).version, 6)
+        self.assertEqual(ipaddress.ip_network(self.ipv4.ip).version, 4)
+        self.assertEqual(ipaddress.ip_network(self.ipv6.ip).version, 6)
 
-    if ipaddr._compat_has_real_bytes: # on python3+
+    if ipaddress._compat_has_real_bytes: # on python3+
         def testIpFromPacked(self):
-            ip = ipaddr.ip_network
+            ip = ipaddress.ip_network
 
             self.assertEqual(self.ipv4.ip,
                              ip(_cb('\x01\x02\x03\x04')).ip)
             self.assertEqual(ip('255.254.253.252'),
                              ip(_cb('\xff\xfe\xfd\xfc')))
-            self.assertRaises(ValueError, ipaddr.ip_network, _cb('\x00' * 3))
-            self.assertRaises(ValueError, ipaddr.ip_network, _cb('\x00' * 5))
+            self.assertRaises(ValueError, ipaddress.ip_network, _cb('\x00' * 3))
+            self.assertRaises(ValueError, ipaddress.ip_network, _cb('\x00' * 5))
             self.assertEqual(self.ipv6.ip,
                              ip(_cb('\x20\x01\x06\x58\x02\x2a\xca\xfe'
                                '\x02\x00\x00\x00\x00\x00\x00\x01')).ip)
@@ -274,11 +274,11 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(self.ipv6.prefixlen, 64)
 
     def testZeroNetmask(self):
-        ipv4_zero_netmask = ipaddr.IPv4Interface('1.2.3.4/0')
+        ipv4_zero_netmask = ipaddress.IPv4Interface('1.2.3.4/0')
         self.assertEqual(int(ipv4_zero_netmask.netmask), 0)
         self.assertTrue(ipv4_zero_netmask._is_valid_netmask(str(0)))
 
-        ipv6_zero_netmask = ipaddr.IPv6Interface('::1/0')
+        ipv6_zero_netmask = ipaddress.IPv6Interface('::1/0')
         self.assertEqual(int(ipv6_zero_netmask.netmask), 0)
         self.assertTrue(ipv6_zero_netmask._is_valid_netmask(str(0)))
 
@@ -299,14 +299,14 @@ class IpaddrUnitTest(unittest.TestCase):
     def testGetSupernet(self):
         self.assertEqual(self.ipv4.supernet().prefixlen, 23)
         self.assertEqual(str(self.ipv4.supernet().network_address), '1.2.2.0')
-        self.assertEqual(ipaddr.IPv4Interface('0.0.0.0/0').supernet(),
-                         ipaddr.IPv4Interface('0.0.0.0/0'))
+        self.assertEqual(ipaddress.IPv4Interface('0.0.0.0/0').supernet(),
+                         ipaddress.IPv4Interface('0.0.0.0/0'))
 
         self.assertEqual(self.ipv6.supernet().prefixlen, 63)
         self.assertEqual(str(self.ipv6.supernet().network_address),
                          '2001:658:22a:cafe::')
-        self.assertEqual(ipaddr.IPv6Interface('::0/0').supernet(),
-                         ipaddr.IPv6Interface('::0/0'))
+        self.assertEqual(ipaddress.IPv6Interface('::0/0').supernet(),
+                         ipaddress.IPv6Interface('::0/0'))
 
     def testGetSupernet3(self):
         self.assertEqual(self.ipv4.supernet(3).prefixlen, 21)
@@ -334,9 +334,9 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(self.ipv6.subnet(), list(self.ipv6.iter_subnets()))
 
     def testIterHosts(self):
-        self.assertEqual([ipaddr.IPv4Address('2.0.0.0'),
-                          ipaddr.IPv4Address('2.0.0.1')],
-                         list(ipaddr.ip_interface('2.0.0.0/31').iterhosts()))
+        self.assertEqual([ipaddress.IPv4Address('2.0.0.0'),
+                          ipaddress.IPv4Address('2.0.0.1')],
+                         list(ipaddress.ip_interface('2.0.0.0/31').iterhosts()))
 
     def testFancySubnetting(self):
         self.assertEqual(sorted(self.ipv4.subnet(prefixlen_diff=3)),
@@ -358,14 +358,14 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(self.ipv6.subnet()[0].prefixlen, 65)
 
     def testGetSubnetForSingle32(self):
-        ip = ipaddr.IPv4Interface('1.2.3.4/32')
+        ip = ipaddress.IPv4Interface('1.2.3.4/32')
         subnets1 = [str(x) for x in ip.subnet()]
         subnets2 = [str(x) for x in ip.subnet(2)]
         self.assertEqual(subnets1, ['1.2.3.4/32'])
         self.assertEqual(subnets1, subnets2)
 
     def testGetSubnetForSingle128(self):
-        ip = ipaddr.IPv6Interface('::1/128')
+        ip = ipaddress.IPv6Interface('::1/128')
         subnets1 = [str(x) for x in ip.subnet()]
         subnets2 = [str(x) for x in ip.subnet(2)]
         self.assertEqual(subnets1, ['::1/128'])
@@ -407,47 +407,47 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(self.ipv6.supernet().numhosts, 36893488147419103232)
 
     def testContains(self):
-        self.assertTrue(ipaddr.IPv4Interface('1.2.3.128/25') in self.ipv4)
-        self.assertFalse(ipaddr.IPv4Interface('1.2.4.1/24') in self.ipv4)
+        self.assertTrue(ipaddress.IPv4Interface('1.2.3.128/25') in self.ipv4)
+        self.assertFalse(ipaddress.IPv4Interface('1.2.4.1/24') in self.ipv4)
         self.assertTrue(self.ipv4 in self.ipv4)
         self.assertTrue(self.ipv6 in self.ipv6)
         # We can test addresses and string as well.
-        addr1 = ipaddr.IPv4Address('1.2.3.37')
+        addr1 = ipaddress.IPv4Address('1.2.3.37')
         self.assertTrue(addr1 in self.ipv4)
         # issue 61, bad network comparison on like-ip'd network objects
         # with identical broadcast addresses.
-        self.assertFalse(ipaddr.IPv4Interface('1.1.0.0/16').__contains__(
-                ipaddr.IPv4Interface('1.0.0.0/15')))
+        self.assertFalse(ipaddress.IPv4Interface('1.1.0.0/16').__contains__(
+                ipaddress.IPv4Interface('1.0.0.0/15')))
 
     def testBadAddress(self):
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Interface,
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv4Interface,
                           'poop')
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv4Interface, '1.2.3.256')
+        self.assertRaises(ipaddress.AddressValueError,
+                          ipaddress.IPv4Interface, '1.2.3.256')
 
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Interface,
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
                           'poopv6')
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv4Interface, '1.2.3.4/32/24')
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv4Interface, '10/8')
-        self.assertRaises(ipaddr.AddressValueError,
-                          ipaddr.IPv6Interface, '10/8')
+        self.assertRaises(ipaddress.AddressValueError,
+                          ipaddress.IPv4Interface, '1.2.3.4/32/24')
+        self.assertRaises(ipaddress.AddressValueError,
+                          ipaddress.IPv4Interface, '10/8')
+        self.assertRaises(ipaddress.AddressValueError,
+                          ipaddress.IPv6Interface, '10/8')
 
 
     def testBadNetMask(self):
-        self.assertRaises(ipaddr.NetmaskValueError,
-                          ipaddr.IPv4Interface, '1.2.3.4/')
-        self.assertRaises(ipaddr.NetmaskValueError,
-                          ipaddr.IPv4Interface, '1.2.3.4/33')
-        self.assertRaises(ipaddr.NetmaskValueError,
-                          ipaddr.IPv4Interface, '1.2.3.4/254.254.255.256')
-        self.assertRaises(ipaddr.NetmaskValueError,
-                          ipaddr.IPv4Interface, '1.1.1.1/240.255.0.0')
-        self.assertRaises(ipaddr.NetmaskValueError,
-                          ipaddr.IPv6Interface, '::1/')
-        self.assertRaises(ipaddr.NetmaskValueError,
-                          ipaddr.IPv6Interface, '::1/129')
+        self.assertRaises(ipaddress.NetmaskValueError,
+                          ipaddress.IPv4Interface, '1.2.3.4/')
+        self.assertRaises(ipaddress.NetmaskValueError,
+                          ipaddress.IPv4Interface, '1.2.3.4/33')
+        self.assertRaises(ipaddress.NetmaskValueError,
+                          ipaddress.IPv4Interface, '1.2.3.4/254.254.255.256')
+        self.assertRaises(ipaddress.NetmaskValueError,
+                          ipaddress.IPv4Interface, '1.1.1.1/240.255.0.0')
+        self.assertRaises(ipaddress.NetmaskValueError,
+                          ipaddress.IPv6Interface, '::1/')
+        self.assertRaises(ipaddress.NetmaskValueError,
+                          ipaddress.IPv6Interface, '::1/129')
 
     def testNth(self):
         self.assertEqual(str(self.ipv4[5]), '1.2.3.5')
@@ -458,7 +458,7 @@ class IpaddrUnitTest(unittest.TestCase):
 
     def testGetitem(self):
         # http://code.google.com/p/ipaddr-py/issues/detail?id=15
-        addr = ipaddr.IPv4Interface('172.31.255.128/255.255.255.240')
+        addr = ipaddress.IPv4Interface('172.31.255.128/255.255.255.240')
         self.assertEqual(28, addr.prefixlen)
         addr_list = list(addr)
         self.assertEqual('172.31.255.128', str(addr_list[0]))
@@ -468,175 +468,175 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(addr_list[-1], addr[-1])
 
     def testEqual(self):
-        self.assertTrue(self.ipv4 == ipaddr.IPv4Interface('1.2.3.4/24'))
-        self.assertFalse(self.ipv4 == ipaddr.IPv4Interface('1.2.3.4/23'))
-        self.assertFalse(self.ipv4 == ipaddr.IPv6Interface('::1.2.3.4/24'))
+        self.assertTrue(self.ipv4 == ipaddress.IPv4Interface('1.2.3.4/24'))
+        self.assertFalse(self.ipv4 == ipaddress.IPv4Interface('1.2.3.4/23'))
+        self.assertFalse(self.ipv4 == ipaddress.IPv6Interface('::1.2.3.4/24'))
         self.assertFalse(self.ipv4 == '')
         self.assertFalse(self.ipv4 == [])
         self.assertFalse(self.ipv4 == 2)
-        self.assertTrue(ipaddr.ip_network('1.1.1.1/32') ==
-                        ipaddr.ip_address('1.1.1.1'))
-        self.assertTrue(ipaddr.ip_interface('1.1.1.1/24') ==
-                        ipaddr.ip_address('1.1.1.1'))
-        self.assertFalse(ipaddr.ip_network('1.1.1.0/24') ==
-                         ipaddr.ip_address('1.1.1.1'))
+        self.assertTrue(ipaddress.ip_network('1.1.1.1/32') ==
+                        ipaddress.ip_address('1.1.1.1'))
+        self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') ==
+                        ipaddress.ip_address('1.1.1.1'))
+        self.assertFalse(ipaddress.ip_network('1.1.1.0/24') ==
+                         ipaddress.ip_address('1.1.1.1'))
 
         self.assertTrue(self.ipv6 ==
-            ipaddr.IPv6Interface('2001:658:22a:cafe:200::1/64'))
-        self.assertTrue(ipaddr.ip_network('::1/128') ==
-                        ipaddr.ip_address('::1'))
-        self.assertTrue(ipaddr.ip_interface('::1/127') ==
-                        ipaddr.ip_address('::1'))
-        self.assertFalse(ipaddr.ip_network('::0/127') ==
-                         ipaddr.ip_address('::1'))
+            ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64'))
+        self.assertTrue(ipaddress.ip_network('::1/128') ==
+                        ipaddress.ip_address('::1'))
+        self.assertTrue(ipaddress.ip_interface('::1/127') ==
+                        ipaddress.ip_address('::1'))
+        self.assertFalse(ipaddress.ip_network('::0/127') ==
+                         ipaddress.ip_address('::1'))
         self.assertFalse(self.ipv6 ==
-            ipaddr.IPv6Interface('2001:658:22a:cafe:200::1/63'))
-        self.assertFalse(self.ipv6 == ipaddr.IPv4Interface('1.2.3.4/23'))
+            ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63'))
+        self.assertFalse(self.ipv6 == ipaddress.IPv4Interface('1.2.3.4/23'))
         self.assertFalse(self.ipv6 == '')
         self.assertFalse(self.ipv6 == [])
         self.assertFalse(self.ipv6 == 2)
 
     def testNotEqual(self):
-        self.assertFalse(self.ipv4 != ipaddr.IPv4Interface('1.2.3.4/24'))
-        self.assertTrue(self.ipv4 != ipaddr.IPv4Interface('1.2.3.4/23'))
-        self.assertTrue(self.ipv4 != ipaddr.IPv6Interface('::1.2.3.4/24'))
+        self.assertFalse(self.ipv4 != ipaddress.IPv4Interface('1.2.3.4/24'))
+        self.assertTrue(self.ipv4 != ipaddress.IPv4Interface('1.2.3.4/23'))
+        self.assertTrue(self.ipv4 != ipaddress.IPv6Interface('::1.2.3.4/24'))
         self.assertTrue(self.ipv4 != '')
         self.assertTrue(self.ipv4 != [])
         self.assertTrue(self.ipv4 != 2)
 
-        addr2 = ipaddr.ip_address('2001:658:22a:cafe:200::1')
+        addr2 = ipaddress.ip_address('2001:658:22a:cafe:200::1')
         self.assertFalse(self.ipv6 !=
-            ipaddr.IPv6Interface('2001:658:22a:cafe:200::1/64'))
+            ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64'))
         self.assertTrue(self.ipv6 !=
-            ipaddr.IPv6Interface('2001:658:22a:cafe:200::1/63'))
-        self.assertTrue(self.ipv6 != ipaddr.IPv4Interface('1.2.3.4/23'))
+            ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63'))
+        self.assertTrue(self.ipv6 != ipaddress.IPv4Interface('1.2.3.4/23'))
         self.assertTrue(self.ipv6 != '')
         self.assertTrue(self.ipv6 != [])
         self.assertTrue(self.ipv6 != 2)
 
     def testSlash32Constructor(self):
-        self.assertEqual(str(ipaddr.IPv4Interface('1.2.3.4/255.255.255.255')),
+        self.assertEqual(str(ipaddress.IPv4Interface('1.2.3.4/255.255.255.255')),
                           '1.2.3.4/32')
 
     def testSlash128Constructor(self):
-        self.assertEqual(str(ipaddr.IPv6Interface('::1/128')),
+        self.assertEqual(str(ipaddress.IPv6Interface('::1/128')),
                                   '::1/128')
 
     def testSlash0Constructor(self):
-        self.assertEqual(str(ipaddr.IPv4Interface('1.2.3.4/0.0.0.0')),
+        self.assertEqual(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 = ipaddr.IPv4Address('1.1.1.0')
-        ip2 = ipaddr.IPv4Address('1.1.1.1')
-        ip3 = ipaddr.IPv4Address('1.1.1.2')
-        ip4 = ipaddr.IPv4Address('1.1.1.3')
-        ip5 = ipaddr.IPv4Address('1.1.1.4')
-        ip6 = ipaddr.IPv4Address('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 = ipaddr.collapse_address_list([ip1, ip2, ip3, ip4, ip5, ip6])
-        self.assertEqual(collapsed, [ipaddr.IPv4Interface('1.1.1.0/30'),
-                                     ipaddr.IPv4Interface('1.1.1.4/32')])
+        collapsed = ipaddress.collapse_address_list([ip1, ip2, ip3, ip4, ip5, ip6])
+        self.assertEqual(collapsed, [ipaddress.IPv4Interface('1.1.1.0/30'),
+                                     ipaddress.IPv4Interface('1.1.1.4/32')])
 
         # test a mix of IP addresses and networks including some duplicates
-        ip1 = ipaddr.IPv4Address('1.1.1.0')
-        ip2 = ipaddr.IPv4Address('1.1.1.1')
-        ip3 = ipaddr.IPv4Address('1.1.1.2')
-        ip4 = ipaddr.IPv4Address('1.1.1.3')
-        ip5 = ipaddr.IPv4Interface('1.1.1.4/30')
-        ip6 = ipaddr.IPv4Interface('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 = ipaddr.collapse_address_list([ip5, ip1, ip2, ip3, ip4, ip6])
-        self.assertEqual(collapsed, [ipaddr.IPv4Interface('1.1.1.0/29')])
+        collapsed = ipaddress.collapse_address_list([ip5, ip1, ip2, ip3, ip4, ip6])
+        self.assertEqual(collapsed, [ipaddress.IPv4Interface('1.1.1.0/29')])
 
         # test only IP networks
-        ip1 = ipaddr.IPv4Interface('1.1.0.0/24')
-        ip2 = ipaddr.IPv4Interface('1.1.1.0/24')
-        ip3 = ipaddr.IPv4Interface('1.1.2.0/24')
-        ip4 = ipaddr.IPv4Interface('1.1.3.0/24')
-        ip5 = ipaddr.IPv4Interface('1.1.4.0/24')
+        ip1 = ipaddress.IPv4Interface('1.1.0.0/24')
+        ip2 = ipaddress.IPv4Interface('1.1.1.0/24')
+        ip3 = ipaddress.IPv4Interface('1.1.2.0/24')
+        ip4 = ipaddress.IPv4Interface('1.1.3.0/24')
+        ip5 = ipaddress.IPv4Interface('1.1.4.0/24')
         # stored in no particular order b/c we want CollapseAddr to call [].sort
-        ip6 = ipaddr.IPv4Interface('1.1.0.0/22')
+        ip6 = ipaddress.IPv4Interface('1.1.0.0/22')
         # check that addreses are subsumed properly.
-        collapsed = ipaddr.collapse_address_list([ip1, ip2, ip3, ip4, ip5, ip6])
-        self.assertEqual(collapsed, [ipaddr.IPv4Interface('1.1.0.0/22'),
-                                     ipaddr.IPv4Interface('1.1.4.0/24')])
+        collapsed = ipaddress.collapse_address_list([ip1, ip2, ip3, ip4, ip5, ip6])
+        self.assertEqual(collapsed, [ipaddress.IPv4Interface('1.1.0.0/22'),
+                                     ipaddress.IPv4Interface('1.1.4.0/24')])
 
         # test that two addresses are supernet'ed properly
-        collapsed = ipaddr.collapse_address_list([ip1, ip2])
-        self.assertEqual(collapsed, [ipaddr.IPv4Interface('1.1.0.0/23')])
+        collapsed = ipaddress.collapse_address_list([ip1, ip2])
+        self.assertEqual(collapsed, [ipaddress.IPv4Interface('1.1.0.0/23')])
 
         # test same IP networks
-        ip_same1 = ip_same2 = ipaddr.IPv4Interface('1.1.1.1/32')
-        self.assertEqual(ipaddr.collapse_address_list([ip_same1, ip_same2]),
+        ip_same1 = ip_same2 = ipaddress.IPv4Interface('1.1.1.1/32')
+        self.assertEqual(ipaddress.collapse_address_list([ip_same1, ip_same2]),
                          [ip_same1])
 
         # test same IP addresses
-        ip_same1 = ip_same2 = ipaddr.IPv4Address('1.1.1.1')
-        self.assertEqual(ipaddr.collapse_address_list([ip_same1, ip_same2]),
-                         [ipaddr.ip_network('1.1.1.1/32')])
-        ip1 = ipaddr.IPv6Interface('::2001:1/100')
-        ip2 = ipaddr.IPv6Interface('::2002:1/120')
-        ip3 = ipaddr.IPv6Interface('::2001:1/96')
+        ip_same1 = ip_same2 = ipaddress.IPv4Address('1.1.1.1')
+        self.assertEqual(ipaddress.collapse_address_list([ip_same1, ip_same2]),
+                         [ipaddress.ip_network('1.1.1.1/32')])
+        ip1 = ipaddress.IPv6Interface('::2001:1/100')
+        ip2 = ipaddress.IPv6Interface('::2002:1/120')
+        ip3 = ipaddress.IPv6Interface('::2001:1/96')
         # test that ipv6 addresses are subsumed properly.
-        collapsed = ipaddr.collapse_address_list([ip1, ip2, ip3])
+        collapsed = ipaddress.collapse_address_list([ip1, ip2, ip3])
         self.assertEqual(collapsed, [ip3])
 
         # the toejam test
-        ip1 = ipaddr.ip_address('1.1.1.1')
-        ip2 = ipaddr.ip_address('::1')
-        self.assertRaises(TypeError, ipaddr.collapse_address_list,
+        ip1 = ipaddress.ip_address('1.1.1.1')
+        ip2 = ipaddress.ip_address('::1')
+        self.assertRaises(TypeError, ipaddress.collapse_address_list,
                           [ip1, ip2])
 
     def testSummarizing(self):
-        #ip = ipaddr.ip_address
-        #ipnet = ipaddr.ip_network
-        summarize = ipaddr.summarize_address_range
-        ip1 = ipaddr.ip_address('1.1.1.0')
-        ip2 = ipaddr.ip_address('1.1.1.255')
+        #ip = ipaddress.ip_address
+        #ipnet = ipaddress.ip_network
+        summarize = ipaddress.summarize_address_range
+        ip1 = ipaddress.ip_address('1.1.1.0')
+        ip2 = ipaddress.ip_address('1.1.1.255')
         # test a /24 is sumamrized properly
-        self.assertEqual(summarize(ip1, ip2)[0], ipaddr.ip_network('1.1.1.0/24'))
+        self.assertEqual(summarize(ip1, ip2)[0], ipaddress.ip_network('1.1.1.0/24'))
         # test an  IPv4 range that isn't on a network byte boundary
-        ip2 = ipaddr.ip_address('1.1.1.8')
-        self.assertEqual(summarize(ip1, ip2), [ipaddr.ip_network('1.1.1.0/29'),
-                                               ipaddr.ip_network('1.1.1.8')])
+        ip2 = ipaddress.ip_address('1.1.1.8')
+        self.assertEqual(summarize(ip1, ip2), [ipaddress.ip_network('1.1.1.0/29'),
+                                               ipaddress.ip_network('1.1.1.8')])
 
-        ip1 = ipaddr.ip_address('1::')
-        ip2 = ipaddr.ip_address('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(summarize(ip1, ip2)[0], ipaddr.ip_network('1::/16'))
+        self.assertEqual(summarize(ip1, ip2)[0], ipaddress.ip_network('1::/16'))
         # test an IPv6 range that isn't on a network byte boundary
-        ip2 = ipaddr.ip_address('2::')
-        self.assertEqual(summarize(ip1, ip2), [ipaddr.ip_network('1::/16'),
-                                               ipaddr.ip_network('2::/128')])
+        ip2 = ipaddress.ip_address('2::')
+        self.assertEqual(summarize(ip1, ip2), [ipaddress.ip_network('1::/16'),
+                                               ipaddress.ip_network('2::/128')])
 
         # test exception raised when first is greater than last
-        self.assertRaises(ValueError, summarize, ipaddr.ip_address('1.1.1.0'),
-            ipaddr.ip_address('1.1.0.0'))
+        self.assertRaises(ValueError, 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, summarize,
-                          ipaddr.ip_network('1.1.1.0'),
-                          ipaddr.ip_network('1.1.0.0'))
+                          ipaddress.ip_network('1.1.1.0'),
+                          ipaddress.ip_network('1.1.0.0'))
         self.assertRaises(TypeError, summarize,
-            ipaddr.ip_network('1.1.1.0'), ipaddr.ip_network('1.1.0.0'))
+            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, summarize, ipaddr.ip_address('::'),
-            ipaddr.ip_network('1.1.0.0'))
+        self.assertRaises(TypeError, summarize, ipaddress.ip_address('::'),
+            ipaddress.ip_network('1.1.0.0'))
 
     def testAddressComparison(self):
-        self.assertTrue(ipaddr.ip_address('1.1.1.1') <=
-                        ipaddr.ip_address('1.1.1.1'))
-        self.assertTrue(ipaddr.ip_address('1.1.1.1') <=
-                        ipaddr.ip_address('1.1.1.2'))
-        self.assertTrue(ipaddr.ip_address('::1') <= ipaddr.ip_address('::1'))
-        self.assertTrue(ipaddr.ip_address('::1') <= ipaddr.ip_address('::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 testNetworkComparison(self):
         # ip1 and ip2 have the same network address
-        ip1 = ipaddr.IPv4Interface('1.1.1.0/24')
-        ip2 = ipaddr.IPv4Interface('1.1.1.1/24')
-        ip3 = ipaddr.IPv4Interface('1.1.2.0/24')
+        ip1 = ipaddress.IPv4Interface('1.1.1.0/24')
+        ip2 = ipaddress.IPv4Interface('1.1.1.1/24')
+        ip3 = ipaddress.IPv4Interface('1.1.2.0/24')
 
         self.assertTrue(ip1 < ip3)
         self.assertTrue(ip3 > ip2)
@@ -646,9 +646,9 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(ip1.compare_networks(ip3), -1)
         self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
 
-        ip1 = ipaddr.IPv6Interface('2001::2000/96')
-        ip2 = ipaddr.IPv6Interface('2001::2001/96')
-        ip3 = ipaddr.IPv6Interface('2001:ffff::2000/96')
+        ip1 = ipaddress.IPv6Interface('2001::2000/96')
+        ip2 = ipaddress.IPv6Interface('2001::2001/96')
+        ip3 = ipaddress.IPv6Interface('2001:ffff::2000/96')
 
         self.assertTrue(ip1 < ip3)
         self.assertTrue(ip3 > ip2)
@@ -659,33 +659,33 @@ class IpaddrUnitTest(unittest.TestCase):
 
         # Test comparing different protocols.
         # Should always raise a TypeError.
-        ipv6 = ipaddr.IPv6Interface('::/0')
-        ipv4 = ipaddr.IPv4Interface('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 = ipaddr.ip_network('10.1.2.128/25')
+        ip1 = ipaddress.ip_network('10.1.2.128/25')
         self.assertFalse(ip1 < ip1)
         self.assertFalse(ip1 > ip1)
-        ip2 = ipaddr.ip_network('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 = ipaddr.ip_network('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 = ipaddr.ip_network('10.10.10.0/31')
-        ip2 = ipaddr.ip_network('10.10.10.0')
-        ip3 = ipaddr.ip_network('10.10.10.2/31')
-        ip4 = ipaddr.ip_network('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()
@@ -694,51 +694,51 @@ class IpaddrUnitTest(unittest.TestCase):
         unsorted.sort()
         self.assertEqual(sorted, unsorted)
         self.assertRaises(TypeError, ip1.__lt__,
-                          ipaddr.ip_address('10.10.10.0'))
+                          ipaddress.ip_address('10.10.10.0'))
         self.assertRaises(TypeError, ip2.__lt__,
-                          ipaddr.ip_address('10.10.10.0'))
+                          ipaddress.ip_address('10.10.10.0'))
 
         # <=, >=
-        self.assertTrue(ipaddr.ip_network('1.1.1.1') <=
-                        ipaddr.ip_network('1.1.1.1'))
-        self.assertTrue(ipaddr.ip_network('1.1.1.1') <=
-                        ipaddr.ip_network('1.1.1.2'))
-        self.assertFalse(ipaddr.ip_network('1.1.1.2') <=
-                        ipaddr.ip_network('1.1.1.1'))
-        self.assertTrue(ipaddr.ip_network('::1') <= ipaddr.ip_network('::1'))
-        self.assertTrue(ipaddr.ip_network('::1') <= ipaddr.ip_network('::2'))
-        self.assertFalse(ipaddr.ip_network('::2') <= ipaddr.ip_network('::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, ipaddr.ip_network, '192.168.1.1/24')
-        self.assertRaises(ValueError, ipaddr.ip_network, '::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 = ipaddr.IPv4Interface('1.2.3.0/30')
-        other2 = ipaddr.IPv4Interface('1.2.2.0/24')
-        other3 = ipaddr.IPv4Interface('1.2.2.64/26')
+        other = ipaddress.IPv4Interface('1.2.3.0/30')
+        other2 = ipaddress.IPv4Interface('1.2.2.0/24')
+        other3 = ipaddress.IPv4Interface('1.2.2.64/26')
         self.assertTrue(self.ipv4.overlaps(other))
         self.assertFalse(self.ipv4.overlaps(other2))
         self.assertTrue(other2.overlaps(other3))
 
     def testEmbeddedIpv4(self):
         ipv4_string = '192.168.0.1'
-        ipv4 = ipaddr.IPv4Interface(ipv4_string)
-        v4compat_ipv6 = ipaddr.IPv6Interface('::%s' % ipv4_string)
+        ipv4 = ipaddress.IPv4Interface(ipv4_string)
+        v4compat_ipv6 = ipaddress.IPv6Interface('::%s' % ipv4_string)
         self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
-        v4mapped_ipv6 = ipaddr.IPv6Interface('::ffff:%s' % ipv4_string)
+        v4mapped_ipv6 = ipaddress.IPv6Interface('::ffff:%s' % ipv4_string)
         self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
-        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Interface,
+        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
                           '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(ipaddr.ip_address('::FFFF:192.0.2.1'),
-                          ipaddr.ip_address('::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(ipaddr.ip_address('FFFF::192.0.2.1'),
-                          ipaddr.ip_address('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.version, 4)
@@ -751,176 +751,176 @@ class IpaddrUnitTest(unittest.TestCase):
     def testPacked(self):
         self.assertEqual(self.ipv4.packed,
                          _cb('\x01\x02\x03\x04'))
-        self.assertEqual(ipaddr.IPv4Interface('255.254.253.252').packed,
+        self.assertEqual(ipaddress.IPv4Interface('255.254.253.252').packed,
                          _cb('\xff\xfe\xfd\xfc'))
         self.assertEqual(self.ipv6.packed,
                          _cb('\x20\x01\x06\x58\x02\x2a\xca\xfe'
                              '\x02\x00\x00\x00\x00\x00\x00\x01'))
-        self.assertEqual(ipaddr.IPv6Interface('ffff:2:3:4:ffff::').packed,
+        self.assertEqual(ipaddress.IPv6Interface('ffff:2:3:4:ffff::').packed,
                          _cb('\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff'
                             + '\x00' * 6))
-        self.assertEqual(ipaddr.IPv6Interface('::1:0:0:0:0').packed,
+        self.assertEqual(ipaddress.IPv6Interface('::1:0:0:0:0').packed,
                          _cb('\x00' * 6 + '\x00\x01' + '\x00' * 8))
 
     def testIpStrFromPrefixlen(self):
-        ipv4 = ipaddr.IPv4Interface('1.2.3.4/24')
+        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 = ipaddr.ip_network('1.2.3.4')
-        ipv4addr = ipaddr.ip_address('1.2.3.4')
-        ipv6net = ipaddr.ip_network('::1.2.3.4')
-        ipv6addr = ipaddr.ip_address('::1.2.3.4')
-        self.assertEqual(ipaddr.IPv4Network, type(ipv4net))
-        self.assertEqual(ipaddr.IPv4Address, type(ipv4addr))
-        self.assertEqual(ipaddr.IPv6Network, type(ipv6net))
-        self.assertEqual(ipaddr.IPv6Address, type(ipv6addr))
+        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))
+        self.assertEqual(ipaddress.IPv6Address, type(ipv6addr))
 
     def testReservedIpv4(self):
         # test networks
-        self.assertEqual(True, ipaddr.ip_interface('224.1.1.1/31').is_multicast)
-        self.assertEqual(False, ipaddr.ip_network('240.0.0.0').is_multicast)
+        self.assertEqual(True, ipaddress.ip_interface('224.1.1.1/31').is_multicast)
+        self.assertEqual(False, ipaddress.ip_network('240.0.0.0').is_multicast)
 
-        self.assertEqual(True, ipaddr.ip_interface('192.168.1.1/17').is_private)
-        self.assertEqual(False, ipaddr.ip_network('192.169.0.0').is_private)
-        self.assertEqual(True, ipaddr.ip_network('10.255.255.255').is_private)
-        self.assertEqual(False, ipaddr.ip_network('11.0.0.0').is_private)
-        self.assertEqual(True, ipaddr.ip_network('172.31.255.255').is_private)
-        self.assertEqual(False, ipaddr.ip_network('172.32.0.0').is_private)
+        self.assertEqual(True, ipaddress.ip_interface('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('10.255.255.255').is_private)
+        self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_private)
+        self.assertEqual(True, ipaddress.ip_network('172.31.255.255').is_private)
+        self.assertEqual(False, ipaddress.ip_network('172.32.0.0').is_private)
 
         self.assertEqual(True,
-                          ipaddr.ip_interface(
+                          ipaddress.ip_interface(
                               '169.254.100.200/24').is_link_local)
         self.assertEqual(False,
-                          ipaddr.ip_interface(
+                          ipaddress.ip_interface(
                               '169.255.100.200/24').is_link_local)
 
         self.assertEqual(True,
-                          ipaddr.ip_network(
+                          ipaddress.ip_network(
                               '127.100.200.254/32').is_loopback)
-        self.assertEqual(True, ipaddr.ip_network('127.42.0.0/16').is_loopback)
-        self.assertEqual(False, ipaddr.ip_network('128.0.0.0').is_loopback)
+        self.assertEqual(True, ipaddress.ip_network('127.42.0.0/16').is_loopback)
+        self.assertEqual(False, ipaddress.ip_network('128.0.0.0').is_loopback)
 
         # test addresses
-        self.assertEqual(True, ipaddr.ip_address('224.1.1.1').is_multicast)
-        self.assertEqual(False, ipaddr.ip_address('240.0.0.0').is_multicast)
+        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, ipaddr.ip_address('192.168.1.1').is_private)
-        self.assertEqual(False, ipaddr.ip_address('192.169.0.0').is_private)
-        self.assertEqual(True, ipaddr.ip_address('10.255.255.255').is_private)
-        self.assertEqual(False, ipaddr.ip_address('11.0.0.0').is_private)
-        self.assertEqual(True, ipaddr.ip_address('172.31.255.255').is_private)
-        self.assertEqual(False, ipaddr.ip_address('172.32.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('10.255.255.255').is_private)
+        self.assertEqual(False, ipaddress.ip_address('11.0.0.0').is_private)
+        self.assertEqual(True, ipaddress.ip_address('172.31.255.255').is_private)
+        self.assertEqual(False, ipaddress.ip_address('172.32.0.0').is_private)
 
         self.assertEqual(True,
-                          ipaddr.ip_address('169.254.100.200').is_link_local)
+                          ipaddress.ip_address('169.254.100.200').is_link_local)
         self.assertEqual(False,
-                          ipaddr.ip_address('169.255.100.200').is_link_local)
+                          ipaddress.ip_address('169.255.100.200').is_link_local)
 
         self.assertEqual(True,
-                          ipaddr.ip_address('127.100.200.254').is_loopback)
-        self.assertEqual(True, ipaddr.ip_address('127.42.0.0').is_loopback)
-        self.assertEqual(False, ipaddr.ip_address('128.0.0.0').is_loopback)
-        self.assertEqual(True, ipaddr.ip_network('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, ipaddr.ip_network('ffff::').is_multicast)
-        self.assertEqual(True, ipaddr.ip_network(2**128-1).is_multicast)
-        self.assertEqual(True, ipaddr.ip_network('ff00::').is_multicast)
-        self.assertEqual(False, ipaddr.ip_network('fdff::').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('ff00::').is_multicast)
+        self.assertEqual(False, ipaddress.ip_network('fdff::').is_multicast)
 
-        self.assertEqual(True, ipaddr.ip_network('fecf::').is_site_local)
-        self.assertEqual(True, ipaddr.ip_network(
+        self.assertEqual(True, ipaddress.ip_network('fecf::').is_site_local)
+        self.assertEqual(True, ipaddress.ip_network(
                 'feff:ffff:ffff:ffff::').is_site_local)
-        self.assertEqual(False, ipaddr.ip_network('fbf:ffff::').is_site_local)
-        self.assertEqual(False, ipaddr.ip_network('ff00::').is_site_local)
+        self.assertEqual(False, ipaddress.ip_network('fbf:ffff::').is_site_local)
+        self.assertEqual(False, ipaddress.ip_network('ff00::').is_site_local)
 
-        self.assertEqual(True, ipaddr.ip_network('fc00::').is_private)
-        self.assertEqual(True, ipaddr.ip_network(
+        self.assertEqual(True, ipaddress.ip_network('fc00::').is_private)
+        self.assertEqual(True, ipaddress.ip_network(
                 'fc00:ffff:ffff:ffff::').is_private)
-        self.assertEqual(False, ipaddr.ip_network('fbff:ffff::').is_private)
-        self.assertEqual(False, ipaddr.ip_network('fe00::').is_private)
+        self.assertEqual(False, ipaddress.ip_network('fbff:ffff::').is_private)
+        self.assertEqual(False, ipaddress.ip_network('fe00::').is_private)
 
-        self.assertEqual(True, ipaddr.ip_network('fea0::').is_link_local)
-        self.assertEqual(True, ipaddr.ip_network('febf:ffff::').is_link_local)
-        self.assertEqual(False, ipaddr.ip_network('fe7f:ffff::').is_link_local)
-        self.assertEqual(False, ipaddr.ip_network('fec0::').is_link_local)
+        self.assertEqual(True, ipaddress.ip_network('fea0::').is_link_local)
+        self.assertEqual(True, ipaddress.ip_network('febf:ffff::').is_link_local)
+        self.assertEqual(False, ipaddress.ip_network('fe7f:ffff::').is_link_local)
+        self.assertEqual(False, ipaddress.ip_network('fec0::').is_link_local)
 
-        self.assertEqual(True, ipaddr.ip_network('0:0::0:01').is_loopback)
-        self.assertEqual(False, ipaddr.ip_interface('::1/127').is_loopback)
-        self.assertEqual(False, ipaddr.ip_network('::').is_loopback)
-        self.assertEqual(False, ipaddr.ip_network('::2').is_loopback)
+        self.assertEqual(True, ipaddress.ip_network('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, ipaddr.ip_network('0::0').is_unspecified)
-        self.assertEqual(False, ipaddr.ip_network('::1').is_unspecified)
-        self.assertEqual(False, ipaddr.ip_network('::/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, ipaddr.ip_address('ffff::').is_multicast)
-        self.assertEqual(True, ipaddr.ip_address(2**128-1).is_multicast)
-        self.assertEqual(True, ipaddr.ip_address('ff00::').is_multicast)
-        self.assertEqual(False, ipaddr.ip_address('fdff::').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('ff00::').is_multicast)
+        self.assertEqual(False, ipaddress.ip_address('fdff::').is_multicast)
 
-        self.assertEqual(True, ipaddr.ip_address('fecf::').is_site_local)
-        self.assertEqual(True, ipaddr.ip_address(
+        self.assertEqual(True, ipaddress.ip_address('fecf::').is_site_local)
+        self.assertEqual(True, ipaddress.ip_address(
                 'feff:ffff:ffff:ffff::').is_site_local)
-        self.assertEqual(False, ipaddr.ip_address('fbf:ffff::').is_site_local)
-        self.assertEqual(False, ipaddr.ip_address('ff00::').is_site_local)
+        self.assertEqual(False, ipaddress.ip_address('fbf:ffff::').is_site_local)
+        self.assertEqual(False, ipaddress.ip_address('ff00::').is_site_local)
 
-        self.assertEqual(True, ipaddr.ip_address('fc00::').is_private)
-        self.assertEqual(True, ipaddr.ip_address(
+        self.assertEqual(True, ipaddress.ip_address('fc00::').is_private)
+        self.assertEqual(True, ipaddress.ip_address(
                 'fc00:ffff:ffff:ffff::').is_private)
-        self.assertEqual(False, ipaddr.ip_address('fbff:ffff::').is_private)
-        self.assertEqual(False, ipaddr.ip_address('fe00::').is_private)
+        self.assertEqual(False, ipaddress.ip_address('fbff:ffff::').is_private)
+        self.assertEqual(False, ipaddress.ip_address('fe00::').is_private)
 
-        self.assertEqual(True, ipaddr.ip_address('fea0::').is_link_local)
-        self.assertEqual(True, ipaddr.ip_address('febf:ffff::').is_link_local)
-        self.assertEqual(False, ipaddr.ip_address('fe7f:ffff::').is_link_local)
-        self.assertEqual(False, ipaddr.ip_address('fec0::').is_link_local)
+        self.assertEqual(True, ipaddress.ip_address('fea0::').is_link_local)
+        self.assertEqual(True, ipaddress.ip_address('febf:ffff::').is_link_local)
+        self.assertEqual(False, ipaddress.ip_address('fe7f:ffff::').is_link_local)
+        self.assertEqual(False, ipaddress.ip_address('fec0::').is_link_local)
 
-        self.assertEqual(True, ipaddr.ip_address('0:0::0:01').is_loopback)
-        self.assertEqual(True, ipaddr.ip_address('::1').is_loopback)
-        self.assertEqual(False, ipaddr.ip_address('::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, ipaddr.ip_address('0::0').is_unspecified)
-        self.assertEqual(False, ipaddr.ip_address('::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, ipaddr.ip_address('100::').is_reserved)
-        self.assertEqual(True, ipaddr.ip_network('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(ipaddr.ip_address('::ffff:192.168.1.1').ipv4_mapped,
-                         ipaddr.ip_address('192.168.1.1'))
-        self.assertEqual(ipaddr.ip_address('::c0a8:101').ipv4_mapped, None)
-        self.assertEqual(ipaddr.ip_address('::ffff:c0a8:101').ipv4_mapped,
-                         ipaddr.ip_address('192.168.1.1'))
+        self.assertEqual(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 = ipaddr.ip_network('10.1.1.0/24')
-        addr2 = ipaddr.ip_network('10.1.1.0/26')
-        addr3 = ipaddr.ip_network('10.2.1.0/24')
-        addr4 = ipaddr.ip_address('10.1.1.0')
+        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')
         self.assertEqual(addr1.address_exclude(addr2),
-                         [ipaddr.ip_network('10.1.1.64/26'),
-                          ipaddr.ip_network('10.1.1.128/25')])
+                         [ipaddress.ip_network('10.1.1.64/26'),
+                          ipaddress.ip_network('10.1.1.128/25')])
         self.assertRaises(ValueError, addr1.address_exclude, addr3)
         self.assertRaises(TypeError, addr1.address_exclude, addr4)
         self.assertEqual(addr1.address_exclude(addr1), [])
 
     def testHash(self):
-        self.assertEqual(hash(ipaddr.ip_network('10.1.1.0/24')),
-                          hash(ipaddr.ip_network('10.1.1.0/24')))
-        self.assertEqual(hash(ipaddr.ip_address('10.1.1.0')),
-                          hash(ipaddr.ip_address('10.1.1.0')))
+        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(ipaddr.ip_address('1.2.3.4')),
-                          hash(ipaddr.ip_address(
-                    long(ipaddr.ip_address('1.2.3.4')._ip))))
-        ip1 = ipaddr.ip_address('10.1.1.0')
-        ip2 = ipaddr.ip_address('1::')
+        self.assertEqual(hash(ipaddress.ip_address('1.2.3.4')),
+                          hash(ipaddress.ip_address(
+                    long(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] = None
         dummy[self.ipv6] = None
@@ -930,17 +930,17 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertTrue(ip2 in dummy)
 
     def testCopyConstructor(self):
-        addr1 = ipaddr.ip_network('10.1.1.0/24')
-        addr2 = ipaddr.ip_network(addr1)
-        addr3 = ipaddr.ip_interface('2001:658:22a:cafe:200::1/64')
-        addr4 = ipaddr.ip_interface(addr3)
-        addr5 = ipaddr.IPv4Address('1.1.1.1')
-        addr6 = ipaddr.IPv6Address('2001:658:22a:cafe:200::1')
+        addr1 = ipaddress.ip_network('10.1.1.0/24')
+        addr2 = ipaddress.ip_network(addr1)
+        addr3 = ipaddress.ip_interface('2001:658:22a:cafe:200::1/64')
+        addr4 = ipaddress.ip_interface(addr3)
+        addr5 = ipaddress.IPv4Address('1.1.1.1')
+        addr6 = ipaddress.IPv6Address('2001:658:22a:cafe:200::1')
 
         self.assertEqual(addr1, addr2)
         self.assertEqual(addr3, addr4)
-        self.assertEqual(addr5, ipaddr.IPv4Address(addr5))
-        self.assertEqual(addr6, ipaddr.IPv6Address(addr6))
+        self.assertEqual(addr5, ipaddress.IPv4Address(addr5))
+        self.assertEqual(addr6, ipaddress.IPv6Address(addr6))
 
     def testCompressIPv6Address(self):
         test_addresses = {
@@ -966,17 +966,17 @@ class IpaddrUnitTest(unittest.TestCase):
             '0:6:5:4:3:2:1::': '0:6:5:4:3:2:1:0/128',
             }
         for uncompressed, compressed in test_addresses.items():
-            self.assertEqual(compressed, str(ipaddr.IPv6Interface(
+            self.assertEqual(compressed, str(ipaddress.IPv6Interface(
                 uncompressed)))
 
     def testExplodeShortHandIpStr(self):
-        addr1 = ipaddr.IPv6Interface('2001::1')
-        addr2 = ipaddr.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
-        addr3 = ipaddr.IPv6Network('2001::/96')
+        addr1 = ipaddress.IPv6Interface('2001::1')
+        addr2 = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
+        addr3 = ipaddress.IPv6Network('2001::/96')
         self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0001/128',
                          addr1.exploded)
         self.assertEqual('0000:0000:0000:0000:0000:0000:0000:0001/128',
-                         ipaddr.IPv6Interface('::1/128').exploded)
+                         ipaddress.IPv6Interface('::1/128').exploded)
         # issue 77
         self.assertEqual('2001:0000:5ef5:79fd:0000:059d:a0e5:0ba1',
                          addr2.exploded)
@@ -996,43 +996,43 @@ class IpaddrUnitTest(unittest.TestCase):
 
     # backwards compatibility
     def testBackwardsCompability(self):
-        self.assertEqual(ipaddr.CollapseAddrList(
-            [ipaddr.ip_network('1.1.0.0/24'), ipaddr.ip_network('1.1.1.0/24')]),
-                         [ipaddr.ip_network('1.1.0.0/23')])
+        self.assertEqual(ipaddress.CollapseAddrList(
+            [ipaddress.ip_network('1.1.0.0/24'), ipaddress.ip_network('1.1.1.0/24')]),
+                         [ipaddress.ip_network('1.1.0.0/23')])
 
-        self.assertEqual(ipaddr.ip_network('::42:0/112').AddressExclude(
-            ipaddr.ip_network('::42:8000/113')),
-                         [ipaddr.ip_network('::42:0/113')])
+        self.assertEqual(ipaddress.ip_network('::42:0/112').AddressExclude(
+            ipaddress.ip_network('::42:8000/113')),
+                         [ipaddress.ip_network('::42:0/113')])
 
         self.assertTrue(
-            ipaddr.ip_interface('1::/8').CompareNetworks(
-                ipaddr.ip_interface('2::/9')) < 0)
-
-        self.assertEqual(ipaddr.ip_network('1::/16').Contains(
-            ipaddr.ip_network('2::/16')), False)
-
-        self.assertEqual(ipaddr.ip_network('0.0.0.0/0').Subnet(),
-                         [ipaddr.ip_network('0.0.0.0/1'),
-                          ipaddr.ip_network('128.0.0.0/1')])
-        self.assertEqual(ipaddr.ip_network('::/127').Subnet(),
-                         [ipaddr.ip_network('::/128'),
-                          ipaddr.ip_network('::1/128')])
-
-        self.assertEqual(ipaddr.ip_network('1.0.0.0/32').Supernet(),
-                         ipaddr.ip_network('1.0.0.0/31'))
-        self.assertEqual(ipaddr.ip_network('::/121').Supernet(),
-                         ipaddr.ip_network('::/120'))
-
-        self.assertEqual(ipaddr.ip_network('10.0.0.2').IsRFC1918(), True)
-        self.assertEqual(ipaddr.ip_network('10.0.0.0').IsMulticast(), False)
-        self.assertEqual(ipaddr.ip_network('127.255.255.255').IsLoopback(),
+            ipaddress.ip_interface('1::/8').CompareNetworks(
+                ipaddress.ip_interface('2::/9')) < 0)
+
+        self.assertEqual(ipaddress.ip_network('1::/16').Contains(
+            ipaddress.ip_network('2::/16')), False)
+
+        self.assertEqual(ipaddress.ip_network('0.0.0.0/0').Subnet(),
+                         [ipaddress.ip_network('0.0.0.0/1'),
+                          ipaddress.ip_network('128.0.0.0/1')])
+        self.assertEqual(ipaddress.ip_network('::/127').Subnet(),
+                         [ipaddress.ip_network('::/128'),
+                          ipaddress.ip_network('::1/128')])
+
+        self.assertEqual(ipaddress.ip_network('1.0.0.0/32').Supernet(),
+                         ipaddress.ip_network('1.0.0.0/31'))
+        self.assertEqual(ipaddress.ip_network('::/121').Supernet(),
+                         ipaddress.ip_network('::/120'))
+
+        self.assertEqual(ipaddress.ip_network('10.0.0.2').IsRFC1918(), True)
+        self.assertEqual(ipaddress.ip_network('10.0.0.0').IsMulticast(), False)
+        self.assertEqual(ipaddress.ip_network('127.255.255.255').IsLoopback(),
                          True)
-        self.assertEqual(ipaddr.ip_network('169.255.255.255').IsLinkLocal(),
+        self.assertEqual(ipaddress.ip_network('169.255.255.255').IsLinkLocal(),
                          False)
 
     def testForceVersion(self):
-        self.assertEqual(ipaddr.ip_network(1).version, 4)
-        self.assertEqual(ipaddr.ip_network(1, version=6).version, 6)
+        self.assertEqual(ipaddress.ip_network(1).version, 4)
+        self.assertEqual(ipaddress.ip_network(1, version=6).version, 6)
 
     def testWithStar(self):
         self.assertEqual(str(self.ipv4.with_prefixlen), "1.2.3.4/24")
@@ -1057,9 +1057,9 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertFalse(self.ipv4._cache.has_key('hostmask'))
 
         # V4 - populate and test
-        self.assertEqual(self.ipv4.network_address, ipaddr.IPv4Address('1.2.3.0'))
-        self.assertEqual(self.ipv4.broadcast_address, ipaddr.IPv4Address('1.2.3.255'))
-        self.assertEqual(self.ipv4.hostmask, ipaddr.IPv4Address('0.0.0.255'))
+        self.assertEqual(self.ipv4.network_address, ipaddress.IPv4Address('1.2.3.0'))
+        self.assertEqual(self.ipv4.broadcast_address, ipaddress.IPv4Address('1.2.3.255'))
+        self.assertEqual(self.ipv4.hostmask, ipaddress.IPv4Address('0.0.0.255'))
 
         # V4 - check we're cached
         self.assertTrue(self.ipv4._cache.has_key('network_address'))
@@ -1073,11 +1073,11 @@ class IpaddrUnitTest(unittest.TestCase):
 
         # V6 - populate and test
         self.assertEqual(self.ipv6.network_address,
-                         ipaddr.IPv6Address('2001:658:22a:cafe::'))
-        self.assertEqual(self.ipv6.broadcast_address, ipaddr.IPv6Address(
+                         ipaddress.IPv6Address('2001:658:22a:cafe::'))
+        self.assertEqual(self.ipv6.broadcast_address, ipaddress.IPv6Address(
             '2001:658:22a:cafe:ffff:ffff:ffff:ffff'))
         self.assertEqual(self.ipv6.hostmask,
-                         ipaddr.IPv6Address('::ffff:ffff:ffff:ffff'))
+                         ipaddress.IPv6Address('::ffff:ffff:ffff:ffff'))
 
         # V6 - check we're cached
         self.assertTrue(self.ipv6._cache.has_key('network_address'))
@@ -1086,27 +1086,27 @@ class IpaddrUnitTest(unittest.TestCase):
 
     def testTeredo(self):
         # stolen from wikipedia
-        server = ipaddr.IPv4Address('65.54.227.120')
-        client = ipaddr.IPv4Address('192.0.2.45')
+        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),
-                         ipaddr.ip_address(teredo_addr).teredo)
+                         ipaddress.ip_address(teredo_addr).teredo)
         bad_addr = '2000::4136:e378:8000:63bf:3fff:fdd2'
-        self.assertFalse(ipaddr.ip_address(bad_addr).teredo)
+        self.assertFalse(ipaddress.ip_address(bad_addr).teredo)
         bad_addr = '2001:0001:4136:e378:8000:63bf:3fff:fdd2'
-        self.assertFalse(ipaddr.ip_address(bad_addr).teredo)
+        self.assertFalse(ipaddress.ip_address(bad_addr).teredo)
 
         # i77
-        teredo_addr = ipaddr.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
-        self.assertEqual((ipaddr.IPv4Address('94.245.121.253'),
-                          ipaddr.IPv4Address('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 = ipaddr.ip_address('2002:ac1d:2d64::1')
-        bad_addr = ipaddr.ip_address('2000:ac1d:2d64::1')
-        self.assertEqual(ipaddr.IPv4Address('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)