collapse_address_list is too slow

ipaddr_test.py

 #!/usr/bin/python
 #
 # Copyright 2007 Google Inc.
 #  Licensed to PSF under a Contributor Agreement.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
 """Unittest for ipaddr module."""
 
 
 import unittest
-
+import time
 import ipaddr
 
 # Compatibility function to cast str to bytes objects
 if ipaddr._compat_has_real_bytes:
     _cb = lambda bytestr: bytes(bytestr, 'charmap')
 else:
     _cb = str
 
 class IpaddrUnitTest(unittest.TestCase):
 
     def setUp(self):
         self.ipv4 = ipaddr.IPv4('1.2.3.4/24')
         self.ipv4_hostmask = ipaddr.IPv4('10.0.0.1/0.255.255.255')
         self.ipv6 = ipaddr.IPv6('2001:658:22a:cafe:200:0:0:1/64')
 
+    def tearDown(self):
+        del(self.ipv4)
+        del(self.ipv4_hostmask)
+        del(self.ipv6)
+        del(self)
+
     def testRepr(self):
-        self.assertEqual("IPv4('1.2.3.4/32')", repr(ipaddr.IPv4('1.2.3.4')))
-        self.assertEqual("IPv6('::1/128')", repr(ipaddr.IPv6('::1')))
+        self.assertEqual("IPv4Network('1.2.3.4/32')",
+                         repr(ipaddr.IPv4('1.2.3.4')))
+        self.assertEqual("IPv6Network('::1/128')", repr(ipaddr.IPv6('::1')))
 
     def testInvalidStrings(self):
         self.assertRaises(ValueError, ipaddr.IP, '')
         self.assertRaises(ValueError, ipaddr.IP, 'www.google.com')
         self.assertRaises(ValueError, ipaddr.IP, '1.2.3')
         self.assertRaises(ValueError, ipaddr.IP, '1.2.3.4.5')
         self.assertRaises(ValueError, ipaddr.IP, '301.2.2.2')
         self.assertRaises(ValueError, ipaddr.IP, '1:2:3:4:5:6:7')
         self.assertRaises(ValueError, ipaddr.IP, '1:2:3:4:5:6:7:')
         self.assertRaises(ValueError, ipaddr.IP, ':2:3:4:5:6:7:8')
@@ skipping 13 matching lines @@
                           'google.com')
         self.assertRaises(ipaddr.IPv4IpValidationError, ipaddr.IPv4,
                           '::1.2.3.4')
         self.assertRaises(ipaddr.IPv6IpValidationError, ipaddr.IPv6, '')
         self.assertRaises(ipaddr.IPv6IpValidationError, ipaddr.IPv6,
                           'google.com')
         self.assertRaises(ipaddr.IPv6IpValidationError, ipaddr.IPv6,
                           '1.2.3.4')
 
     def testGetNetwork(self):
-        self.assertEqual(self.ipv4.network, 16909056)
-        self.assertEqual(self.ipv4.network_ext, '1.2.3.0')
-        self.assertEqual(self.ipv4_hostmask.network_ext, '10.0.0.0')
-
-        self.assertEqual(self.ipv6.network,
+        self.assertEqual(int(self.ipv4.network), 16909056)
+        self.assertEqual(str(self.ipv4.network), '1.2.3.0')
+        self.assertEqual(str(self.ipv4_hostmask.network), '10.0.0.0')
+
+        self.assertEqual(int(self.ipv6.network),
                          42540616829182469433403647294022090752)
-        self.assertEqual(self.ipv6.network_ext,
+        self.assertEqual(str(self.ipv6.network),
                          '2001:658:22a:cafe::')
-        self.assertEqual(self.ipv6.hostmask_ext,
+        self.assertEqual(str(self.ipv6.hostmask),
                          '::ffff:ffff:ffff:ffff')
 
     def testIpFromInt(self):
         self.assertEqual(self.ipv4.ip, ipaddr.IPv4(16909060).ip)
         self.assertRaises(ipaddr.IPv4IpValidationError,
                           ipaddr.IPv4, 2**32)
         self.assertRaises(ipaddr.IPv4IpValidationError,
                           ipaddr.IPv4, -1)
+
+        ipv4 = ipaddr.IP('1.2.3.4')
+        ipv6 = ipaddr.IP('2001:658:22a:cafe:200:0:0:1')
+        self.assertEqual(ipv4, ipaddr.IP(int(ipv4)))
+        self.assertEqual(ipv6, ipaddr.IP(int(ipv6)))
 
         self.assertEqual(self.ipv6.ip,
                          ipaddr.IPv6(42540616829182469433547762482097946625).ip)
         self.assertRaises(ipaddr.IPv6IpValidationError,
                           ipaddr.IPv6, 2**128)
         self.assertRaises(ipaddr.IPv6IpValidationError,
                           ipaddr.IPv6, -1)
 
         self.assertEqual(ipaddr.IP(self.ipv4.ip).version, 4)
         self.assertEqual(ipaddr.IP(self.ipv6.ip).version, 6)
@@ skipping 13 matching lines @@
                                '\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(self.ipv4.ip, 16909060)
-        self.assertEqual(self.ipv4.ip_ext, '1.2.3.4')
-        self.assertEqual(self.ipv4.ip_ext_full, '1.2.3.4')
-        self.assertEqual(self.ipv4_hostmask.ip_ext, '10.0.0.1')
-
-        self.assertEqual(self.ipv6.ip, 42540616829182469433547762482097946625)
-        self.assertEqual(self.ipv6.ip_ext,
+        self.assertEqual(int(self.ipv4.ip), 16909060)
+        self.assertEqual(str(self.ipv4.ip), '1.2.3.4')
+        self.assertEqual(str(self.ipv4_hostmask.ip), '10.0.0.1')
+
+        self.assertEqual(int(self.ipv6.ip),
+                         42540616829182469433547762482097946625)
+        self.assertEqual(str(self.ipv6.ip),
                          '2001:658:22a:cafe:200::1')
-        self.assertEqual(self.ipv6.ip_ext_full,
-                         '2001:0658:022a:cafe:0200:0000:0000:0001')
 
     def testGetNetmask(self):
-        self.assertEqual(self.ipv4.netmask, 4294967040L)
-        self.assertEqual(self.ipv4.netmask_ext, '255.255.255.0')
-        self.assertEqual(self.ipv4_hostmask.netmask_ext, '255.0.0.0')
-        self.assertEqual(self.ipv6.netmask,
+        self.assertEqual(int(self.ipv4.netmask), 4294967040L)
+        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),
                          340282366920938463444927863358058659840)
-        self.assertEqual(self.ipv6.netmask_ext, 64)
+        self.assertEqual(self.ipv6.prefixlen, 64)
 
     def testZeroNetmask(self):
         ipv4_zero_netmask = ipaddr.IPv4('1.2.3.4/0')
-        self.assertEqual(ipv4_zero_netmask.netmask, 0)
+        self.assertEqual(int(ipv4_zero_netmask.netmask), 0)
         self.assert_(ipv4_zero_netmask._is_valid_netmask(str(0)))
 
         ipv6_zero_netmask = ipaddr.IPv6('::1/0')
-        self.assertEqual(ipv6_zero_netmask.netmask, 0)
+        self.assertEqual(int(ipv6_zero_netmask.netmask), 0)
         self.assert_(ipv6_zero_netmask._is_valid_netmask(str(0)))
 
     def testGetBroadcast(self):
-        self.assertEqual(self.ipv4.broadcast, 16909311L)
-        self.assertEqual(self.ipv4.broadcast_ext, '1.2.3.255')
-
-        self.assertEqual(self.ipv6.broadcast,
+        self.assertEqual(int(self.ipv4.broadcast), 16909311L)
+        self.assertEqual(str(self.ipv4.broadcast), '1.2.3.255')
+
+        self.assertEqual(int(self.ipv6.broadcast),
                          42540616829182469451850391367731642367)
-        self.assertEqual(self.ipv6.broadcast_ext,
+        self.assertEqual(str(self.ipv6.broadcast),
                          '2001:658:22a:cafe:ffff:ffff:ffff:ffff')
 
     def testGetPrefixlen(self):
         self.assertEqual(self.ipv4.prefixlen, 24)
 
         self.assertEqual(self.ipv6.prefixlen, 64)
 
     def testGetSupernet(self):
         self.assertEqual(self.ipv4.supernet().prefixlen, 23)
-        self.assertEqual(self.ipv4.supernet().network_ext, '1.2.2.0')
+        self.assertEqual(str(self.ipv4.supernet().network), '1.2.2.0')
         self.assertEqual(ipaddr.IPv4('0.0.0.0/0').supernet(),
                          ipaddr.IPv4('0.0.0.0/0'))
 
         self.assertEqual(self.ipv6.supernet().prefixlen, 63)
-        self.assertEqual(self.ipv6.supernet().network_ext,
+        self.assertEqual(str(self.ipv6.supernet().network),
                          '2001:658:22a:cafe::')
         self.assertEqual(ipaddr.IPv6('::0/0').supernet(), ipaddr.IPv6('::0/0'))
 
     def testGetSupernet3(self):
         self.assertEqual(self.ipv4.supernet(3).prefixlen, 21)
-        self.assertEqual(self.ipv4.supernet(3).network_ext, '1.2.0.0')
+        self.assertEqual(str(self.ipv4.supernet(3).network), '1.2.0.0')
 
         self.assertEqual(self.ipv6.supernet(3).prefixlen, 61)
-        self.assertEqual(self.ipv6.supernet(3).network_ext,
+        self.assertEqual(str(self.ipv6.supernet(3).network),
                          '2001:658:22a:caf8::')
 
     def testGetSubnet(self):
         self.assertEqual(self.ipv4.subnet()[0].prefixlen, 25)
-        self.assertEqual(self.ipv4.subnet()[0].network_ext, '1.2.3.0')
-        self.assertEqual(self.ipv4.subnet()[1].network_ext, '1.2.3.128')
+        self.assertEqual(str(self.ipv4.subnet()[0].network), '1.2.3.0')
+        self.assertEqual(str(self.ipv4.subnet()[1].network), '1.2.3.128')
 
         self.assertEqual(self.ipv6.subnet()[0].prefixlen, 65)
 
     def testGetSubnetForSingle32(self):
         ip = ipaddr.IPv4('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)
 
@@ skipping 44 matching lines @@
         self.assertEqual(self.ipv6.subnet()[0].numhosts, 9223372036854775808)
         self.assertEqual(self.ipv6.supernet().numhosts, 36893488147419103232)
 
     def testContains(self):
         self.assertTrue(ipaddr.IPv4('1.2.3.128/25') in self.ipv4)
         self.assertFalse(ipaddr.IPv4('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.
+        addr1str = '1.2.3.37'
+        addr1 = ipaddr.IPv4Address(addr1str)
+        self.assertTrue(addr1 in self.ipv4)
+        self.assertTrue(int(addr1) in self.ipv4)
+        self.assertTrue(addr1str in self.ipv4)
 
     def testBadAddress(self):
         self.assertRaises(ipaddr.IPv4IpValidationError, ipaddr.IPv4, 'poop')
         self.assertRaises(ipaddr.IPv4IpValidationError,
                           ipaddr.IPv4, '1.2.3.256')
 
         self.assertRaises(ipaddr.IPv6IpValidationError, ipaddr.IPv6, 'poopv6')
         self.assertRaises(ipaddr.IPv4IpValidationError,
                           ipaddr.IPv4, '1.2.3.4/32/24')
 
     def testBadNetMask(self):
         self.assertRaises(ipaddr.IPv4NetmaskValidationError,
                           ipaddr.IPv4, '1.2.3.4/')
         self.assertRaises(ipaddr.IPv4NetmaskValidationError,
                           ipaddr.IPv4, '1.2.3.4/33')
         self.assertRaises(ipaddr.IPv4NetmaskValidationError,
                           ipaddr.IPv4, '1.2.3.4/254.254.255.256')
 
         self.assertRaises(ipaddr.IPv6NetmaskValidationError,
                           ipaddr.IPv6, '::1/')
         self.assertRaises(ipaddr.IPv6NetmaskValidationError,
                           ipaddr.IPv6, '::1/129')
 
     def testNth(self):
-        self.assertEqual(self.ipv4[5], '1.2.3.5')
+        self.assertEqual(str(self.ipv4[5]), '1.2.3.5')
         self.assertRaises(IndexError, self.ipv4.__getitem__, 256)
 
-        self.assertEqual(self.ipv6[5],
+        self.assertEqual(str(self.ipv6[5]),
                          '2001:658:22a:cafe::5')
 
     def testGetitem(self):
         # http://code.google.com/p/ipaddr-py/issues/detail?id=15
         addr = ipaddr.IPv4('172.31.255.128/255.255.255.240')
         self.assertEqual(28, addr.prefixlen)
         addr_list = list(addr)
-        self.assertEqual('172.31.255.128', addr_list[0])
-        self.assertEqual('172.31.255.128', addr[0])
-        self.assertEqual('172.31.255.143', addr_list[-1])
-        self.assertEqual('172.31.255.143', addr[-1])
+        self.assertEqual('172.31.255.128', str(addr_list[0]))
+        self.assertEqual('172.31.255.128', str(addr[0]))
+        self.assertEqual('172.31.255.143', str(addr_list[-1]))
+        self.assertEqual('172.31.255.143', str(addr[-1]))
         self.assertEqual(addr_list[-1], addr[-1])
 
     def testEquals(self):
         self.assertTrue(self.ipv4 == ipaddr.IPv4('1.2.3.4/24'))
         self.assertFalse(self.ipv4 == ipaddr.IPv4('1.2.3.4/23'))
         self.assertFalse(self.ipv4 == ipaddr.IPv4('1.2.3.5/24'))
         self.assertFalse(self.ipv4 == ipaddr.IPv6('::1.2.3.4/24'))
         self.assertFalse(self.ipv4 == '')
         self.assertFalse(self.ipv4 == [])
         self.assertFalse(self.ipv4 == 2)
@@ skipping 34 matching lines @@
                           '1.2.3.4/32')
 
     def testSlash128Constructor(self):
         self.assertEquals(str(ipaddr.IPv6('::1/128')),
                                   '::1/128')
 
     def testSlash0Constructor(self):
         self.assertEquals(str(ipaddr.IPv4('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.IPv4('1.1.1.0', host=True)
+        ip2 = ipaddr.IPv4('1.1.1.1', host=True)
+        ip3 = ipaddr.IPv4('1.1.1.2', host=True)
+        ip4 = ipaddr.IPv4('1.1.1.3', host=True)
+        ip5 = ipaddr.IPv4('1.1.1.4', host=True)
+        ip6 = ipaddr.IPv4('1.1.1.0', host=True)
+        # check that addreses are subsumed properly.
+        collapsed = ipaddr.collapse_address_list([ip1, ip2, ip3, ip4, ip5, ip6])
+        self.assertEqual(collapsed, [ipaddr.IPv4('1.1.1.0/30'),
+                                     ipaddr.IPv4('1.1.1.4/32')])
+
+        # test a mix of IP addresses and networks including some duplicates
+        ip1 = ipaddr.IPv4('1.1.1.0', host=True)
+        ip2 = ipaddr.IPv4('1.1.1.1', host=True)
+        ip3 = ipaddr.IPv4('1.1.1.2', host=True)
+        ip4 = ipaddr.IPv4('1.1.1.3', host=True)
+        ip5 = ipaddr.IPv4('1.1.1.4/30')
+        ip6 = ipaddr.IPv4('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.IPv4('1.1.1.0/29')])
+
+        # test only IP networks
         ip1 = ipaddr.IPv4('1.1.0.0/24')
         ip2 = ipaddr.IPv4('1.1.1.0/24')
         ip3 = ipaddr.IPv4('1.1.2.0/24')
         ip4 = ipaddr.IPv4('1.1.3.0/24')
         ip5 = ipaddr.IPv4('1.1.4.0/24')
         # stored in no particular order b/c we want CollapseAddr to call [].sort
         ip6 = ipaddr.IPv4('1.1.0.0/22')
-        # check that addreses are subsumed properlly.
+        # check that addreses are subsumed properly.
         collapsed = ipaddr.collapse_address_list([ip1, ip2, ip3, ip4, ip5, ip6])
         self.assertEqual(collapsed, [ipaddr.IPv4('1.1.0.0/22'),
                                      ipaddr.IPv4('1.1.4.0/24')])
-        # test that two addresses are supernet'ed properlly
+
+        # test that two addresses are supernet'ed properly
         collapsed = ipaddr.collapse_address_list([ip1, ip2])
         self.assertEqual(collapsed, [ipaddr.IPv4('1.1.0.0/23')])
 
+        # test same IP networks
         ip_same1 = ip_same2 = ipaddr.IPv4('1.1.1.1/32')
+        self.assertEqual(ipaddr.collapse_address_list([ip_same1, ip_same2]),
+                         [ip_same1])
+
+        # test same IP addresses
+        ip_same1 = ip_same2 = ipaddr.IPv4('1.1.1.1', host=True)
         self.assertEqual(ipaddr.collapse_address_list([ip_same1, ip_same2]),
                          [ip_same1])
         ip1 = ipaddr.IPv6('::2001:1/100')
         ip2 = ipaddr.IPv6('::2002:1/120')
         ip3 = ipaddr.IPv6('::2001:1/96')
         # test that ipv6 addresses are subsumed properly.
         collapsed = ipaddr.collapse_address_list([ip1, ip2, ip3])
         self.assertEqual(collapsed, [ip3])
 
     def testSummarizing(self):
         ip = ipaddr.IP
         summarize = ipaddr.summarize_address_range
-        ip1 = ip('1.1.1.0')
-        ip2 = ip('1.1.1.255')
+        ip1 = ip('1.1.1.0', host=True)
+        ip2 = ip('1.1.1.255', host=True)
         # test a /24 is sumamrized properly
         self.assertEqual(summarize(ip1, ip2)[0], ip('1.1.1.0/24'))
         # test an  IPv4 range that isn't on a network byte boundary
-        ip2 = ip('1.1.1.8')
+        ip2 = ip('1.1.1.8', host=True)
         self.assertEqual(summarize(ip1, ip2), [ip('1.1.1.0/29'), ip('1.1.1.8')])
 
-        ip1 = ip('1::')
-        ip2 = ip('1:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
+        ip1 = ip('1::', host=True)
+        ip2 = ip('1:ffff:ffff:ffff:ffff:ffff:ffff:ffff', host=True)
         # test a IPv6 is sumamrized properly
         self.assertEqual(summarize(ip1, ip2)[0], ip('1::/16'))
         # test an IPv6 range that isn't on a network byte boundary
-        ip2 = ip('2::')
+        ip2 = ip('2::', host=True)
         self.assertEqual(summarize(ip1, ip2), [ip('1::/16'), ip('2::/128')])
 
-        self.assertRaises(ValueError, summarize, ip('1.1.1.0'), ip('1.1.0.0'))
-        self.assertRaises(ValueError, summarize, ip('::'), ip('1.1.0.0'))
+        # test exception raised when first is greater than last
+        self.assertRaises(ValueError, summarize, ip('1.1.1.0', host=True),
+            ip('1.1.0.0', host=True))
+        # test exception raised when first and last aren't IP addresses
+        self.assertRaises(ipaddr.IPTypeError, summarize, ip('1.1.1.0'),
+            ip('1.1.0.0'))
+        self.assertRaises(ipaddr.IPTypeError, summarize,
+            ip('1.1.1.0', host=True), ip('1.1.0.0'))
+        # test exception raised when first and last are not same version
+        self.assertRaises(ipaddr.IPTypeError, summarize, ip('::', host=True),
+            ip('1.1.0.0', host=True))
 
     def testNetworkComparison(self):
         # ip1 and ip2 have the same network address
         ip1 = ipaddr.IPv4('1.1.1.0/24')
         ip2 = ipaddr.IPv4('1.1.1.1/24')
         ip3 = ipaddr.IPv4('1.1.2.0/24')
 
         self.assertTrue(ip1 < ip3)
         self.assertTrue(ip3 > ip2)
 
@@ skipping 12 matching lines @@
         self.assertTrue(ip1._get_networks_key() == ip2._get_networks_key())
         self.assertEquals(ip1.compare_networks(ip3), -1)
         self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
 
         # Test comparing different protocols
         ipv6 = ipaddr.IPv6('::/0')
         ipv4 = ipaddr.IPv4('0.0.0.0/0')
         self.assertTrue(ipv6 > ipv4)
         self.assertTrue(ipv4 < ipv6)
 
+        # Regression test for issue 19.
+        ip1 = ipaddr.IP('10.1.2.128/25')
+        self.assertFalse(ip1 < ip1)
+        self.assertFalse(ip1 > ip1)
+        ip2 = ipaddr.IP('10.1.3.0/24')
+        self.assertTrue(ip1 < ip2)
+        self.assertFalse(ip2 < ip1)
+        self.assertFalse(ip1 > ip2)
+        self.assertTrue(ip2 > ip1)
+        ip3 = ipaddr.IP('10.1.3.0/25')
+        self.assertTrue(ip2 < ip3)
+        self.assertFalse(ip3 < ip2)
+        self.assertFalse(ip2 > ip3)
+        self.assertTrue(ip3 > ip2)
+
     def testEmbeddedIpv4(self):
         ipv4_string = '192.168.0.1'
         ipv4 = ipaddr.IPv4(ipv4_string)
         v4compat_ipv6 = ipaddr.IPv6('::%s' % ipv4_string)
-        self.assertEquals(v4compat_ipv6.ip, ipv4.ip)
+        self.assertEquals(int(v4compat_ipv6.ip), int(ipv4.ip))
         v4mapped_ipv6 = ipaddr.IPv6('::ffff:%s' % ipv4_string)
         self.assertNotEquals(v4mapped_ipv6.ip, ipv4.ip)
         self.assertRaises(ipaddr.IPv6IpValidationError, ipaddr.IPv6,
                           '2001:1.1.1.1:1.1.1.1')
 
     def testIPVersion(self):
         self.assertEqual(self.ipv4.version, 4)
         self.assertEqual(self.ipv6.version, 6)
 
     def testPacked(self):
         self.assertEqual(self.ipv4.packed,
                          _cb('\x01\x02\x03\x04'))
         self.assertEqual(ipaddr.IPv4('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.IPv6('ffff:2:3:4:ffff::').packed,
                          _cb('\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff'
                             + '\x00' * 6))
         self.assertEqual(ipaddr.IPv6('::1:0:0:0:0').packed,
                          _cb('\x00' * 6 + '\x00\x01' + '\x00' * 8))
 
     def testIpStrFromPrefixlen(self):
         ipv4 = ipaddr.IPv4('1.2.3.4/24')
         self.assertEquals(ipv4._ip_string_from_prefix(), '255.255.255.0')
         self.assertEquals(ipv4._ip_string_from_prefix(28), '255.255.255.240')
 
     def testIpType(self):
-        ipv4 = ipaddr.IP('1.2.3.4')
-        ipv6 = ipaddr.IP('::1.2.3.4')
-        self.assertEquals(ipaddr.IPv4, type(ipv4))
-        self.assertEquals(ipaddr.IPv6, type(ipv6))
+        ipv4net = ipaddr.IP('1.2.3.4')
+        ipv4addr = ipaddr.IP('1.2.3.4', host=True)
+        ipv6net = ipaddr.IP('::1.2.3.4')
+        ipv6addr = ipaddr.IP('::1.2.3.4', host=True)
+        self.assertEquals(ipaddr.IPv4Network, type(ipv4net))
+        self.assertEquals(ipaddr.IPv4Address, type(ipv4addr))
+        self.assertEquals(ipaddr.IPv6Network, type(ipv6net))
+        self.assertEquals(ipaddr.IPv6Address, type(ipv6addr))
 
     def testReservedIpv4(self):
         self.assertEquals(True, ipaddr.IP('224.1.1.1/31').is_multicast)
         self.assertEquals(False, ipaddr.IP('240.0.0.0').is_multicast)
 
         self.assertEquals(True, ipaddr.IP('192.168.1.1/17').is_private)
         self.assertEquals(False, ipaddr.IP('192.169.0.0').is_private)
         self.assertEquals(True, ipaddr.IP('10.255.255.255').is_private)
         self.assertEquals(False, ipaddr.IP('11.0.0.0').is_private)
         self.assertEquals(True, ipaddr.IP('172.31.255.255').is_private)
@@ skipping 43 matching lines @@
         addr2 = ipaddr.IP('10.1.1.0/26')
         addr3 = ipaddr.IP('10.2.1.0/24')
         self.assertEqual(addr1.address_exclude(addr2),
                          [ipaddr.IP('10.1.1.64/26'),
                           ipaddr.IP('10.1.1.128/25')])
         self.assertRaises(ValueError, addr1.address_exclude, addr3)
 
     def testHash(self):
         self.assertEquals(hash(ipaddr.IP('10.1.1.0/24')),
                           hash(ipaddr.IP('10.1.1.0/24')))
+        self.assertEquals(hash(ipaddr.IP('10.1.1.0', host=True)),
+                          hash(ipaddr.IP('10.1.1.0', host=True)))
+        ip1 = ipaddr.IP('10.1.1.0', host=True)
+        ip2 = ipaddr.IP('1::', host=True)
         dummy = {}
         dummy[self.ipv4] = None
         dummy[self.ipv6] = None
+        dummy[ip1] = None
+        dummy[ip2] = None
         self.assertTrue(self.ipv4 in dummy)
+        self.assertTrue(ip2 in dummy)
 
     def testIPv4PrefixFromInt(self):
         addr1 = ipaddr.IP('10.1.1.0/24')
-        addr2 = ipaddr.IPv4(addr1.ip)  # clone prefix
+        addr2 = ipaddr.IPv4(int(addr1.ip))  # clone prefix
         addr2.set_prefix(addr1.prefixlen)
         addr3 = ipaddr.IP(123456)
 
-        self.assertEqual(123456, addr3.ip)
+        self.assertEqual(123456, int(addr3.ip))
         self.assertRaises(ipaddr.IPv4NetmaskValidationError,
                           addr2.set_prefix, -1L)
         self.assertEqual(addr1, addr2)
         self.assertEqual(str(addr1), str(addr2))
 
     def testIPv6PrefixFromInt(self):
         addr1 = ipaddr.IP('2001:0658:022a:cafe:0200::1/64')
         addr2 = ipaddr.IPv6(addr1.ip)  # clone prefix
         addr2.set_prefix(addr1.prefixlen)
         addr3 = ipaddr.IP(123456)
 
-        self.assertEqual(123456, addr3.ip)
+        self.assertEqual(123456, int(addr3.ip))
         self.assertRaises(ipaddr.IPv6NetmaskValidationError,
                           addr2.set_prefix, -1L)
         self.assertEqual(addr1, addr2)
         self.assertEqual(str(addr1), str(addr2))
 
     def testCopyConstructor(self):
         addr1 = ipaddr.IP('10.1.1.0/24')
         addr2 = ipaddr.IP(addr1)
         addr3 = ipaddr.IP('2001:658:22a:cafe:200::1/64')
         addr4 = ipaddr.IP(addr3)
@@ skipping 17 matching lines @@
             '0:0:0:0:0:0:0:1': '::1/128',
             '2001:0658:022a:cafe:0000:0000:0000:0000/66':
             '2001:658:22a:cafe::/66',
             }
         for uncompressed, compressed in test_addresses.items():
             self.assertEquals(compressed, str(ipaddr.IPv6(uncompressed)))
 
     def testExplodeShortHandIpStr(self):
         addr1 = ipaddr.IPv6('2001::1')
         self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0001',
-                         addr1._explode_shorthand_ip_string(addr1.ip_ext))
+                         addr1._explode_shorthand_ip_string(str(addr1.ip)))
 
     def testIntRepresentation(self):
         self.assertEqual(16909060, int(self.ipv4))
         self.assertEqual(42540616829182469433547762482097946625, int(self.ipv6))
 
     def testHexRepresentation(self):
-        self.assertEqual(hex(0x1020304), hex(self.ipv4))
+        self.assertEqual(hex(0x1020304),
+                         hex(self.ipv4))
 
         self.assertEqual(hex(0x20010658022ACAFE0200000000000001),
                          hex(self.ipv6))
 
     # backwards compatibility
     def testBackwardsCompability(self):
         ip = ipaddr.IP
 
         self.assertEqual(ipaddr.CollapseAddrList(
                             [ip('1.1.0.0/24'), ip('1.1.1.0/24')]),
@@ skipping 19 matching lines @@
         self.assertEqual(ip('::/127').Subnet(), [ip('::/128'), ip('::1/128')])
 
         self.assertEqual(ip('1.0.0.0/32').Supernet(), ip('1.0.0.0/31'))
         self.assertEqual(ip('::/121').Supernet(), ip('::/120'))
 
         self.assertEqual(ip('10.0.0.02').IsRFC1918(), True)
         self.assertEqual(ip('10.0.0.0').IsMulticast(), False)
         self.assertEqual(ip('127.255.255.255').IsLoopback(), True)
         self.assertEqual(ip('169.255.255.255').IsLinkLocal(), False)
 
+    def testChangingPrefixlength(self):
+        self.ipv4.prefixlen = 23
+        self.assertEqual(self.ipv4.network,
+                         ipaddr.IPv4Address('1.2.2.0'))
+        self.assertEqual(self.ipv4.broadcast,
+                         ipaddr.IPv4Address('1.2.3.255'))
+        self.assertEqual(self.ipv4.numhosts, 512)
+
+        #ipaddr.IPv6('2001:658:22a:cafe:200:0:0:1/64')
+        self.ipv6.prefixlen = 32
+        self.assertEqual(self.ipv6.network,
+                         ipaddr.IPv6Address('2001:658::'))
+        self.assertEqual(self.ipv6.broadcast,
+                         ipaddr.IPv6Address(
+            '2001:658:ffff:ffff:ffff:ffff:ffff:ffff'))
+
+    def testForceVersion(self):
+        self.assertEqual(ipaddr.IP(1).version, 4)
+        self.assertEqual(ipaddr.IP(1, version=6).version, 6)
+
+    def testWithStar(self):
+        self.assertEqual(str(self.ipv4.with_prefixlen), "1.2.3.4/24")
+        self.assertEqual(str(self.ipv4.with_netmask), "1.2.3.4/255.255.255.0")
+        self.assertEqual(str(self.ipv4.with_hostmask), "1.2.3.4/0.0.0.255")
+
+        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
+        self.assertEqual(str(self.ipv6.with_netmask),
+                         '2001:658:22a:cafe:200::1/ffff:ffff:ffff:ffff::')
+        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'))
+
+        # V4 - populate and test
+        self.assertEqual(self.ipv4.network, ipaddr.IPv4Address('1.2.3.0'))
+        self.assertEqual(self.ipv4.broadcast, ipaddr.IPv4Address('1.2.3.255'))
+        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'))
+
+        # 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'))
+
+        # V6 - populate and test
+        self.assertEqual(self.ipv6.network,
+                         ipaddr.IPv6Address('2001:658:22a:cafe::'))
+        self.assertEqual(self.ipv6.broadcast, ipaddr.IPv6Address(
+            '2001:658:22a:cafe:ffff:ffff:ffff:ffff'))
+        self.assertEqual(self.ipv6.hostmask,
+                         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'))
+
+
 if __name__ == '__main__':
     unittest.main()