#14814: ipaddress: refactor dup code, minor janitoring, bump coverage

- remove duplicate netmask/hostmask code
- make two ifs more pythonic
- remove packed property for networks
- some minor pep8 stuff
- Test coverage is now at 97%, the rest are mostly unreachable safeguards.

Lib/ipaddress.py

@@ -10,8 +10,10 @@ and networks.
 
 __version__ = '1.0'
 
+
 import struct
 
+
 IPV4LENGTH = 32
 IPV6LENGTH = 128
 
@@ -424,7 +426,7 @@ class _IPAddressBase:
             An integer.
 
         """
-        if not prefixlen and prefixlen != 0:
+        if prefixlen is None:
             prefixlen = self._prefixlen
         return self._ALL_ONES ^ (self._ALL_ONES >> prefixlen)
 
@@ -989,6 +991,9 @@ class _BaseV4:
     _ALL_ONES = (2**IPV4LENGTH) - 1
     _DECIMAL_DIGITS = frozenset('0123456789')
 
+    # the valid octets for host and netmasks. only useful for IPv4.
+    _valid_mask_octets = set((255, 254, 252, 248, 240, 224, 192, 128, 0))
+
     def __init__(self, address):
         self._version = 4
         self._max_prefixlen = IPV4LENGTH
@@ -1060,6 +1065,53 @@ class _BaseV4:
             ip_int >>= 8
         return '.'.join(octets)
 
+    def _is_valid_netmask(self, netmask):
+        """Verify that the netmask is valid.
+
+        Args:
+            netmask: A string, either a prefix or dotted decimal
+              netmask.
+
+        Returns:
+            A boolean, True if the prefix represents a valid IPv4
+            netmask.
+
+        """
+        mask = netmask.split('.')
+        if len(mask) == 4:
+            if [x for x in mask if int(x) not in self._valid_mask_octets]:
+                return False
+            if [y for idx, y in enumerate(mask) if idx > 0 and
+                y > mask[idx - 1]]:
+                return False
+            return True
+        try:
+            netmask = int(netmask)
+        except ValueError:
+            return False
+        return 0 <= netmask <= self._max_prefixlen
+
+    def _is_hostmask(self, ip_str):
+        """Test if the IP string is a hostmask (rather than a netmask).
+
+        Args:
+            ip_str: A string, the potential hostmask.
+
+        Returns:
+            A boolean, True if the IP string is a hostmask.
+
+        """
+        bits = ip_str.split('.')
+        try:
+            parts = [int(x) for x in bits if int(x) in self._valid_mask_octets]
+        except ValueError:
+            return False
+        if len(parts) != len(bits):
+            return False
+        if parts[0] < parts[-1]:
+            return True
+        return False
+
     @property
     def max_prefixlen(self):
         return self._max_prefixlen
@@ -1213,9 +1265,6 @@ class IPv4Address(_BaseV4, _BaseAddress):
 
 class IPv4Interface(IPv4Address):
 
-    # the valid octets for host and netmasks. only useful for IPv4.
-    _valid_mask_octets = set((255, 254, 252, 248, 240, 224, 192, 128, 0))
-
     def __init__(self, address):
         if isinstance(address, (bytes, int)):
             IPv4Address.__init__(self, address)
@@ -1248,53 +1297,6 @@ class IPv4Interface(IPv4Address):
     def __hash__(self):
         return self._ip ^ self._prefixlen ^ int(self.network.network_address)
 
-    def _is_valid_netmask(self, netmask):
-        """Verify that the netmask is valid.
-
-        Args:
-            netmask: A string, either a prefix or dotted decimal
-              netmask.
-
-        Returns:
-            A boolean, True if the prefix represents a valid IPv4
-            netmask.
-
-        """
-        mask = netmask.split('.')
-        if len(mask) == 4:
-            if [x for x in mask if int(x) not in self._valid_mask_octets]:
-                return False
-            if [y for idx, y in enumerate(mask) if idx > 0 and
-                y > mask[idx - 1]]:
-                return False
-            return True
-        try:
-            netmask = int(netmask)
-        except ValueError:
-            return False
-        return 0 <= netmask <= self._max_prefixlen
-
-    def _is_hostmask(self, ip_str):
-        """Test if the IP string is a hostmask (rather than a netmask).
-
-        Args:
-            ip_str: A string, the potential hostmask.
-
-        Returns:
-            A boolean, True if the IP string is a hostmask.
-
-        """
-        bits = ip_str.split('.')
-        try:
-            parts = [int(x) for x in bits if int(x) in self._valid_mask_octets]
-        except ValueError:
-            return False
-        if len(parts) != len(bits):
-            return False
-        if parts[0] < parts[-1]:
-            return True
-        return False
-
     @property
     def prefixlen(self):
         return self._prefixlen
@@ -1334,9 +1336,6 @@ class IPv4Network(_BaseV4, _BaseNetwork):
     # TODO (ncoghlan): Investigate using IPv4Interface instead
     _address_class = IPv4Address
 
-    # the valid octets for host and netmasks. only useful for IPv4.
-    _valid_mask_octets = set((255, 254, 252, 248, 240, 224, 192, 128, 0))
-
     def __init__(self, address, strict=True):
 
         """Instantiate a new IPv4 network object.
@@ -1443,58 +1442,6 @@ class IPv4Network(_BaseV4, _BaseNetwork):
         if self._prefixlen == (self._max_prefixlen - 1):
             self.hosts = self.__iter__
 
-    @property
-    def packed(self):
-        """The binary representation of this address."""
-        return v4_int_to_packed(self.network_address)
-
-    def _is_valid_netmask(self, netmask):
-        """Verify that the netmask is valid.
-
-        Args:
-            netmask: A string, either a prefix or dotted decimal
-              netmask.
-
-        Returns:
-            A boolean, True if the prefix represents a valid IPv4
-            netmask.
-
-        """
-        mask = netmask.split('.')
-        if len(mask) == 4:
-            if [x for x in mask if int(x) not in self._valid_mask_octets]:
-                return False
-            if [y for idx, y in enumerate(mask) if idx > 0 and
-                y > mask[idx - 1]]:
-                return False
-            return True
-        try:
-            netmask = int(netmask)
-        except ValueError:
-            return False
-        return 0 <= netmask <= self._max_prefixlen
-
-    def _is_hostmask(self, ip_str):
-        """Test if the IP string is a hostmask (rather than a netmask).
-
-        Args:
-            ip_str: A string, the potential hostmask.
-
-        Returns:
-            A boolean, True if the IP string is a hostmask.
-
-        """
-        bits = ip_str.split('.')
-        try:
-            parts = [int(x) for x in bits if int(x) in self._valid_mask_octets]
-        except ValueError:
-            return False
-        if len(parts) != len(bits):
-            return False
-        if parts[0] < parts[-1]:
-            return True
-        return False
-
 
 class _BaseV6:
 
@@ -1675,7 +1622,7 @@ class _BaseV6:
             ValueError: The address is bigger than 128 bits of all ones.
 
         """
-        if not ip_int and ip_int != 0:
+        if ip_int is None:
             ip_int = int(self._ip)
 
         if ip_int > self._ALL_ONES:
@@ -1720,11 +1667,6 @@ class _BaseV6:
     def max_prefixlen(self):
         return self._max_prefixlen
 
-    @property
-    def packed(self):
-        """The binary representation of this address."""
-        return v6_int_to_packed(self._ip)
-
     @property
     def version(self):
         return self._version
@@ -1931,6 +1873,11 @@ class IPv6Address(_BaseV6, _BaseAddress):
 
         self._ip = self._ip_int_from_string(addr_str)
 
+    @property
+    def packed(self):
+        """The binary representation of this address."""
+        return v6_int_to_packed(self._ip)
+
 
 class IPv6Interface(IPv6Address):
 

Lib/test/test_ipaddress.py

@@ -5,12 +5,13 @@
 
 
 import unittest
-import time
 import ipaddress
 
+
 # Compatibility function to cast str to bytes objects
 _cb = lambda bytestr: bytes(bytestr, 'charmap')
 
+
 class IpaddrUnitTest(unittest.TestCase):
 
     def setUp(self):
@@ -133,6 +134,31 @@ class IpaddrUnitTest(unittest.TestCase):
                           '1.a.2.3')
         self.assertEqual(False, ipaddress.IPv4Interface(1)._is_hostmask(
                 '1.a.2.3'))
+        self.assertRaises(ValueError, ipaddress.ip_interface, 'bogus')
+        self.assertRaises(ValueError, ipaddress.IPv4Address, '127.0.0.1/32')
+        self.assertRaises(ValueError, ipaddress.v4_int_to_packed, -1)
+        self.assertRaises(ValueError, ipaddress.v4_int_to_packed,
+                          2 ** ipaddress.IPV4LENGTH)
+        self.assertRaises(ValueError, ipaddress.v6_int_to_packed, -1)
+        self.assertRaises(ValueError, ipaddress.v6_int_to_packed,
+                          2 ** ipaddress.IPV6LENGTH)
+
+    def testInternals(self):
+        first, last = ipaddress._find_address_range([
+            ipaddress.IPv4Address('10.10.10.10'),
+            ipaddress.IPv4Address('10.10.10.12')])
+        self.assertEqual(first, last)
+        self.assertEqual(0, ipaddress._get_prefix_length(2**32, 0, 32))
+        self.assertEqual(128, ipaddress._count_righthand_zero_bits(0, 128))
+        base_ip = ipaddress._BaseAddress('127.0.0.1')
+        try:
+            base_ip.version
+            self.fail('_BaseAddress.version didn\'t raise NotImplementedError')
+        except NotImplementedError:
+            pass
+        self.assertEqual("IPv4Network('1.2.3.0/24')", repr(self.ipv4_network))
+        self.assertEqual('0x1020318', hex(self.ipv4_network))
+        self.assertRaises(TypeError, self.ipv4_network.__eq__, object())
 
     def testGetNetwork(self):
         self.assertEqual(int(self.ipv4_network.network_address), 16909056)
@@ -188,6 +214,7 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual([v6addr, v6net],
                          sorted([v6net, v6addr],
                                 key=ipaddress.get_mixed_type_key))
+        self.assertEqual(NotImplemented, ipaddress.get_mixed_type_key(object))
 
     def testIpFromInt(self):
         self.assertEqual(self.ipv4_interface._ip,
@@ -209,9 +236,15 @@ class IpaddrUnitTest(unittest.TestCase):
                           ipaddress.IPv6Interface, 2**128)
         self.assertRaises(ipaddress.AddressValueError,
                           ipaddress.IPv6Interface, -1)
+        self.assertRaises(ipaddress.AddressValueError,
+                          ipaddress.IPv6Network, 2**128)
+        self.assertRaises(ipaddress.AddressValueError,
+                          ipaddress.IPv6Network, -1)
 
-        self.assertEqual(ipaddress.ip_network(self.ipv4_address._ip).version, 4)
+        self.assertEqual(ipaddress.ip_network(self.ipv4_address._ip).version,
-        self.assertEqual(ipaddress.ip_network(self.ipv6_address._ip).version, 6)
+                         4)
+        self.assertEqual(ipaddress.ip_network(self.ipv6_address._ip).version,
+                         6)
 
     def testIpFromPacked(self):
         ip = ipaddress.ip_network
@@ -255,12 +288,31 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(int(ipv4_zero_netmask.network.netmask), 0)
         self.assertTrue(ipv4_zero_netmask.network._is_valid_netmask(
                 str(0)))
+        self.assertTrue(ipv4_zero_netmask._is_valid_netmask('0'))
+        self.assertTrue(ipv4_zero_netmask._is_valid_netmask('0.0.0.0'))
+        self.assertFalse(ipv4_zero_netmask._is_valid_netmask('invalid'))
 
         ipv6_zero_netmask = ipaddress.IPv6Interface('::1/0')
         self.assertEqual(int(ipv6_zero_netmask.network.netmask), 0)
         self.assertTrue(ipv6_zero_netmask.network._is_valid_netmask(
                 str(0)))
 
+    def testIPv4NetAndHostmasks(self):
+        net = self.ipv4_network
+        self.assertFalse(net._is_valid_netmask('invalid'))
+        self.assertTrue(net._is_valid_netmask('128.128.128.128'))
+        self.assertFalse(net._is_valid_netmask('128.128.128.127'))
+        self.assertFalse(net._is_valid_netmask('128.128.128.255'))
+        self.assertTrue(net._is_valid_netmask('255.128.128.128'))
+
+        self.assertFalse(net._is_hostmask('invalid'))
+        self.assertTrue(net._is_hostmask('128.255.255.255'))
+        self.assertFalse(net._is_hostmask('255.255.255.255'))
+        self.assertFalse(net._is_hostmask('1.2.3.4'))
+
+        net = ipaddress.IPv4Network('127.0.0.0/0.0.0.255')
+        self.assertEqual(24, net.prefixlen)
+
     def testGetBroadcast(self):
         self.assertEqual(int(self.ipv4_network.broadcast_address), 16909311)
         self.assertEqual(str(self.ipv4_network.broadcast_address), '1.2.3.255')
@@ -300,17 +352,25 @@ class IpaddrUnitTest(unittest.TestCase):
     def testGetSupernet4(self):
         self.assertRaises(ValueError, self.ipv4_network.supernet,
                           prefixlen_diff=2, new_prefix=1)
-        self.assertRaises(ValueError, self.ipv4_network.supernet, new_prefix=25)
+        self.assertRaises(ValueError, self.ipv4_network.supernet,
+                          new_prefix=25)
         self.assertEqual(self.ipv4_network.supernet(prefixlen_diff=2),
                          self.ipv4_network.supernet(new_prefix=22))
 
         self.assertRaises(ValueError, self.ipv6_network.supernet,
                           prefixlen_diff=2, new_prefix=1)
-        self.assertRaises(ValueError, self.ipv6_network.supernet, new_prefix=65)
+        self.assertRaises(ValueError, self.ipv6_network.supernet,
+                          new_prefix=65)
         self.assertEqual(self.ipv6_network.supernet(prefixlen_diff=2),
                          self.ipv6_network.supernet(new_prefix=62))
 
     def testHosts(self):
+        hosts = list(self.ipv4_network.hosts())
+        self.assertEqual(254, len(hosts))
+        self.assertEqual(ipaddress.IPv4Address('1.2.3.1'), hosts[0])
+        self.assertEqual(ipaddress.IPv4Address('1.2.3.254'), hosts[-1])
+
+        # special case where only 1 bit is left for address
         self.assertEqual([ipaddress.IPv4Address('2.0.0.0'),
                           ipaddress.IPv4Address('2.0.0.1')],
                          list(ipaddress.ip_network('2.0.0.0/31').hosts()))
@@ -398,7 +458,8 @@ class IpaddrUnitTest(unittest.TestCase):
 
     def testGetNum_Addresses(self):
         self.assertEqual(self.ipv4_network.num_addresses, 256)
-        self.assertEqual(list(self.ipv4_network.subnets())[0].num_addresses, 128)
+        self.assertEqual(list(self.ipv4_network.subnets())[0].num_addresses,
+                         128)
         self.assertEqual(self.ipv4_network.supernet().num_addresses, 512)
 
         self.assertEqual(self.ipv6_network.num_addresses, 18446744073709551616)
@@ -430,6 +491,8 @@ class IpaddrUnitTest(unittest.TestCase):
                           'poopv6')
         self.assertRaises(ipaddress.AddressValueError,
                           ipaddress.IPv4Interface, '1.2.3.4/32/24')
+        self.assertRaises(ipaddress.AddressValueError,
+                          ipaddress.IPv4Network, '1.2.3.4/32/24')
         self.assertRaises(ipaddress.AddressValueError,
                           ipaddress.IPv4Interface, '10/8')
         self.assertRaises(ipaddress.AddressValueError,
@@ -545,8 +608,9 @@ class IpaddrUnitTest(unittest.TestCase):
         # check that addreses are subsumed properly.
         collapsed = ipaddress.collapse_addresses(
             [ip1, ip2, ip3, ip4, ip5, ip6])
-        self.assertEqual(list(collapsed), [ipaddress.IPv4Network('1.1.1.0/30'),
+        self.assertEqual(list(collapsed),
-                                           ipaddress.IPv4Network('1.1.1.4/32')])
+                [ipaddress.IPv4Network('1.1.1.0/30'),
+                 ipaddress.IPv4Network('1.1.1.4/32')])
 
         # test a mix of IP addresses and networks including some duplicates
         ip1 = ipaddress.IPv4Address('1.1.1.0')
@@ -557,7 +621,8 @@ class IpaddrUnitTest(unittest.TestCase):
         #ip6 = ipaddress.IPv4Interface('1.1.1.4/30')
         # check that addreses are subsumed properly.
         collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4])
-        self.assertEqual(list(collapsed), [ipaddress.IPv4Network('1.1.1.0/30')])
+        self.assertEqual(list(collapsed),
+                         [ipaddress.IPv4Network('1.1.1.0/30')])
 
         # test only IP networks
         ip1 = ipaddress.IPv4Network('1.1.0.0/24')
@@ -565,17 +630,20 @@ class IpaddrUnitTest(unittest.TestCase):
         ip3 = ipaddress.IPv4Network('1.1.2.0/24')
         ip4 = ipaddress.IPv4Network('1.1.3.0/24')
         ip5 = ipaddress.IPv4Network('1.1.4.0/24')
-        # stored in no particular order b/c we want CollapseAddr to call [].sort
+        # stored in no particular order b/c we want CollapseAddr to call
+        # [].sort
         ip6 = ipaddress.IPv4Network('1.1.0.0/22')
         # check that addreses are subsumed properly.
         collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4, ip5,
                                                      ip6])
-        self.assertEqual(list(collapsed), [ipaddress.IPv4Network('1.1.0.0/22'),
+        self.assertEqual(list(collapsed),
-                                           ipaddress.IPv4Network('1.1.4.0/24')])
+                         [ipaddress.IPv4Network('1.1.0.0/22'),
+                          ipaddress.IPv4Network('1.1.4.0/24')])
 
         # test that two addresses are supernet'ed properly
         collapsed = ipaddress.collapse_addresses([ip1, ip2])
-        self.assertEqual(list(collapsed), [ipaddress.IPv4Network('1.1.0.0/23')])
+        self.assertEqual(list(collapsed),
+                         [ipaddress.IPv4Network('1.1.0.0/23')])
 
         # test same IP networks
         ip_same1 = ip_same2 = ipaddress.IPv4Network('1.1.1.1/32')
@@ -614,7 +682,20 @@ class IpaddrUnitTest(unittest.TestCase):
         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
+
+        # summarize works only for IPv4 & IPv6
+        class IPv7Address(ipaddress.IPv6Address):
+            @property
+            def version(self):
+                return 7
+        ip_invalid1 = IPv7Address('::1')
+        ip_invalid2 = IPv7Address('::1')
+        self.assertRaises(ValueError, list,
+                          summarize(ip_invalid1, ip_invalid2))
+        # test that a summary over ip4 & ip6 fails
+        self.assertRaises(TypeError, list,
+                          summarize(ip1, ipaddress.IPv6Address('::1')))
+        # test a /24 is summarized properly
         self.assertEqual(list(summarize(ip1, ip2))[0],
                          ipaddress.ip_network('1.1.1.0/24'))
         # test an  IPv4 range that isn't on a network byte boundary
@@ -622,6 +703,11 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(list(summarize(ip1, ip2)),
                          [ipaddress.ip_network('1.1.1.0/29'),
                           ipaddress.ip_network('1.1.1.8')])
+        # all!
+        ip1 = ipaddress.IPv4Address(0)
+        ip2 = ipaddress.IPv4Address(ipaddress.IPv4Address._ALL_ONES)
+        self.assertEqual([ipaddress.IPv4Network('0.0.0.0/0')],
+                         list(summarize(ip1, ip2)))
 
         ip1 = ipaddress.ip_address('1::')
         ip2 = ipaddress.ip_address('1:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
@@ -663,15 +749,20 @@ class IpaddrUnitTest(unittest.TestCase):
     def testNetworkComparison(self):
         # ip1 and ip2 have the same network address
         ip1 = ipaddress.IPv4Network('1.1.1.0/24')
-        ip2 = ipaddress.IPv4Network('1.1.1.1/32')
+        ip2 = ipaddress.IPv4Network('1.1.1.0/32')
         ip3 = ipaddress.IPv4Network('1.1.2.0/24')
 
         self.assertTrue(ip1 < ip3)
         self.assertTrue(ip3 > ip2)
 
-        #self.assertEqual(ip1.compare_networks(ip2), 0)
+        self.assertEqual(ip1.compare_networks(ip1), 0)
-        #self.assertTrue(ip1._get_networks_key() == ip2._get_networks_key())
+
+        # if addresses are the same, sort by netmask
+        self.assertEqual(ip1.compare_networks(ip2), -1)
+        self.assertEqual(ip2.compare_networks(ip1), 1)
+
         self.assertEqual(ip1.compare_networks(ip3), -1)
+        self.assertEqual(ip3.compare_networks(ip1), 1)
         self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
 
         ip1 = ipaddress.IPv6Network('2001:2000::/96')
@@ -685,6 +776,9 @@ class IpaddrUnitTest(unittest.TestCase):
 
         # Test comparing different protocols.
         # Should always raise a TypeError.
+        self.assertRaises(TypeError,
+                          self.ipv4_network.compare_networks,
+                          self.ipv6_network)
         ipv6 = ipaddress.IPv6Interface('::/0')
         ipv4 = ipaddress.IPv4Interface('0.0.0.0/0')
         self.assertRaises(TypeError, ipv4.__lt__, ipv6)
@@ -811,6 +905,7 @@ class IpaddrUnitTest(unittest.TestCase):
         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, ipaddress.ip_network('240.0.0.0').is_reserved)
 
         self.assertEqual(True, ipaddress.ip_interface(
                 '192.168.1.1/17').is_private)
@@ -818,9 +913,12 @@ class IpaddrUnitTest(unittest.TestCase):
         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(False, ipaddress.ip_network('11.0.0.0').is_reserved)
         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,
+                         ipaddress.ip_network('169.254.1.0/24').is_link_local)
 
         self.assertEqual(True,
                           ipaddress.ip_interface(
@@ -840,6 +938,9 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(True, ipaddress.ip_address('0.0.0.0').is_unspecified)
         self.assertEqual(True, ipaddress.ip_address('224.1.1.1').is_multicast)
         self.assertEqual(False, ipaddress.ip_address('240.0.0.0').is_multicast)
+        self.assertEqual(True, ipaddress.ip_address('240.0.0.1').is_reserved)
+        self.assertEqual(False,
+                         ipaddress.ip_address('239.255.255.255').is_reserved)
 
         self.assertEqual(True, ipaddress.ip_address('192.168.1.1').is_private)
         self.assertEqual(False, ipaddress.ip_address('192.169.0.0').is_private)
@@ -851,9 +952,9 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(False, ipaddress.ip_address('172.32.0.0').is_private)
 
         self.assertEqual(True,
-                          ipaddress.ip_address('169.254.100.200').is_link_local)
+                         ipaddress.ip_address('169.254.100.200').is_link_local)
         self.assertEqual(False,
-                          ipaddress.ip_address('169.255.100.200').is_link_local)
+                         ipaddress.ip_address('169.255.100.200').is_link_local)
 
         self.assertEqual(True,
                           ipaddress.ip_address('127.100.200.254').is_loopback)
@@ -864,7 +965,7 @@ class IpaddrUnitTest(unittest.TestCase):
     def testReservedIpv6(self):
 
         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(2**128 - 1).is_multicast)
         self.assertEqual(True, ipaddress.ip_network('ff00::').is_multicast)
         self.assertEqual(False, ipaddress.ip_network('fdff::').is_multicast)
 
@@ -899,7 +1000,7 @@ class IpaddrUnitTest(unittest.TestCase):
 
         # test addresses
         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(2**128 - 1).is_multicast)
         self.assertEqual(True, ipaddress.ip_address('ff00::').is_multicast)
         self.assertEqual(False, ipaddress.ip_address('fdff::').is_multicast)
 
@@ -935,8 +1036,9 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertEqual(True, ipaddress.ip_network('4000::1/128').is_reserved)
 
     def testIpv4Mapped(self):
-        self.assertEqual(ipaddress.ip_address('::ffff:192.168.1.1').ipv4_mapped,
+        self.assertEqual(
-                         ipaddress.ip_address('192.168.1.1'))
+                ipaddress.ip_address('::ffff:192.168.1.1').ipv4_mapped,
+                ipaddress.ip_address('192.168.1.1'))
         self.assertEqual(ipaddress.ip_address('::c0a8:101').ipv4_mapped, None)
         self.assertEqual(ipaddress.ip_address('::ffff:c0a8:101').ipv4_mapped,
                          ipaddress.ip_address('192.168.1.1'))
@@ -946,21 +1048,25 @@ class IpaddrUnitTest(unittest.TestCase):
         addr2 = ipaddress.ip_network('10.1.1.0/26')
         addr3 = ipaddress.ip_network('10.2.1.0/24')
         addr4 = ipaddress.ip_address('10.1.1.0')
+        addr5 = ipaddress.ip_network('2001:db8::0/32')
         self.assertEqual(sorted(list(addr1.address_exclude(addr2))),
                          [ipaddress.ip_network('10.1.1.64/26'),
                           ipaddress.ip_network('10.1.1.128/25')])
         self.assertRaises(ValueError, list, addr1.address_exclude(addr3))
         self.assertRaises(TypeError, list, addr1.address_exclude(addr4))
+        self.assertRaises(TypeError, list, addr1.address_exclude(addr5))
         self.assertEqual(list(addr1.address_exclude(addr1)), [])
 
     def testHash(self):
+        self.assertEqual(hash(ipaddress.ip_interface('10.1.1.0/24')),
+                         hash(ipaddress.ip_interface('10.1.1.0/24')))
         self.assertEqual(hash(ipaddress.ip_network('10.1.1.0/24')),
-                          hash(ipaddress.ip_network('10.1.1.0/24')))
+                         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')))
+                         hash(ipaddress.ip_address('10.1.1.0')))
         # i70
         self.assertEqual(hash(ipaddress.ip_address('1.2.3.4')),
-                          hash(ipaddress.ip_address(
+                         hash(ipaddress.ip_address(
                     int(ipaddress.ip_address('1.2.3.4')._ip))))
         ip1 = ipaddress.ip_address('10.1.1.0')
         ip2 = ipaddress.ip_address('1::')
@@ -972,6 +1078,18 @@ class IpaddrUnitTest(unittest.TestCase):
         self.assertTrue(self.ipv4_address in dummy)
         self.assertTrue(ip2 in dummy)
 
+    def testIPBases(self):
+        net = self.ipv4_network
+        self.assertEqual('1.2.3.0/24', net.compressed)
+        self.assertEqual(
+                net._ip_int_from_prefix(24),
+                net._ip_int_from_prefix(None))
+        net = self.ipv6_network
+        self.assertRaises(ValueError, net._string_from_ip_int, 2**128 + 1)
+        self.assertEqual(
+                self.ipv6_address._string_from_ip_int(self.ipv6_address._ip),
+                self.ipv6_address._string_from_ip_int(None))
+
     def testIPv6NetworkHelpers(self):
         net = self.ipv6_network
         self.assertEqual('2001:658:22a:cafe::/64', net.with_prefixlen)
@@ -1032,6 +1150,7 @@ class IpaddrUnitTest(unittest.TestCase):
         addr1 = ipaddress.IPv6Interface('2001::1')
         addr2 = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
         addr3 = ipaddress.IPv6Network('2001::/96')
+        addr4 = ipaddress.IPv4Address('192.168.178.1')
         self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0001/128',
                          addr1.exploded)
         self.assertEqual('0000:0000:0000:0000:0000:0000:0000:0001/128',
@@ -1041,6 +1160,7 @@ class IpaddrUnitTest(unittest.TestCase):
                          addr2.exploded)
         self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0000/96',
                          addr3.exploded)
+        self.assertEqual('192.168.178.1', addr4.exploded)
 
     def testIntRepresentation(self):
         self.assertEqual(16909060, int(self.ipv4_address))
@@ -1118,7 +1238,8 @@ class IpaddrUnitTest(unittest.TestCase):
         # V6 - check we're cached
         self.assertTrue('broadcast_address' in self.ipv6_network._cache)
         self.assertTrue('hostmask' in self.ipv6_network._cache)
-        self.assertTrue('broadcast_address' in self.ipv6_interface.network._cache)
+        self.assertTrue(
+                'broadcast_address' in self.ipv6_interface.network._cache)
         self.assertTrue('hostmask' in self.ipv6_interface.network._cache)
 
     def testTeredo(self):
@@ -1139,7 +1260,6 @@ class IpaddrUnitTest(unittest.TestCase):
                           ipaddress.IPv4Address('95.26.244.94')),
                          teredo_addr.teredo)
 
-
     def testsixtofour(self):
         sixtofouraddr = ipaddress.ip_address('2002:ac1d:2d64::1')
         bad_addr = ipaddress.ip_address('2000:ac1d:2d64::1')