+ make ipaddr which is fully py3k compliant.

git-svn-id: https://ipaddr-py.googlecode.com/svn@191 09200d28-7f98-11dd-ad27-0f66e57d2035

8 files changed, 156 insertions, 85 deletions

diff --git a/branches/2.1.0-py3k/COPYING b/branches/2.1.x-py3k/COPYING
index d645695..d645695 100644
--- a/branches/2.1.0-py3k/COPYING
+++ b/branches/2.1.x-py3k/COPYING
diff --git a/branches/2.1.0-py3k/MANIFEST.in b/branches/2.1.x-py3k/MANIFEST.in
index 4c16e20..4c16e20 100644
--- a/branches/2.1.0-py3k/MANIFEST.in
+++ b/branches/2.1.x-py3k/MANIFEST.in
diff --git a/branches/2.1.0-py3k/OWNERS b/branches/2.1.x-py3k/OWNERS
index 501673e..501673e 100644
--- a/branches/2.1.0-py3k/OWNERS
+++ b/branches/2.1.x-py3k/OWNERS
diff --git a/branches/2.1.0-py3k/README b/branches/2.1.x-py3k/README
index 1b54294..1b54294 100644
--- a/branches/2.1.0-py3k/README
+++ b/branches/2.1.x-py3k/README
diff --git a/branches/2.1.0-py3k/ipaddr.py b/branches/2.1.x-py3k/ipaddr.py
index 7e7cb0c..b614dc9 100644
--- a/branches/2.1.0-py3k/ipaddr.py
+++ b/branches/2.1.x-py3k/ipaddr.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3.1
 #
 # Copyright 2007 Google Inc.
 #  Licensed to PSF under a Contributor Agreement.
@@ -22,10 +22,13 @@ and networks.
 
 """
 
-__version__ = 'trunk'
+__version__ = '2.1.5-py3k'
 
 import struct
 
+IPV4LENGTH = 32
+IPV6LENGTH = 128
+
 
 class AddressValueError(ValueError):
     """A Value Error related to the address."""
@@ -44,7 +47,7 @@ def IPAddress(address, version=None):
           be considered to be IPv4 by default.
         version: An Integer, 4 or 6. If set, don't try to automatically
           determine what the IP address type is. important for things
-          like IPAddress(1), which could be IPv4, '0.0.0.0.1',  or IPv6,
+          like IPAddress(1), which could be IPv4, '0.0.0.1',  or IPv6,
           '::1'.
 
     Returns:
@@ -198,7 +201,7 @@ def summarize_address_range(first, last):
         raise TypeError('first and last must be IP addresses, not networks')
     if first.version != last.version:
         raise TypeError("%s and %s are not of the same version" % (
-                str(self), str(other)))        
+                str(self), str(other)))
     if first > last:
         raise ValueError('last IP address must be greater than first')
 
@@ -340,10 +343,7 @@ CollapseAddrList = collapse_address_list
 # We need to exclude platforms where bytes == str so that we can
 # distinguish between packed representations and strings, for example
 # b'12::' (the IPv4 address 49.50.58.58) and '12::' (an IPv6 address).
-try:
-    _compat_has_real_bytes = bytes is not str
-except NameError: # <Python2.6
-    _compat_has_real_bytes = False
+_compat_has_real_bytes = bytes is not str
 
 def get_mixed_type_key(obj):
     """Return a key suitable for sorting between networks and addresses.
@@ -356,7 +356,7 @@ def get_mixed_type_key(obj):
     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
     can use this function as the key= argument to sorted().
-    
+
     Args:
       obj: either a Network or Address object.
     Returns:
@@ -409,7 +409,8 @@ class _BaseIP(_IPAddrBase):
     def __eq__(self, other):
         try:
             return (self._ip == other._ip
-                    and self._version == other._version)
+                    and self._version == other._version
+                    and isinstance(other, _BaseIP))
         except AttributeError:
             return NotImplemented
 
@@ -453,6 +454,18 @@ class _BaseIP(_IPAddrBase):
             return self._ip > other._ip
         return False
 
+    # Shorthand for Integer addition and subtraction. This is not
+    # meant to ever support addition/subtraction of addresses.
+    def __add__(self, other):
+        if not isinstance(other, int):
+            return NotImplemented
+        return IPAddress(int(self) + other, version=self._version)
+
+    def __sub__(self, other):
+        if not isinstance(other, int):
+            return NotImplemented
+        return IPAddress(int(self) - other, version=self._version)
+
     def __repr__(self):
         return '%s(%r)' % (self.__class__.__name__, str(self))
 
@@ -578,10 +591,13 @@ class _BaseNet(_IPAddrBase):
         return hash(int(self.network) ^ int(self.netmask))
 
     def __contains__(self, other):
+        # always false if one is v4 and the other is v6.
+        if self._version != other._version:
+          return False
         # dealing with another network.
         if isinstance(other, _BaseNet):
-            return (int(self.network) <= int(other._ip) and
-                    int(self.broadcast) >= int(other.broadcast))
+            return (self.network <= other.network and
+                    self.broadcast >= other.broadcast)
         # dealing with another address
         else:
             return (int(self.network) <= int(other._ip) <=
@@ -672,7 +688,7 @@ class _BaseNet(_IPAddrBase):
 
         Raises:
             TypeError: If self and other are of difffering address
-              versions.
+              versions, or if other is not a network object.
             ValueError: If other is not completely contained by self.
 
         """
@@ -680,9 +696,15 @@ class _BaseNet(_IPAddrBase):
             raise TypeError("%s and %s are not of the same version" % (
                 str(self), str(other)))
 
+        if not isinstance(other, _BaseNet):
+            raise TypeError("%s is not a network object" % str(other))
+
         if other not in self:
             raise ValueError('%s not contained in %s' % (str(other),
                                                          str(self)))
+        if other == self:
+            return []
+
         ret_addrs = []
 
         # Make sure we're comparing the network of other.
@@ -884,6 +906,11 @@ class _BaseNet(_IPAddrBase):
 
             yield current
 
+    def masked(self):
+        """Return the network object with the host bits masked out."""
+        return IPNetwork('%s/%d' % (self.network, self._prefixlen),
+                         version=self._version)
+
     def subnet(self, prefixlen_diff=1, new_prefix=None):
         """Return a list of subnets, rather than an interator."""
         return list(self.iter_subnets(prefixlen_diff, new_prefix))
@@ -946,11 +973,11 @@ class _BaseV4(object):
     """
 
     # Equivalent to 255.255.255.255 or 32 bits of 1's.
-    _ALL_ONES = (2**32) - 1
+    _ALL_ONES = (2**IPV4LENGTH) - 1
 
     def __init__(self, address):
         self._version = 4
-        self._max_prefixlen = 32
+        self._max_prefixlen = IPV4LENGTH
 
     def _explode_shorthand_ip_string(self, ip_str=None):
         if not ip_str:
@@ -992,7 +1019,7 @@ class _BaseV4(object):
 
         """
         octets = []
-        for _ in xrange(4):
+        for _ in range(4):
             octets.insert(0, str(ip_int & 0xFF))
             ip_int >>= 8
         return '.'.join(octets)
@@ -1132,7 +1159,7 @@ class IPv4Address(_BaseV4, _BaseIP):
         _BaseV4.__init__(self, address)
 
         # Efficient constructor from integer.
-        if isinstance(address, (int, long)):
+        if isinstance(address, int):
             self._ip = address
             if address < 0 or address > self._ALL_ONES:
                 raise AddressValueError(address)
@@ -1215,10 +1242,10 @@ class IPv4Network(_BaseV4, _BaseNet):
         _BaseV4.__init__(self, address)
 
         # Efficient constructor from integer.
-        if isinstance(address, (int, long)):
+        if isinstance(address, int):
             self._ip = address
             self.ip = IPv4Address(self._ip)
-            self._prefixlen = 32
+            self._prefixlen = self._max_prefixlen
             self.netmask = IPv4Address(self._ALL_ONES)
             if address < 0 or address > self._ALL_ONES:
                 raise AddressValueError(address)
@@ -1229,7 +1256,7 @@ class IPv4Network(_BaseV4, _BaseNet):
             if isinstance(address, bytes) and len(address) == 4:
                 self._ip = struct.unpack('!I', address)[0]
                 self.ip = IPv4Address(self._ip)
-                self._prefixlen = 32
+                self._prefixlen = self._max_prefixlen
                 self.netmask = IPv4Address(self._ALL_ONES)
                 return
 
@@ -1269,7 +1296,7 @@ class IPv4Network(_BaseV4, _BaseNet):
                 self.netmask = IPv4Address(self._ip_int_from_prefix(
                     self._prefixlen))
         else:
-            self._prefixlen = 32
+            self._prefixlen = self._max_prefixlen
             self.netmask = IPv4Address(self._ip_int_from_prefix(
                 self._prefixlen))
         if strict:
@@ -1297,7 +1324,7 @@ class IPv4Network(_BaseV4, _BaseNet):
         if parts[0] < parts[-1]:
             return True
         return False
-    
+
     def _is_valid_netmask(self, netmask):
         """Verify that the netmask is valid.
 
@@ -1314,7 +1341,7 @@ class IPv4Network(_BaseV4, _BaseNet):
         if len(mask) == 4:
             if [x for x in mask if int(x) not in self._valid_mask_octets]:
                 return False
-            if [x for idx, y in enumerate(mask) if idx > 0 and
+            if [y for idx, y in enumerate(mask) if idx > 0 and
                 y > mask[idx - 1]]:
                 return False
             return True
@@ -1322,7 +1349,7 @@ class IPv4Network(_BaseV4, _BaseNet):
             netmask = int(netmask)
         except ValueError:
             return False
-        return 0 <= netmask <= 32
+        return 0 <= netmask <= self._max_prefixlen
 
     # backwards compatibility
     IsRFC1918 = lambda self: self.is_private
@@ -1340,11 +1367,11 @@ class _BaseV6(object):
 
     """
 
-    _ALL_ONES = (2**128) - 1
+    _ALL_ONES = (2**IPV6LENGTH) - 1
 
     def __init__(self, address):
         self._version = 6
-        self._max_prefixlen = 128
+        self._max_prefixlen = IPV6LENGTH
 
     def _ip_int_from_string(self, ip_str=None):
         """Turn an IPv6 ip_str into an integer.
@@ -1372,7 +1399,7 @@ class _BaseV6(object):
             ipv4_string = fields.pop()
             ipv4_int = IPv4Network(ipv4_string)._ip
             octets = []
-            for _ in xrange(2):
+            for _ in range(2):
                 octets.append(hex(ipv4_int & 0xFFFF).lstrip('0x').rstrip('L'))
                 ipv4_int >>= 16
             fields.extend(reversed(octets))
@@ -1480,7 +1507,7 @@ class _BaseV6(object):
             sep = len(hextet[0].split(':')) + len(hextet[1].split(':'))
             new_ip = hextet[0].split(':')
 
-            for _ in xrange(8 - sep):
+            for _ in range(8 - sep):
                 new_ip.append('0000')
             new_ip += hextet[1].split(':')
 
@@ -1624,7 +1651,7 @@ class _BaseV6(object):
             RFC 2373 2.5.2.
 
         """
-        return self == IPv6Network('::')
+        return (self == IPv6Network('::') or self == IPv6Address('::'))
 
     @property
     def is_loopback(self):
@@ -1635,7 +1662,7 @@ class _BaseV6(object):
             RFC 2373 2.5.3.
 
         """
-        return self == IPv6Network('::1')
+        return (self == IPv6Network('::1') or self == IPv6Address('::1'))
 
     @property
     def is_link_local(self):
@@ -1685,7 +1712,7 @@ class _BaseV6(object):
             return None
         try:
             return IPv4Address(int('%s%s' % (hextets[-2], hextets[-1]), 16))
-        except IPv4IpvalidationError:
+        except AddressValueError:
             return None
 
 
@@ -1708,14 +1735,14 @@ class IPv6Address(_BaseV6, _BaseIP):
                 IPv6Address('2001:4860::')
 
         Raises:
-            IPv6IpValidationError: If address isn't a valid IPv6 address.
+            AddressValueError: If address isn't a valid IPv6 address.
 
         """
         _BaseIP.__init__(self, address)
         _BaseV6.__init__(self, address)
 
         # Efficient constructor from integer.
-        if isinstance(address, (int, long)):
+        if isinstance(address, int):
             self._ip = address
             if address < 0 or address > self._ALL_ONES:
                 raise AddressValueError(address)
@@ -1734,6 +1761,9 @@ class IPv6Address(_BaseV6, _BaseIP):
         if not addr_str:
             raise AddressValueError('')
 
+        if not self._is_valid_ip(addr_str):
+            raise AddressValueError(addr_str)
+
         self._ip = self._ip_int_from_string(addr_str)
 
 
@@ -1788,10 +1818,10 @@ class IPv6Network(_BaseV6, _BaseNet):
         _BaseV6.__init__(self, address)
 
         # Efficient constructor from integer.
-        if isinstance(address, (int, long)):
+        if isinstance(address, int):
             self._ip = address
             self.ip = IPv6Address(self._ip)
-            self._prefixlen = 128
+            self._prefixlen = self._max_prefixlen
             self.netmask = IPv6Address(self._ALL_ONES)
             if address < 0 or address > self._ALL_ONES:
                 raise AddressValueError(address)
@@ -1803,7 +1833,7 @@ class IPv6Network(_BaseV6, _BaseNet):
                 tmp = struct.unpack('!QQ', address)
                 self._ip = (tmp[0] << 64) | tmp[1]
                 self.ip = IPv6Address(self._ip)
-                self._prefixlen = 128
+                self._prefixlen = self._max_prefixlen
                 self.netmask = IPv6Address(self._ALL_ONES)
                 return
 
@@ -1823,7 +1853,7 @@ class IPv6Network(_BaseV6, _BaseNet):
             else:
                 raise NetmaskValueError(addr[1])
         else:
-            self._prefixlen = 128
+            self._prefixlen = self._max_prefixlen
 
         self.netmask = IPv6Address(self._ip_int_from_prefix(self._prefixlen))
 
@@ -1851,4 +1881,8 @@ class IPv6Network(_BaseV6, _BaseNet):
             prefixlen = int(prefixlen)
         except ValueError:
             return False
-        return 0 <= prefixlen <= 128
+        return 0 <= prefixlen <= self._max_prefixlen
+
+    @property
+    def with_netmask(self):
+        return self.with_prefixlen
diff --git a/branches/2.1.0-py3k/ipaddr_test.py b/branches/2.1.x-py3k/ipaddr_test.py
index b59ae1f..cfd4178 100755
--- a/branches/2.1.0-py3k/ipaddr_test.py
+++ b/branches/2.1.x-py3k/ipaddr_test.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3.1
 #
 # Copyright 2007 Google Inc.
 #  Licensed to PSF under a Contributor Agreement.
@@ -47,6 +47,26 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual("IPv6Network('::1/128')",
                          repr(ipaddr.IPv6Network('::1')))
 
+    def testAutoMasking(self):
+        addr1 = ipaddr.IPv4Network('1.1.1.255/24')
+        addr1_masked = ipaddr.IPv4Network('1.1.1.0/24')
+        self.assertEqual(addr1_masked, addr1.masked())
+
+        addr2 = ipaddr.IPv6Network('2000:cafe::efac:100/96')
+        addr2_masked = ipaddr.IPv6Network('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'))
+
     def testInvalidStrings(self):
         self.assertRaises(ValueError, ipaddr.IPNetwork, '')
         self.assertRaises(ValueError, ipaddr.IPNetwork, 'www.google.com')
@@ -83,6 +103,10 @@ class IpaddrUnitTest(unittest.TestCase):
                           '1234:axy::b')
         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Address,
                           '1234:axy::b')
+        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Address,
+                          '2001:db8:::1')
+        self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Address,
+                          '2001:888888::1')
         self.assertRaises(ipaddr.AddressValueError,
                           ipaddr.IPv4Address(1)._ip_int_from_string,
                           '1.a.2.3')
@@ -106,7 +130,7 @@ class IpaddrUnitTest(unittest.TestCase):
         v4net = ipaddr.IPNetwork('1.1.1.1')
         v6addr = ipaddr.IPAddress('::1')
         v6net = ipaddr.IPAddress('::1')
-        
+
         self.assertRaises(TypeError, v4addr.__lt__, v6addr)
         self.assertRaises(TypeError, v4addr.__gt__, v6addr)
         self.assertRaises(TypeError, v4net.__lt__, v6net)
@@ -122,7 +146,10 @@ class IpaddrUnitTest(unittest.TestCase):
         v4net = ipaddr.IPNetwork('1.1.1.1/32')
         v6addr = ipaddr.IPAddress('::1')
         v6net = ipaddr.IPNetwork('::1/128')
-        
+
+        self.assertFalse(v4net.__contains__(v6net))
+        self.assertFalse(v6net.__contains__(v4net))
+
         self.assertRaises(TypeError, lambda: v4addr < v4net)
         self.assertRaises(TypeError, lambda: v4addr > v4net)
         self.assertRaises(TypeError, lambda: v4net < v4addr)
@@ -138,7 +165,7 @@ class IpaddrUnitTest(unittest.TestCase):
                                                  key=ipaddr.get_mixed_type_key))
         self.assertEqual([v6addr, v6net], sorted([v6net, v6addr],
                                                  key=ipaddr.get_mixed_type_key))
-        
+
     def testIpFromInt(self):
         self.assertEqual(self.ipv4.ip, ipaddr.IPv4Network(16909060).ip)
         self.assertRaises(ipaddr.AddressValueError,
@@ -161,26 +188,25 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(ipaddr.IPNetwork(self.ipv4.ip).version, 4)
         self.assertEqual(ipaddr.IPNetwork(self.ipv6.ip).version, 6)
 
-    if ipaddr._compat_has_real_bytes: # on python3+
-        def testIpFromPacked(self):
-            ip = ipaddr.IP
-
-            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, _cb('\x00' * 3))
-            self.assertRaises(ValueError, ipaddr.IP, _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)
-            self.assertEqual(ip('ffff:2:3:4:ffff::'),
-                             ip(_cb('\xff\xff\x00\x02\x00\x03\x00\x04' +
-                                   '\xff\xff' + '\x00' * 6)))
-            self.assertEqual(ip('::'),
-                             ip(_cb('\x00' * 16)))
-            self.assertRaises(ValueError, ip, _cb('\x00' * 15))
-            self.assertRaises(ValueError, ip, _cb('\x00' * 17))
+    def testIpFromPacked(self):
+        ip = ipaddr.IPNetwork
+
+        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.IPNetwork, _cb('\x00' * 3))
+        self.assertRaises(ValueError, ipaddr.IPNetwork, _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)
+        self.assertEqual(ip('ffff:2:3:4:ffff::'),
+                         ip(_cb('\xff\xff\x00\x02\x00\x03\x00\x04' +
+                                '\xff\xff' + '\x00' * 6)))
+        self.assertEqual(ip('::'),
+                         ip(_cb('\x00' * 16)))
+        self.assertRaises(ValueError, ip, _cb('\x00' * 15))
+        self.assertRaises(ValueError, ip, _cb('\x00' * 17))
 
     def testGetIp(self):
         self.assertEqual(int(self.ipv4.ip), 16909060)
@@ -193,7 +219,7 @@ class IpaddrUnitTest(unittest.TestCase):
                          '2001:658:22a:cafe:200::1')
 
     def testGetNetmask(self):
-        self.assertEqual(int(self.ipv4.netmask), 4294967040L)
+        self.assertEqual(int(self.ipv4.netmask), 4294967040)
         self.assertEqual(str(self.ipv4.netmask), '255.255.255.0')
         self.assertEqual(str(self.ipv4_hostmask.netmask), '255.0.0.0')
         self.assertEqual(int(self.ipv6.netmask),
@@ -210,7 +236,7 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assert_(ipv6_zero_netmask._is_valid_netmask(str(0)))
 
     def testGetBroadcast(self):
-        self.assertEqual(int(self.ipv4.broadcast), 16909311L)
+        self.assertEqual(int(self.ipv4.broadcast), 16909311)
         self.assertEqual(str(self.ipv4.broadcast), '1.2.3.255')
 
         self.assertEqual(int(self.ipv6.broadcast),
@@ -331,13 +357,15 @@ class IpaddrUnitTest(unittest.TestCase):
     def testContains(self):
         self.assertTrue(ipaddr.IPv4Network('1.2.3.128/25') in self.ipv4)
         self.assertFalse(ipaddr.IPv4Network('1.2.4.1/24') in self.ipv4)
-        self.assertFalse(self.ipv4 in self.ipv6)
-        self.assertFalse(self.ipv6 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')
         self.assertTrue(addr1 in self.ipv4)
+        # issue 61, bad network comparison on like-ip'd network objects
+        # with identical broadcast addresses.
+        self.assertFalse(ipaddr.IPv4Network('1.1.0.0/16').__contains__(
+                ipaddr.IPv4Network('1.0.0.0/15')))
 
     def testBadAddress(self):
         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Network,
@@ -353,7 +381,7 @@ class IpaddrUnitTest(unittest.TestCase):
                           ipaddr.IPv4Network, '10/8')
         self.assertRaises(ipaddr.AddressValueError,
                           ipaddr.IPv6Network, '10/8')
-        
+
 
     def testBadNetMask(self):
         self.assertRaises(ipaddr.NetmaskValueError,
@@ -405,15 +433,19 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertFalse(self.ipv6 == 2)
 
     def testNotEquals(self):
+        addr1 = ipaddr.IPAddress('1.2.3.4')
         self.assertFalse(self.ipv4 != ipaddr.IPv4Network('1.2.3.4/24'))
+        self.assertFalse(self.ipv4 == addr1)
         self.assertTrue(self.ipv4 != ipaddr.IPv4Network('1.2.3.4/23'))
         self.assertTrue(self.ipv4 != ipaddr.IPv6Network('::1.2.3.4/24'))
         self.assertTrue(self.ipv4 != '')
         self.assertTrue(self.ipv4 != [])
         self.assertTrue(self.ipv4 != 2)
 
+        addr2 = ipaddr.IPAddress('2001:658:22a:cafe:200::1')
         self.assertFalse(self.ipv6 !=
             ipaddr.IPv6Network('2001:658:22a:cafe:200::1/64'))
+        self.assertFalse(self.ipv6 == addr2)
         self.assertTrue(self.ipv6 !=
             ipaddr.IPv6Network('2001:658:22a:cafe:200::1/63'))
         self.assertTrue(self.ipv6 != ipaddr.IPv4Network('1.2.3.4/23'))
@@ -482,7 +514,7 @@ class IpaddrUnitTest(unittest.TestCase):
         # test same IP addresses
         ip_same1 = ip_same2 = ipaddr.IPv4Address('1.1.1.1')
         self.assertEqual(ipaddr.collapse_address_list([ip_same1, ip_same2]),
-                         [ip_same1])
+                         [ipaddr.IPNetwork('1.1.1.1/32')])
         ip1 = ipaddr.IPv6Network('::2001:1/100')
         ip2 = ipaddr.IPv6Network('::2002:1/120')
         ip3 = ipaddr.IPv6Network('::2001:1/96')
@@ -611,7 +643,7 @@ class IpaddrUnitTest(unittest.TestCase):
         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.IPv4Network(ipv4_string)
@@ -777,10 +809,13 @@ class IpaddrUnitTest(unittest.TestCase):
         addr1 = ipaddr.IPNetwork('10.1.1.0/24')
         addr2 = ipaddr.IPNetwork('10.1.1.0/26')
         addr3 = ipaddr.IPNetwork('10.2.1.0/24')
+        addr4 = ipaddr.IPAddress('10.1.1.0')
         self.assertEqual(addr1.address_exclude(addr2),
                          [ipaddr.IPNetwork('10.1.1.64/26'),
                           ipaddr.IPNetwork('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.assertEquals(hash(ipaddr.IPNetwork('10.1.1.0/24')),
@@ -827,7 +862,7 @@ class IpaddrUnitTest(unittest.TestCase):
             '2001:0658:022a:cafe:0000:0000:0000:0000/66':
             '2001:658:22a:cafe::/66',
             }
-        for uncompressed, compressed in test_addresses.items():
+        for uncompressed, compressed in list(test_addresses.items()):
             self.assertEquals(compressed, str(ipaddr.IPv6Network(uncompressed)))
 
     def testExplodeShortHandIpStr(self):
@@ -893,18 +928,20 @@ class IpaddrUnitTest(unittest.TestCase):
 
         self.assertEqual(str(self.ipv6.with_prefixlen),
                          '2001:658:22a:cafe:200::1/64')
-        # these two probably don't make much sense, but they're included for
-        # compatability with ipv4
+        # rfc3513 sec 2.3 says that ipv6 only uses cidr notation for
+        # subnets
         self.assertEqual(str(self.ipv6.with_netmask),
-                         '2001:658:22a:cafe:200::1/ffff:ffff:ffff:ffff::')
+                         '2001:658:22a:cafe:200::1/64')
+        # this probably don't make much sense, but it's included for
+        # compatability with ipv4
         self.assertEqual(str(self.ipv6.with_hostmask),
                          '2001:658:22a:cafe:200::1/::ffff:ffff:ffff:ffff')
 
     def testNetworkElementCaching(self):
         # V4 - make sure we're empty
-        self.assertFalse(self.ipv4._cache.has_key('network'))
-        self.assertFalse(self.ipv4._cache.has_key('broadcast'))
-        self.assertFalse(self.ipv4._cache.has_key('hostmask'))
+        self.assertFalse('network' in self.ipv4._cache)
+        self.assertFalse('broadcast' in self.ipv4._cache)
+        self.assertFalse('hostmask' in self.ipv4._cache)
 
         # V4 - populate and test
         self.assertEqual(self.ipv4.network, ipaddr.IPv4Address('1.2.3.0'))
@@ -912,14 +949,14 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(self.ipv4.hostmask, ipaddr.IPv4Address('0.0.0.255'))
 
         # V4 - check we're cached
-        self.assertTrue(self.ipv4._cache.has_key('network'))
-        self.assertTrue(self.ipv4._cache.has_key('broadcast'))
-        self.assertTrue(self.ipv4._cache.has_key('hostmask'))
+        self.assertTrue('network' in self.ipv4._cache)
+        self.assertTrue('broadcast' in self.ipv4._cache)
+        self.assertTrue('hostmask' in self.ipv4._cache)
 
         # V6 - make sure we're empty
-        self.assertFalse(self.ipv6._cache.has_key('network'))
-        self.assertFalse(self.ipv6._cache.has_key('broadcast'))
-        self.assertFalse(self.ipv6._cache.has_key('hostmask'))
+        self.assertFalse('network' in self.ipv6._cache)
+        self.assertFalse('broadcast' in self.ipv6._cache)
+        self.assertFalse('hostmask' in self.ipv6._cache)
 
         # V6 - populate and test
         self.assertEqual(self.ipv6.network,
@@ -930,9 +967,9 @@ class IpaddrUnitTest(unittest.TestCase):
                          ipaddr.IPv6Address('::ffff:ffff:ffff:ffff'))
 
         # V6 - check we're cached
-        self.assertTrue(self.ipv6._cache.has_key('network'))
-        self.assertTrue(self.ipv6._cache.has_key('broadcast'))
-        self.assertTrue(self.ipv6._cache.has_key('hostmask'))
+        self.assertTrue('network' in self.ipv6._cache)
+        self.assertTrue('broadcast' in self.ipv6._cache)
+        self.assertTrue('hostmask' in self.ipv6._cache)
 
     def testIsValidIp(self):
         ip = ipaddr.IPv6Address('::')
diff --git a/branches/2.1.0-py3k/setup.py b/branches/2.1.x-py3k/setup.py
index 3356432..3356432 100755
--- a/branches/2.1.0-py3k/setup.py
+++ b/branches/2.1.x-py3k/setup.py
diff --git a/branches/2.1.0-py3k/test-2to3.sh b/branches/2.1.x-py3k/test-2to3.sh
index 408d665..408d665 100755
--- a/branches/2.1.0-py3k/test-2to3.sh
+++ b/branches/2.1.x-py3k/test-2to3.sh