sdk/platform-tools/systrace/catapult/telemetry/third_party/web-page-replay/third_party/ipaddr/ipaddr_test.py

   1 #!/usr/bin/python
   2 #
   3 # Copyright 2007 Google Inc.
   4 #  Licensed to PSF under a Contributor Agreement.
   5 #
   6 # Licensed under the Apache License, Version 2.0 (the "License");
   7 # you may not use this file except in compliance with the License.
   8 # You may obtain a copy of the License at
   9 #
  10 #      http://www.apache.org/licenses/LICENSE-2.0
  11 #
  12 # Unless required by applicable law or agreed to in writing, software
  13 # distributed under the License is distributed on an "AS IS" BASIS,
  14 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 # See the License for the specific language governing permissions and
  16 # limitations under the License.
  17
  18 """Unittest for ipaddr module."""
  19
  20
  21 import unittest
  22 import time
  23 import ipaddr
  24
  25 # Compatibility function to cast str to bytes objects
  26 if issubclass(ipaddr.Bytes, str):
  27     _cb = ipaddr.Bytes
  28 else:
  29     _cb = lambda bytestr: bytes(bytestr, 'charmap')
  30
  31 class IpaddrUnitTest(unittest.TestCase):
  32
  33     def setUp(self):
  34         self.ipv4 = ipaddr.IPv4Network('1.2.3.4/24')
  35         self.ipv4_hostmask = ipaddr.IPv4Network('10.0.0.1/0.255.255.255')
  36         self.ipv6 = ipaddr.IPv6Network('2001:658:22a:cafe:200:0:0:1/64')
  37
  38     def tearDown(self):
  39         del(self.ipv4)
  40         del(self.ipv4_hostmask)
  41         del(self.ipv6)
  42         del(self)
  43
  44     def testRepr(self):
  45         self.assertEqual("IPv4Network('1.2.3.4/32')",
  46                          repr(ipaddr.IPv4Network('1.2.3.4')))
  47         self.assertEqual("IPv6Network('::1/128')",
  48                          repr(ipaddr.IPv6Network('::1')))
  49
  50     def testAutoMasking(self):
  51         addr1 = ipaddr.IPv4Network('1.1.1.255/24')
  52         addr1_masked = ipaddr.IPv4Network('1.1.1.0/24')
  53         self.assertEqual(addr1_masked, addr1.masked())
  54
  55         addr2 = ipaddr.IPv6Network('2000:cafe::efac:100/96')
  56         addr2_masked = ipaddr.IPv6Network('2000:cafe::/96')
  57         self.assertEqual(addr2_masked, addr2.masked())
  58
  59     # issue57
  60     def testAddressIntMath(self):
  61         self.assertEqual(ipaddr.IPv4Address('1.1.1.1') + 255,
  62                          ipaddr.IPv4Address('1.1.2.0'))
  63         self.assertEqual(ipaddr.IPv4Address('1.1.1.1') - 256,
  64                          ipaddr.IPv4Address('1.1.0.1'))
  65         self.assertEqual(ipaddr.IPv6Address('::1') + (2**16 - 2),
  66                          ipaddr.IPv6Address('::ffff'))
  67         self.assertEqual(ipaddr.IPv6Address('::ffff') - (2**16 - 2),
  68                          ipaddr.IPv6Address('::1'))
  69
  70     def testInvalidStrings(self):
  71         def AssertInvalidIP(ip_str):
  72             self.assertRaises(ValueError, ipaddr.IPAddress, ip_str)
  73         AssertInvalidIP("")
  74         AssertInvalidIP("016.016.016.016")
  75         AssertInvalidIP("016.016.016")
  76         AssertInvalidIP("016.016")
  77         AssertInvalidIP("016")
  78         AssertInvalidIP("000.000.000.000")
  79         AssertInvalidIP("000")
  80         AssertInvalidIP("0x0a.0x0a.0x0a.0x0a")
  81         AssertInvalidIP("0x0a.0x0a.0x0a")
  82         AssertInvalidIP("0x0a.0x0a")
  83         AssertInvalidIP("0x0a")
  84         AssertInvalidIP("42.42.42.42.42")
  85         AssertInvalidIP("42.42.42")
  86         AssertInvalidIP("42.42")
  87         AssertInvalidIP("42")
  88         AssertInvalidIP("42..42.42")
  89         AssertInvalidIP("42..42.42.42")
  90         AssertInvalidIP("42.42.42.42.")
  91         AssertInvalidIP("42.42.42.42...")
  92         AssertInvalidIP(".42.42.42.42")
  93         AssertInvalidIP("...42.42.42.42")
  94         AssertInvalidIP("42.42.42.-0")
  95         AssertInvalidIP("42.42.42.+0")
  96         AssertInvalidIP(".")
  97         AssertInvalidIP("...")
  98         AssertInvalidIP("bogus")
  99         AssertInvalidIP("bogus.com")
 100         AssertInvalidIP("192.168.0.1.com")
 101         AssertInvalidIP("12345.67899.-54321.-98765")
 102         AssertInvalidIP("257.0.0.0")
 103         AssertInvalidIP("42.42.42.-42")
 104         AssertInvalidIP("3ffe::1.net")
 105         AssertInvalidIP("3ffe::1::1")
 106         AssertInvalidIP("1::2::3::4:5")
 107         AssertInvalidIP("::7:6:5:4:3:2:")
 108         AssertInvalidIP(":6:5:4:3:2:1::")
 109         AssertInvalidIP("2001::db:::1")
 110         AssertInvalidIP("FEDC:9878")
 111         AssertInvalidIP("+1.+2.+3.4")
 112         AssertInvalidIP("1.2.3.4e0")
 113         AssertInvalidIP("::7:6:5:4:3:2:1:0")
 114         AssertInvalidIP("7:6:5:4:3:2:1:0::")
 115         AssertInvalidIP("9:8:7:6:5:4:3::2:1")
 116         AssertInvalidIP("0:1:2:3::4:5:6:7")
 117         AssertInvalidIP("3ffe:0:0:0:0:0:0:0:1")
 118         AssertInvalidIP("3ffe::10000")
 119         AssertInvalidIP("3ffe::goog")
 120         AssertInvalidIP("3ffe::-0")
 121         AssertInvalidIP("3ffe::+0")
 122         AssertInvalidIP("3ffe::-1")
 123         AssertInvalidIP(":")
 124         AssertInvalidIP(":::")
 125         AssertInvalidIP("::1.2.3")
 126         AssertInvalidIP("::1.2.3.4.5")
 127         AssertInvalidIP("::1.2.3.4:")
 128         AssertInvalidIP("1.2.3.4::")
 129         AssertInvalidIP("2001:db8::1:")
 130         AssertInvalidIP(":2001:db8::1")
 131         AssertInvalidIP(":1:2:3:4:5:6:7")
 132         AssertInvalidIP("1:2:3:4:5:6:7:")
 133         AssertInvalidIP(":1:2:3:4:5:6:")
 134         AssertInvalidIP("192.0.2.1/32")
 135         AssertInvalidIP("2001:db8::1/128")
 136
 137         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Network, '')
 138         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Network,
 139                           'google.com')
 140         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Network,
 141                           '::1.2.3.4')
 142         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network, '')
 143         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network,
 144                           'google.com')
 145         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network,
 146                           '1.2.3.4')
 147         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network,
 148                           'cafe:cafe::/128/190')
 149         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network,
 150                           '1234:axy::b')
 151         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Address,
 152                           '1234:axy::b')
 153         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Address,
 154                           '2001:db8:::1')
 155         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Address,
 156                           '2001:888888::1')
 157         self.assertRaises(ipaddr.AddressValueError,
 158                           ipaddr.IPv4Address(1)._ip_int_from_string,
 159                           '1.a.2.3')
 160         self.assertEqual(False, ipaddr.IPv4Network(1)._is_hostmask('1.a.2.3'))
 161
 162     def testGetNetwork(self):
 163         self.assertEqual(int(self.ipv4.network), 16909056)
 164         self.assertEqual(str(self.ipv4.network), '1.2.3.0')
 165         self.assertEqual(str(self.ipv4_hostmask.network), '10.0.0.0')
 166
 167         self.assertEqual(int(self.ipv6.network),
 168                          42540616829182469433403647294022090752)
 169         self.assertEqual(str(self.ipv6.network),
 170                          '2001:658:22a:cafe::')
 171         self.assertEqual(str(self.ipv6.hostmask),
 172                          '::ffff:ffff:ffff:ffff')
 173
 174     def testBadVersionComparison(self):
 175         # These should always raise TypeError
 176         v4addr = ipaddr.IPAddress('1.1.1.1')
 177         v4net = ipaddr.IPNetwork('1.1.1.1')
 178         v6addr = ipaddr.IPAddress('::1')
 179         v6net = ipaddr.IPAddress('::1')
 180
 181         self.assertRaises(TypeError, v4addr.__lt__, v6addr)
 182         self.assertRaises(TypeError, v4addr.__gt__, v6addr)
 183         self.assertRaises(TypeError, v4net.__lt__, v6net)
 184         self.assertRaises(TypeError, v4net.__gt__, v6net)
 185
 186         self.assertRaises(TypeError, v6addr.__lt__, v4addr)
 187         self.assertRaises(TypeError, v6addr.__gt__, v4addr)
 188         self.assertRaises(TypeError, v6net.__lt__, v4net)
 189         self.assertRaises(TypeError, v6net.__gt__, v4net)
 190
 191     def testMixedTypeComparison(self):
 192         v4addr = ipaddr.IPAddress('1.1.1.1')
 193         v4net = ipaddr.IPNetwork('1.1.1.1/32')
 194         v6addr = ipaddr.IPAddress('::1')
 195         v6net = ipaddr.IPNetwork('::1/128')
 196
 197         self.assertFalse(v4net.__contains__(v6net))
 198         self.assertFalse(v6net.__contains__(v4net))
 199
 200         self.assertRaises(TypeError, lambda: v4addr < v4net)
 201         self.assertRaises(TypeError, lambda: v4addr > v4net)
 202         self.assertRaises(TypeError, lambda: v4net < v4addr)
 203         self.assertRaises(TypeError, lambda: v4net > v4addr)
 204
 205         self.assertRaises(TypeError, lambda: v6addr < v6net)
 206         self.assertRaises(TypeError, lambda: v6addr > v6net)
 207         self.assertRaises(TypeError, lambda: v6net < v6addr)
 208         self.assertRaises(TypeError, lambda: v6net > v6addr)
 209
 210         # with get_mixed_type_key, you can sort addresses and network.
 211         self.assertEqual([v4addr, v4net], sorted([v4net, v4addr],
 212                                                  key=ipaddr.get_mixed_type_key))
 213         self.assertEqual([v6addr, v6net], sorted([v6net, v6addr],
 214                                                  key=ipaddr.get_mixed_type_key))
 215
 216     def testIpFromInt(self):
 217         self.assertEqual(self.ipv4.ip, ipaddr.IPv4Network(16909060).ip)
 218         self.assertRaises(ipaddr.AddressValueError,
 219                           ipaddr.IPv4Network, 2**32)
 220         self.assertRaises(ipaddr.AddressValueError,
 221                           ipaddr.IPv4Network, -1)
 222
 223         ipv4 = ipaddr.IPNetwork('1.2.3.4')
 224         ipv6 = ipaddr.IPNetwork('2001:658:22a:cafe:200:0:0:1')
 225         self.assertEqual(ipv4, ipaddr.IPNetwork(int(ipv4)))
 226         self.assertEqual(ipv6, ipaddr.IPNetwork(int(ipv6)))
 227
 228         v6_int = 42540616829182469433547762482097946625
 229         self.assertEqual(self.ipv6.ip, ipaddr.IPv6Network(v6_int).ip)
 230         self.assertRaises(ipaddr.AddressValueError,
 231                           ipaddr.IPv6Network, 2**128)
 232         self.assertRaises(ipaddr.AddressValueError,
 233                           ipaddr.IPv6Network, -1)
 234
 235         self.assertEqual(ipaddr.IPNetwork(self.ipv4.ip).version, 4)
 236         self.assertEqual(ipaddr.IPNetwork(self.ipv6.ip).version, 6)
 237
 238     def testIpFromPacked(self):
 239         ip = ipaddr.IPNetwork
 240
 241         self.assertEqual(self.ipv4.ip,
 242                          ip(_cb('\x01\x02\x03\x04')).ip)
 243         self.assertEqual(ip('255.254.253.252'),
 244                          ip(_cb('\xff\xfe\xfd\xfc')))
 245         self.assertRaises(ValueError, ipaddr.IPNetwork, _cb('\x00' * 3))
 246         self.assertRaises(ValueError, ipaddr.IPNetwork, _cb('\x00' * 5))
 247         self.assertEqual(self.ipv6.ip,
 248                          ip(_cb('\x20\x01\x06\x58\x02\x2a\xca\xfe'
 249                            '\x02\x00\x00\x00\x00\x00\x00\x01')).ip)
 250         self.assertEqual(ip('ffff:2:3:4:ffff::'),
 251                          ip(_cb('\xff\xff\x00\x02\x00\x03\x00\x04' +
 252                                '\xff\xff' + '\x00' * 6)))
 253         self.assertEqual(ip('::'),
 254                          ip(_cb('\x00' * 16)))
 255         self.assertRaises(ValueError, ip, _cb('\x00' * 15))
 256         self.assertRaises(ValueError, ip, _cb('\x00' * 17))
 257
 258     def testGetIp(self):
 259         self.assertEqual(int(self.ipv4.ip), 16909060)
 260         self.assertEqual(str(self.ipv4.ip), '1.2.3.4')
 261         self.assertEqual(str(self.ipv4_hostmask.ip), '10.0.0.1')
 262
 263         self.assertEqual(int(self.ipv6.ip),
 264                          42540616829182469433547762482097946625)
 265         self.assertEqual(str(self.ipv6.ip),
 266                          '2001:658:22a:cafe:200::1')
 267
 268     def testGetNetmask(self):
 269         self.assertEqual(int(self.ipv4.netmask), 4294967040L)
 270         self.assertEqual(str(self.ipv4.netmask), '255.255.255.0')
 271         self.assertEqual(str(self.ipv4_hostmask.netmask), '255.0.0.0')
 272         self.assertEqual(int(self.ipv6.netmask),
 273                          340282366920938463444927863358058659840)
 274         self.assertEqual(self.ipv6.prefixlen, 64)
 275
 276     def testZeroNetmask(self):
 277         ipv4_zero_netmask = ipaddr.IPv4Network('1.2.3.4/0')
 278         self.assertEqual(int(ipv4_zero_netmask.netmask), 0)
 279         self.assertTrue(ipv4_zero_netmask._is_valid_netmask(str(0)))
 280
 281         ipv6_zero_netmask = ipaddr.IPv6Network('::1/0')
 282         self.assertEqual(int(ipv6_zero_netmask.netmask), 0)
 283         self.assertTrue(ipv6_zero_netmask._is_valid_netmask(str(0)))
 284
 285     def testGetBroadcast(self):
 286         self.assertEqual(int(self.ipv4.broadcast), 16909311L)
 287         self.assertEqual(str(self.ipv4.broadcast), '1.2.3.255')
 288
 289         self.assertEqual(int(self.ipv6.broadcast),
 290                          42540616829182469451850391367731642367)
 291         self.assertEqual(str(self.ipv6.broadcast),
 292                          '2001:658:22a:cafe:ffff:ffff:ffff:ffff')
 293
 294     def testGetPrefixlen(self):
 295         self.assertEqual(self.ipv4.prefixlen, 24)
 296
 297         self.assertEqual(self.ipv6.prefixlen, 64)
 298
 299     def testGetSupernet(self):
 300         self.assertEqual(self.ipv4.supernet().prefixlen, 23)
 301         self.assertEqual(str(self.ipv4.supernet().network), '1.2.2.0')
 302         self.assertEqual(ipaddr.IPv4Network('0.0.0.0/0').supernet(),
 303                          ipaddr.IPv4Network('0.0.0.0/0'))
 304
 305         self.assertEqual(self.ipv6.supernet().prefixlen, 63)
 306         self.assertEqual(str(self.ipv6.supernet().network),
 307                          '2001:658:22a:cafe::')
 308         self.assertEqual(ipaddr.IPv6Network('::0/0').supernet(),
 309                          ipaddr.IPv6Network('::0/0'))
 310
 311     def testGetSupernet3(self):
 312         self.assertEqual(self.ipv4.supernet(3).prefixlen, 21)
 313         self.assertEqual(str(self.ipv4.supernet(3).network), '1.2.0.0')
 314
 315         self.assertEqual(self.ipv6.supernet(3).prefixlen, 61)
 316         self.assertEqual(str(self.ipv6.supernet(3).network),
 317                          '2001:658:22a:caf8::')
 318
 319     def testGetSupernet4(self):
 320         self.assertRaises(ValueError, self.ipv4.supernet, prefixlen_diff=2,
 321                           new_prefix=1)
 322         self.assertRaises(ValueError, self.ipv4.supernet, new_prefix=25)
 323         self.assertEqual(self.ipv4.supernet(prefixlen_diff=2),
 324                          self.ipv4.supernet(new_prefix=22))
 325
 326         self.assertRaises(ValueError, self.ipv6.supernet, prefixlen_diff=2,
 327                           new_prefix=1)
 328         self.assertRaises(ValueError, self.ipv6.supernet, new_prefix=65)
 329         self.assertEqual(self.ipv6.supernet(prefixlen_diff=2),
 330                          self.ipv6.supernet(new_prefix=62))
 331
 332     def testIterSubnets(self):
 333         self.assertEqual(self.ipv4.subnet(), list(self.ipv4.iter_subnets()))
 334         self.assertEqual(self.ipv6.subnet(), list(self.ipv6.iter_subnets()))
 335
 336     def testIterHosts(self):
 337         self.assertEqual([ipaddr.IPv4Address('2.0.0.0'),
 338                           ipaddr.IPv4Address('2.0.0.1')],
 339                          list(ipaddr.IPNetwork('2.0.0.0/31').iterhosts()))
 340
 341     def testFancySubnetting(self):
 342         self.assertEqual(sorted(self.ipv4.subnet(prefixlen_diff=3)),
 343                          sorted(self.ipv4.subnet(new_prefix=27)))
 344         self.assertRaises(ValueError, self.ipv4.subnet, new_prefix=23)
 345         self.assertRaises(ValueError, self.ipv4.subnet,
 346                           prefixlen_diff=3, new_prefix=27)
 347         self.assertEqual(sorted(self.ipv6.subnet(prefixlen_diff=4)),
 348                          sorted(self.ipv6.subnet(new_prefix=68)))
 349         self.assertRaises(ValueError, self.ipv6.subnet, new_prefix=63)
 350         self.assertRaises(ValueError, self.ipv6.subnet,
 351                           prefixlen_diff=4, new_prefix=68)
 352
 353     def testGetSubnet(self):
 354         self.assertEqual(self.ipv4.subnet()[0].prefixlen, 25)
 355         self.assertEqual(str(self.ipv4.subnet()[0].network), '1.2.3.0')
 356         self.assertEqual(str(self.ipv4.subnet()[1].network), '1.2.3.128')
 357
 358         self.assertEqual(self.ipv6.subnet()[0].prefixlen, 65)
 359
 360     def testGetSubnetForSingle32(self):
 361         ip = ipaddr.IPv4Network('1.2.3.4/32')
 362         subnets1 = [str(x) for x in ip.subnet()]
 363         subnets2 = [str(x) for x in ip.subnet(2)]
 364         self.assertEqual(subnets1, ['1.2.3.4/32'])
 365         self.assertEqual(subnets1, subnets2)
 366
 367     def testGetSubnetForSingle128(self):
 368         ip = ipaddr.IPv6Network('::1/128')
 369         subnets1 = [str(x) for x in ip.subnet()]
 370         subnets2 = [str(x) for x in ip.subnet(2)]
 371         self.assertEqual(subnets1, ['::1/128'])
 372         self.assertEqual(subnets1, subnets2)
 373
 374     def testSubnet2(self):
 375         ips = [str(x) for x in self.ipv4.subnet(2)]
 376         self.assertEqual(
 377             ips,
 378             ['1.2.3.0/26', '1.2.3.64/26', '1.2.3.128/26', '1.2.3.192/26'])
 379
 380         ipsv6 = [str(x) for x in self.ipv6.subnet(2)]
 381         self.assertEqual(
 382             ipsv6,
 383             ['2001:658:22a:cafe::/66',
 384              '2001:658:22a:cafe:4000::/66',
 385              '2001:658:22a:cafe:8000::/66',
 386              '2001:658:22a:cafe:c000::/66'])
 387
 388     def testSubnetFailsForLargeCidrDiff(self):
 389         self.assertRaises(ValueError, self.ipv4.subnet, 9)
 390         self.assertRaises(ValueError, self.ipv6.subnet, 65)
 391
 392     def testSupernetFailsForLargeCidrDiff(self):
 393         self.assertRaises(ValueError, self.ipv4.supernet, 25)
 394         self.assertRaises(ValueError, self.ipv6.supernet, 65)
 395
 396     def testSubnetFailsForNegativeCidrDiff(self):
 397         self.assertRaises(ValueError, self.ipv4.subnet, -1)
 398         self.assertRaises(ValueError, self.ipv6.subnet, -1)
 399
 400     def testGetNumHosts(self):
 401         self.assertEqual(self.ipv4.numhosts, 256)
 402         self.assertEqual(self.ipv4.subnet()[0].numhosts, 128)
 403         self.assertEqual(self.ipv4.supernet().numhosts, 512)
 404
 405         self.assertEqual(self.ipv6.numhosts, 18446744073709551616)
 406         self.assertEqual(self.ipv6.subnet()[0].numhosts, 9223372036854775808)
 407         self.assertEqual(self.ipv6.supernet().numhosts, 36893488147419103232)
 408
 409     def testContains(self):
 410         self.assertTrue(ipaddr.IPv4Network('1.2.3.128/25') in self.ipv4)
 411         self.assertFalse(ipaddr.IPv4Network('1.2.4.1/24') in self.ipv4)
 412         self.assertTrue(self.ipv4 in self.ipv4)
 413         self.assertTrue(self.ipv6 in self.ipv6)
 414         # We can test addresses and string as well.
 415         addr1 = ipaddr.IPv4Address('1.2.3.37')
 416         self.assertTrue(addr1 in self.ipv4)
 417         # issue 61, bad network comparison on like-ip'd network objects
 418         # with identical broadcast addresses.
 419         self.assertFalse(ipaddr.IPv4Network('1.1.0.0/16').__contains__(
 420                 ipaddr.IPv4Network('1.0.0.0/15')))
 421
 422     def testBadAddress(self):
 423         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv4Network,
 424                           'poop')
 425         self.assertRaises(ipaddr.AddressValueError,
 426                           ipaddr.IPv4Network, '1.2.3.256')
 427
 428         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network,
 429                           'poopv6')
 430         self.assertRaises(ipaddr.AddressValueError,
 431                           ipaddr.IPv4Network, '1.2.3.4/32/24')
 432         self.assertRaises(ipaddr.AddressValueError,
 433                           ipaddr.IPv4Network, '10/8')
 434         self.assertRaises(ipaddr.AddressValueError,
 435                           ipaddr.IPv6Network, '10/8')
 436
 437
 438     def testBadNetMask(self):
 439         self.assertRaises(ipaddr.NetmaskValueError,
 440                           ipaddr.IPv4Network, '1.2.3.4/')
 441         self.assertRaises(ipaddr.NetmaskValueError,
 442                           ipaddr.IPv4Network, '1.2.3.4/33')
 443         self.assertRaises(ipaddr.NetmaskValueError,
 444                           ipaddr.IPv4Network, '1.2.3.4/254.254.255.256')
 445         self.assertRaises(ipaddr.NetmaskValueError,
 446                           ipaddr.IPv4Network, '1.1.1.1/240.255.0.0')
 447         self.assertRaises(ipaddr.NetmaskValueError,
 448                           ipaddr.IPv6Network, '::1/')
 449         self.assertRaises(ipaddr.NetmaskValueError,
 450                           ipaddr.IPv6Network, '::1/129')
 451
 452     def testNth(self):
 453         self.assertEqual(str(self.ipv4[5]), '1.2.3.5')
 454         self.assertRaises(IndexError, self.ipv4.__getitem__, 256)
 455
 456         self.assertEqual(str(self.ipv6[5]),
 457                          '2001:658:22a:cafe::5')
 458
 459     def testGetitem(self):
 460         # http://code.google.com/p/ipaddr-py/issues/detail?id=15
 461         addr = ipaddr.IPv4Network('172.31.255.128/255.255.255.240')
 462         self.assertEqual(28, addr.prefixlen)
 463         addr_list = list(addr)
 464         self.assertEqual('172.31.255.128', str(addr_list[0]))
 465         self.assertEqual('172.31.255.128', str(addr[0]))
 466         self.assertEqual('172.31.255.143', str(addr_list[-1]))
 467         self.assertEqual('172.31.255.143', str(addr[-1]))
 468         self.assertEqual(addr_list[-1], addr[-1])
 469
 470     def testEqual(self):
 471         self.assertTrue(self.ipv4 == ipaddr.IPv4Network('1.2.3.4/24'))
 472         self.assertFalse(self.ipv4 == ipaddr.IPv4Network('1.2.3.4/23'))
 473         self.assertFalse(self.ipv4 == ipaddr.IPv6Network('::1.2.3.4/24'))
 474         self.assertFalse(self.ipv4 == '')
 475         self.assertFalse(self.ipv4 == [])
 476         self.assertFalse(self.ipv4 == 2)
 477         self.assertTrue(ipaddr.IPNetwork('1.1.1.1/32') ==
 478                         ipaddr.IPAddress('1.1.1.1'))
 479         self.assertTrue(ipaddr.IPNetwork('1.1.1.1/24') ==
 480                         ipaddr.IPAddress('1.1.1.1'))
 481         self.assertFalse(ipaddr.IPNetwork('1.1.1.0/24') ==
 482                          ipaddr.IPAddress('1.1.1.1'))
 483
 484         self.assertTrue(self.ipv6 ==
 485             ipaddr.IPv6Network('2001:658:22a:cafe:200::1/64'))
 486         self.assertTrue(ipaddr.IPNetwork('::1/128') ==
 487                         ipaddr.IPAddress('::1'))
 488         self.assertTrue(ipaddr.IPNetwork('::1/127') ==
 489                         ipaddr.IPAddress('::1'))
 490         self.assertFalse(ipaddr.IPNetwork('::0/127') ==
 491                          ipaddr.IPAddress('::1'))
 492         self.assertFalse(self.ipv6 ==
 493             ipaddr.IPv6Network('2001:658:22a:cafe:200::1/63'))
 494         self.assertFalse(self.ipv6 == ipaddr.IPv4Network('1.2.3.4/23'))
 495         self.assertFalse(self.ipv6 == '')
 496         self.assertFalse(self.ipv6 == [])
 497         self.assertFalse(self.ipv6 == 2)
 498
 499     def testNotEqual(self):
 500         self.assertFalse(self.ipv4 != ipaddr.IPv4Network('1.2.3.4/24'))
 501         self.assertTrue(self.ipv4 != ipaddr.IPv4Network('1.2.3.4/23'))
 502         self.assertTrue(self.ipv4 != ipaddr.IPv6Network('::1.2.3.4/24'))
 503         self.assertTrue(self.ipv4 != '')
 504         self.assertTrue(self.ipv4 != [])
 505         self.assertTrue(self.ipv4 != 2)
 506
 507         addr2 = ipaddr.IPAddress('2001:658:22a:cafe:200::1')
 508         self.assertFalse(self.ipv6 !=
 509             ipaddr.IPv6Network('2001:658:22a:cafe:200::1/64'))
 510         self.assertTrue(self.ipv6 !=
 511             ipaddr.IPv6Network('2001:658:22a:cafe:200::1/63'))
 512         self.assertTrue(self.ipv6 != ipaddr.IPv4Network('1.2.3.4/23'))
 513         self.assertTrue(self.ipv6 != '')
 514         self.assertTrue(self.ipv6 != [])
 515         self.assertTrue(self.ipv6 != 2)
 516
 517     def testSlash32Constructor(self):
 518         self.assertEqual(str(ipaddr.IPv4Network('1.2.3.4/255.255.255.255')),
 519                           '1.2.3.4/32')
 520
 521     def testSlash128Constructor(self):
 522         self.assertEqual(str(ipaddr.IPv6Network('::1/128')),
 523                                   '::1/128')
 524
 525     def testSlash0Constructor(self):
 526         self.assertEqual(str(ipaddr.IPv4Network('1.2.3.4/0.0.0.0')),
 527                           '1.2.3.4/0')
 528
 529     def testCollapsing(self):
 530         # test only IP addresses including some duplicates
 531         ip1 = ipaddr.IPv4Address('1.1.1.0')
 532         ip2 = ipaddr.IPv4Address('1.1.1.1')
 533         ip3 = ipaddr.IPv4Address('1.1.1.2')
 534         ip4 = ipaddr.IPv4Address('1.1.1.3')
 535         ip5 = ipaddr.IPv4Address('1.1.1.4')
 536         ip6 = ipaddr.IPv4Address('1.1.1.0')
 537         # check that addreses are subsumed properly.
 538         collapsed = ipaddr.collapse_address_list([ip1, ip2, ip3, ip4, ip5, ip6])
 539         self.assertEqual(collapsed, [ipaddr.IPv4Network('1.1.1.0/30'),
 540                                      ipaddr.IPv4Network('1.1.1.4/32')])
 541
 542         # test a mix of IP addresses and networks including some duplicates
 543         ip1 = ipaddr.IPv4Address('1.1.1.0')
 544         ip2 = ipaddr.IPv4Address('1.1.1.1')
 545         ip3 = ipaddr.IPv4Address('1.1.1.2')
 546         ip4 = ipaddr.IPv4Address('1.1.1.3')
 547         ip5 = ipaddr.IPv4Network('1.1.1.4/30')
 548         ip6 = ipaddr.IPv4Network('1.1.1.4/30')
 549         # check that addreses are subsumed properly.
 550         collapsed = ipaddr.collapse_address_list([ip5, ip1, ip2, ip3, ip4, ip6])
 551         self.assertEqual(collapsed, [ipaddr.IPv4Network('1.1.1.0/29')])
 552
 553         # test only IP networks
 554         ip1 = ipaddr.IPv4Network('1.1.0.0/24')
 555         ip2 = ipaddr.IPv4Network('1.1.1.0/24')
 556         ip3 = ipaddr.IPv4Network('1.1.2.0/24')
 557         ip4 = ipaddr.IPv4Network('1.1.3.0/24')
 558         ip5 = ipaddr.IPv4Network('1.1.4.0/24')
 559         # stored in no particular order b/c we want CollapseAddr to call [].sort
 560         ip6 = ipaddr.IPv4Network('1.1.0.0/22')
 561         # check that addreses are subsumed properly.
 562         collapsed = ipaddr.collapse_address_list([ip1, ip2, ip3, ip4, ip5, ip6])
 563         self.assertEqual(collapsed, [ipaddr.IPv4Network('1.1.0.0/22'),
 564                                      ipaddr.IPv4Network('1.1.4.0/24')])
 565
 566         # test that two addresses are supernet'ed properly
 567         collapsed = ipaddr.collapse_address_list([ip1, ip2])
 568         self.assertEqual(collapsed, [ipaddr.IPv4Network('1.1.0.0/23')])
 569
 570         # test same IP networks
 571         ip_same1 = ip_same2 = ipaddr.IPv4Network('1.1.1.1/32')
 572         self.assertEqual(ipaddr.collapse_address_list([ip_same1, ip_same2]),
 573                          [ip_same1])
 574
 575         # test same IP addresses
 576         ip_same1 = ip_same2 = ipaddr.IPv4Address('1.1.1.1')
 577         self.assertEqual(ipaddr.collapse_address_list([ip_same1, ip_same2]),
 578                          [ipaddr.IPNetwork('1.1.1.1/32')])
 579         ip1 = ipaddr.IPv6Network('::2001:1/100')
 580         ip2 = ipaddr.IPv6Network('::2002:1/120')
 581         ip3 = ipaddr.IPv6Network('::2001:1/96')
 582         # test that ipv6 addresses are subsumed properly.
 583         collapsed = ipaddr.collapse_address_list([ip1, ip2, ip3])
 584         self.assertEqual(collapsed, [ip3])
 585
 586         # the toejam test
 587         ip1 = ipaddr.IPAddress('1.1.1.1')
 588         ip2 = ipaddr.IPAddress('::1')
 589         self.assertRaises(TypeError, ipaddr.collapse_address_list,
 590                           [ip1, ip2])
 591
 592     def testSummarizing(self):
 593         #ip = ipaddr.IPAddress
 594         #ipnet = ipaddr.IPNetwork
 595         summarize = ipaddr.summarize_address_range
 596         ip1 = ipaddr.IPAddress('1.1.1.0')
 597         ip2 = ipaddr.IPAddress('1.1.1.255')
 598         # test a /24 is sumamrized properly
 599         self.assertEqual(summarize(ip1, ip2)[0], ipaddr.IPNetwork('1.1.1.0/24'))
 600         # test an  IPv4 range that isn't on a network byte boundary
 601         ip2 = ipaddr.IPAddress('1.1.1.8')
 602         self.assertEqual(summarize(ip1, ip2), [ipaddr.IPNetwork('1.1.1.0/29'),
 603                                                ipaddr.IPNetwork('1.1.1.8')])
 604
 605         ip1 = ipaddr.IPAddress('1::')
 606         ip2 = ipaddr.IPAddress('1:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
 607         # test a IPv6 is sumamrized properly
 608         self.assertEqual(summarize(ip1, ip2)[0], ipaddr.IPNetwork('1::/16'))
 609         # test an IPv6 range that isn't on a network byte boundary
 610         ip2 = ipaddr.IPAddress('2::')
 611         self.assertEqual(summarize(ip1, ip2), [ipaddr.IPNetwork('1::/16'),
 612                                                ipaddr.IPNetwork('2::/128')])
 613
 614         # test exception raised when first is greater than last
 615         self.assertRaises(ValueError, summarize, ipaddr.IPAddress('1.1.1.0'),
 616             ipaddr.IPAddress('1.1.0.0'))
 617         # test exception raised when first and last aren't IP addresses
 618         self.assertRaises(TypeError, summarize,
 619                           ipaddr.IPNetwork('1.1.1.0'),
 620                           ipaddr.IPNetwork('1.1.0.0'))
 621         self.assertRaises(TypeError, summarize,
 622             ipaddr.IPNetwork('1.1.1.0'), ipaddr.IPNetwork('1.1.0.0'))
 623         # test exception raised when first and last are not same version
 624         self.assertRaises(TypeError, summarize, ipaddr.IPAddress('::'),
 625             ipaddr.IPNetwork('1.1.0.0'))
 626
 627     def testAddressComparison(self):
 628         self.assertTrue(ipaddr.IPAddress('1.1.1.1') <=
 629                         ipaddr.IPAddress('1.1.1.1'))
 630         self.assertTrue(ipaddr.IPAddress('1.1.1.1') <=
 631                         ipaddr.IPAddress('1.1.1.2'))
 632         self.assertTrue(ipaddr.IPAddress('::1') <= ipaddr.IPAddress('::1'))
 633         self.assertTrue(ipaddr.IPAddress('::1') <= ipaddr.IPAddress('::2'))
 634
 635     def testNetworkComparison(self):
 636         # ip1 and ip2 have the same network address
 637         ip1 = ipaddr.IPv4Network('1.1.1.0/24')
 638         ip2 = ipaddr.IPv4Network('1.1.1.1/24')
 639         ip3 = ipaddr.IPv4Network('1.1.2.0/24')
 640
 641         self.assertTrue(ip1 < ip3)
 642         self.assertTrue(ip3 > ip2)
 643
 644         self.assertEqual(ip1.compare_networks(ip2), 0)
 645         self.assertTrue(ip1._get_networks_key() == ip2._get_networks_key())
 646         self.assertEqual(ip1.compare_networks(ip3), -1)
 647         self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
 648
 649         ip1 = ipaddr.IPv6Network('2001::2000/96')
 650         ip2 = ipaddr.IPv6Network('2001::2001/96')
 651         ip3 = ipaddr.IPv6Network('2001:ffff::2000/96')
 652
 653         self.assertTrue(ip1 < ip3)
 654         self.assertTrue(ip3 > ip2)
 655         self.assertEqual(ip1.compare_networks(ip2), 0)
 656         self.assertTrue(ip1._get_networks_key() == ip2._get_networks_key())
 657         self.assertEqual(ip1.compare_networks(ip3), -1)
 658         self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
 659
 660         # Test comparing different protocols.
 661         # Should always raise a TypeError.
 662         ipv6 = ipaddr.IPv6Network('::/0')
 663         ipv4 = ipaddr.IPv4Network('0.0.0.0/0')
 664         self.assertRaises(TypeError, ipv4.__lt__, ipv6)
 665         self.assertRaises(TypeError, ipv4.__gt__, ipv6)
 666         self.assertRaises(TypeError, ipv6.__lt__, ipv4)
 667         self.assertRaises(TypeError, ipv6.__gt__, ipv4)
 668
 669         # Regression test for issue 19.
 670         ip1 = ipaddr.IPNetwork('10.1.2.128/25')
 671         self.assertFalse(ip1 < ip1)
 672         self.assertFalse(ip1 > ip1)
 673         ip2 = ipaddr.IPNetwork('10.1.3.0/24')
 674         self.assertTrue(ip1 < ip2)
 675         self.assertFalse(ip2 < ip1)
 676         self.assertFalse(ip1 > ip2)
 677         self.assertTrue(ip2 > ip1)
 678         ip3 = ipaddr.IPNetwork('10.1.3.0/25')
 679         self.assertTrue(ip2 < ip3)
 680         self.assertFalse(ip3 < ip2)
 681         self.assertFalse(ip2 > ip3)
 682         self.assertTrue(ip3 > ip2)
 683
 684         # Regression test for issue 28.
 685         ip1 = ipaddr.IPNetwork('10.10.10.0/31')
 686         ip2 = ipaddr.IPNetwork('10.10.10.0')
 687         ip3 = ipaddr.IPNetwork('10.10.10.2/31')
 688         ip4 = ipaddr.IPNetwork('10.10.10.2')
 689         sorted = [ip1, ip2, ip3, ip4]
 690         unsorted = [ip2, ip4, ip1, ip3]
 691         unsorted.sort()
 692         self.assertEqual(sorted, unsorted)
 693         unsorted = [ip4, ip1, ip3, ip2]
 694         unsorted.sort()
 695         self.assertEqual(sorted, unsorted)
 696         self.assertRaises(TypeError, ip1.__lt__, ipaddr.IPAddress('10.10.10.0'))
 697         self.assertRaises(TypeError, ip2.__lt__, ipaddr.IPAddress('10.10.10.0'))
 698
 699         # <=, >=
 700         self.assertTrue(ipaddr.IPNetwork('1.1.1.1') <=
 701                         ipaddr.IPNetwork('1.1.1.1'))
 702         self.assertTrue(ipaddr.IPNetwork('1.1.1.1') <=
 703                         ipaddr.IPNetwork('1.1.1.2'))
 704         self.assertFalse(ipaddr.IPNetwork('1.1.1.2') <=
 705                         ipaddr.IPNetwork('1.1.1.1'))
 706         self.assertTrue(ipaddr.IPNetwork('::1') <= ipaddr.IPNetwork('::1'))
 707         self.assertTrue(ipaddr.IPNetwork('::1') <= ipaddr.IPNetwork('::2'))
 708         self.assertFalse(ipaddr.IPNetwork('::2') <= ipaddr.IPNetwork('::1'))
 709
 710     def testStrictNetworks(self):
 711         self.assertRaises(ValueError, ipaddr.IPNetwork, '192.168.1.1/24',
 712                           strict=True)
 713         self.assertRaises(ValueError, ipaddr.IPNetwork, '::1/120', strict=True)
 714
 715     def testOverlaps(self):
 716         other = ipaddr.IPv4Network('1.2.3.0/30')
 717         other2 = ipaddr.IPv4Network('1.2.2.0/24')
 718         other3 = ipaddr.IPv4Network('1.2.2.64/26')
 719         self.assertTrue(self.ipv4.overlaps(other))
 720         self.assertFalse(self.ipv4.overlaps(other2))
 721         self.assertTrue(other2.overlaps(other3))
 722
 723     def testEmbeddedIpv4(self):
 724         ipv4_string = '192.168.0.1'
 725         ipv4 = ipaddr.IPv4Network(ipv4_string)
 726         v4compat_ipv6 = ipaddr.IPv6Network('::%s' % ipv4_string)
 727         self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
 728         v4mapped_ipv6 = ipaddr.IPv6Network('::ffff:%s' % ipv4_string)
 729         self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
 730         self.assertRaises(ipaddr.AddressValueError, ipaddr.IPv6Network,
 731                           '2001:1.1.1.1:1.1.1.1')
 732
 733     # Issue 67: IPv6 with embedded IPv4 address not recognized.
 734     def testIPv6AddressTooLarge(self):
 735         # RFC4291 2.5.5.2
 736         self.assertEqual(ipaddr.IPAddress('::FFFF:192.0.2.1'),
 737                           ipaddr.IPAddress('::FFFF:c000:201'))
 738         # RFC4291 2.2 (part 3) x::d.d.d.d
 739         self.assertEqual(ipaddr.IPAddress('FFFF::192.0.2.1'),
 740                           ipaddr.IPAddress('FFFF::c000:201'))
 741
 742     def testIPVersion(self):
 743         self.assertEqual(self.ipv4.version, 4)
 744         self.assertEqual(self.ipv6.version, 6)
 745
 746     def testMaxPrefixLength(self):
 747         self.assertEqual(self.ipv4.max_prefixlen, 32)
 748         self.assertEqual(self.ipv6.max_prefixlen, 128)
 749
 750     def testPacked(self):
 751         self.assertEqual(self.ipv4.packed,
 752                          _cb('\x01\x02\x03\x04'))
 753         self.assertEqual(ipaddr.IPv4Network('255.254.253.252').packed,
 754                          _cb('\xff\xfe\xfd\xfc'))
 755         self.assertEqual(self.ipv6.packed,
 756                          _cb('\x20\x01\x06\x58\x02\x2a\xca\xfe'
 757                              '\x02\x00\x00\x00\x00\x00\x00\x01'))
 758         self.assertEqual(ipaddr.IPv6Network('ffff:2:3:4:ffff::').packed,
 759                          _cb('\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff'
 760                             + '\x00' * 6))
 761         self.assertEqual(ipaddr.IPv6Network('::1:0:0:0:0').packed,
 762                          _cb('\x00' * 6 + '\x00\x01' + '\x00' * 8))
 763
 764     def testIpStrFromPrefixlen(self):
 765         ipv4 = ipaddr.IPv4Network('1.2.3.4/24')
 766         self.assertEqual(ipv4._ip_string_from_prefix(), '255.255.255.0')
 767         self.assertEqual(ipv4._ip_string_from_prefix(28), '255.255.255.240')
 768
 769     def testIpType(self):
 770         ipv4net = ipaddr.IPNetwork('1.2.3.4')
 771         ipv4addr = ipaddr.IPAddress('1.2.3.4')
 772         ipv6net = ipaddr.IPNetwork('::1.2.3.4')
 773         ipv6addr = ipaddr.IPAddress('::1.2.3.4')
 774         self.assertEqual(ipaddr.IPv4Network, type(ipv4net))
 775         self.assertEqual(ipaddr.IPv4Address, type(ipv4addr))
 776         self.assertEqual(ipaddr.IPv6Network, type(ipv6net))
 777         self.assertEqual(ipaddr.IPv6Address, type(ipv6addr))
 778
 779     def testReservedIpv4(self):
 780         # test networks
 781         self.assertEqual(True, ipaddr.IPNetwork('224.1.1.1/31').is_multicast)
 782         self.assertEqual(False, ipaddr.IPNetwork('240.0.0.0').is_multicast)
 783
 784         self.assertEqual(True, ipaddr.IPNetwork('192.168.1.1/17').is_private)
 785         self.assertEqual(False, ipaddr.IPNetwork('192.169.0.0').is_private)
 786         self.assertEqual(True, ipaddr.IPNetwork('10.255.255.255').is_private)
 787         self.assertEqual(False, ipaddr.IPNetwork('11.0.0.0').is_private)
 788         self.assertEqual(True, ipaddr.IPNetwork('172.31.255.255').is_private)
 789         self.assertEqual(False, ipaddr.IPNetwork('172.32.0.0').is_private)
 790
 791         self.assertEqual(True,
 792                           ipaddr.IPNetwork('169.254.100.200/24').is_link_local)
 793         self.assertEqual(False,
 794                           ipaddr.IPNetwork('169.255.100.200/24').is_link_local)
 795
 796         self.assertEqual(True,
 797                           ipaddr.IPNetwork('127.100.200.254/32').is_loopback)
 798         self.assertEqual(True, ipaddr.IPNetwork('127.42.0.0/16').is_loopback)
 799         self.assertEqual(False, ipaddr.IPNetwork('128.0.0.0').is_loopback)
 800
 801         # test addresses
 802         self.assertEqual(True, ipaddr.IPAddress('224.1.1.1').is_multicast)
 803         self.assertEqual(False, ipaddr.IPAddress('240.0.0.0').is_multicast)
 804
 805         self.assertEqual(True, ipaddr.IPAddress('192.168.1.1').is_private)
 806         self.assertEqual(False, ipaddr.IPAddress('192.169.0.0').is_private)
 807         self.assertEqual(True, ipaddr.IPAddress('10.255.255.255').is_private)
 808         self.assertEqual(False, ipaddr.IPAddress('11.0.0.0').is_private)
 809         self.assertEqual(True, ipaddr.IPAddress('172.31.255.255').is_private)
 810         self.assertEqual(False, ipaddr.IPAddress('172.32.0.0').is_private)
 811
 812         self.assertEqual(True,
 813                           ipaddr.IPAddress('169.254.100.200').is_link_local)
 814         self.assertEqual(False,
 815                           ipaddr.IPAddress('169.255.100.200').is_link_local)
 816
 817         self.assertEqual(True,
 818                           ipaddr.IPAddress('127.100.200.254').is_loopback)
 819         self.assertEqual(True, ipaddr.IPAddress('127.42.0.0').is_loopback)
 820         self.assertEqual(False, ipaddr.IPAddress('128.0.0.0').is_loopback)
 821         self.assertEqual(True, ipaddr.IPNetwork('0.0.0.0').is_unspecified)
 822
 823     def testReservedIpv6(self):
 824
 825         self.assertEqual(True, ipaddr.IPNetwork('ffff::').is_multicast)
 826         self.assertEqual(True, ipaddr.IPNetwork(2**128-1).is_multicast)
 827         self.assertEqual(True, ipaddr.IPNetwork('ff00::').is_multicast)
 828         self.assertEqual(False, ipaddr.IPNetwork('fdff::').is_multicast)
 829
 830         self.assertEqual(True, ipaddr.IPNetwork('fecf::').is_site_local)
 831         self.assertEqual(True, ipaddr.IPNetwork(
 832                 'feff:ffff:ffff:ffff::').is_site_local)
 833         self.assertEqual(False, ipaddr.IPNetwork('fbf:ffff::').is_site_local)
 834         self.assertEqual(False, ipaddr.IPNetwork('ff00::').is_site_local)
 835
 836         self.assertEqual(True, ipaddr.IPNetwork('fc00::').is_private)
 837         self.assertEqual(True, ipaddr.IPNetwork(
 838                 'fc00:ffff:ffff:ffff::').is_private)
 839         self.assertEqual(False, ipaddr.IPNetwork('fbff:ffff::').is_private)
 840         self.assertEqual(False, ipaddr.IPNetwork('fe00::').is_private)
 841
 842         self.assertEqual(True, ipaddr.IPNetwork('fea0::').is_link_local)
 843         self.assertEqual(True, ipaddr.IPNetwork('febf:ffff::').is_link_local)
 844         self.assertEqual(False, ipaddr.IPNetwork('fe7f:ffff::').is_link_local)
 845         self.assertEqual(False, ipaddr.IPNetwork('fec0::').is_link_local)
 846
 847         self.assertEqual(True, ipaddr.IPNetwork('0:0::0:01').is_loopback)
 848         self.assertEqual(False, ipaddr.IPNetwork('::1/127').is_loopback)
 849         self.assertEqual(False, ipaddr.IPNetwork('::').is_loopback)
 850         self.assertEqual(False, ipaddr.IPNetwork('::2').is_loopback)
 851
 852         self.assertEqual(True, ipaddr.IPNetwork('0::0').is_unspecified)
 853         self.assertEqual(False, ipaddr.IPNetwork('::1').is_unspecified)
 854         self.assertEqual(False, ipaddr.IPNetwork('::/127').is_unspecified)
 855
 856         # test addresses
 857         self.assertEqual(True, ipaddr.IPAddress('ffff::').is_multicast)
 858         self.assertEqual(True, ipaddr.IPAddress(2**128-1).is_multicast)
 859         self.assertEqual(True, ipaddr.IPAddress('ff00::').is_multicast)
 860         self.assertEqual(False, ipaddr.IPAddress('fdff::').is_multicast)
 861
 862         self.assertEqual(True, ipaddr.IPAddress('fecf::').is_site_local)
 863         self.assertEqual(True, ipaddr.IPAddress(
 864                 'feff:ffff:ffff:ffff::').is_site_local)
 865         self.assertEqual(False, ipaddr.IPAddress('fbf:ffff::').is_site_local)
 866         self.assertEqual(False, ipaddr.IPAddress('ff00::').is_site_local)
 867
 868         self.assertEqual(True, ipaddr.IPAddress('fc00::').is_private)
 869         self.assertEqual(True, ipaddr.IPAddress(
 870                 'fc00:ffff:ffff:ffff::').is_private)
 871         self.assertEqual(False, ipaddr.IPAddress('fbff:ffff::').is_private)
 872         self.assertEqual(False, ipaddr.IPAddress('fe00::').is_private)
 873
 874         self.assertEqual(True, ipaddr.IPAddress('fea0::').is_link_local)
 875         self.assertEqual(True, ipaddr.IPAddress('febf:ffff::').is_link_local)
 876         self.assertEqual(False, ipaddr.IPAddress('fe7f:ffff::').is_link_local)
 877         self.assertEqual(False, ipaddr.IPAddress('fec0::').is_link_local)
 878
 879         self.assertEqual(True, ipaddr.IPAddress('0:0::0:01').is_loopback)
 880         self.assertEqual(True, ipaddr.IPAddress('::1').is_loopback)
 881         self.assertEqual(False, ipaddr.IPAddress('::2').is_loopback)
 882
 883         self.assertEqual(True, ipaddr.IPAddress('0::0').is_unspecified)
 884         self.assertEqual(False, ipaddr.IPAddress('::1').is_unspecified)
 885
 886         # some generic IETF reserved addresses
 887         self.assertEqual(True, ipaddr.IPAddress('100::').is_reserved)
 888         self.assertEqual(True, ipaddr.IPNetwork('4000::1/128').is_reserved)
 889
 890     def testIpv4Mapped(self):
 891         self.assertEqual(ipaddr.IPAddress('::ffff:192.168.1.1').ipv4_mapped,
 892                          ipaddr.IPAddress('192.168.1.1'))
 893         self.assertEqual(ipaddr.IPAddress('::c0a8:101').ipv4_mapped, None)
 894         self.assertEqual(ipaddr.IPAddress('::ffff:c0a8:101').ipv4_mapped,
 895                          ipaddr.IPAddress('192.168.1.1'))
 896
 897     def testAddrExclude(self):
 898         addr1 = ipaddr.IPNetwork('10.1.1.0/24')
 899         addr2 = ipaddr.IPNetwork('10.1.1.0/26')
 900         addr3 = ipaddr.IPNetwork('10.2.1.0/24')
 901         addr4 = ipaddr.IPAddress('10.1.1.0')
 902         self.assertEqual(addr1.address_exclude(addr2),
 903                          [ipaddr.IPNetwork('10.1.1.64/26'),
 904                           ipaddr.IPNetwork('10.1.1.128/25')])
 905         self.assertRaises(ValueError, addr1.address_exclude, addr3)
 906         self.assertRaises(TypeError, addr1.address_exclude, addr4)
 907         self.assertEqual(addr1.address_exclude(addr1), [])
 908
 909     def testHash(self):
 910         self.assertEqual(hash(ipaddr.IPNetwork('10.1.1.0/24')),
 911                           hash(ipaddr.IPNetwork('10.1.1.0/24')))
 912         self.assertEqual(hash(ipaddr.IPAddress('10.1.1.0')),
 913                           hash(ipaddr.IPAddress('10.1.1.0')))
 914         # i70
 915         self.assertEqual(hash(ipaddr.IPAddress('1.2.3.4')),
 916                           hash(ipaddr.IPAddress(
 917                     long(ipaddr.IPAddress('1.2.3.4')._ip))))
 918         ip1 = ipaddr.IPAddress('10.1.1.0')
 919         ip2 = ipaddr.IPAddress('1::')
 920         dummy = {}
 921         dummy[self.ipv4] = None
 922         dummy[self.ipv6] = None
 923         dummy[ip1] = None
 924         dummy[ip2] = None
 925         self.assertTrue(self.ipv4 in dummy)
 926         self.assertTrue(ip2 in dummy)
 927
 928     def testCopyConstructor(self):
 929         addr1 = ipaddr.IPNetwork('10.1.1.0/24')
 930         addr2 = ipaddr.IPNetwork(addr1)
 931         addr3 = ipaddr.IPNetwork('2001:658:22a:cafe:200::1/64')
 932         addr4 = ipaddr.IPNetwork(addr3)
 933         addr5 = ipaddr.IPv4Address('1.1.1.1')
 934         addr6 = ipaddr.IPv6Address('2001:658:22a:cafe:200::1')
 935
 936         self.assertEqual(addr1, addr2)
 937         self.assertEqual(addr3, addr4)
 938         self.assertEqual(addr5, ipaddr.IPv4Address(addr5))
 939         self.assertEqual(addr6, ipaddr.IPv6Address(addr6))
 940
 941     def testCompressIPv6Address(self):
 942         test_addresses = {
 943             '1:2:3:4:5:6:7:8': '1:2:3:4:5:6:7:8/128',
 944             '2001:0:0:4:0:0:0:8': '2001:0:0:4::8/128',
 945             '2001:0:0:4:5:6:7:8': '2001::4:5:6:7:8/128',
 946             '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128',
 947             '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128',
 948             '0:0:3:0:0:0:0:ffff': '0:0:3::ffff/128',
 949             '0:0:0:4:0:0:0:ffff': '::4:0:0:0:ffff/128',
 950             '0:0:0:0:5:0:0:ffff': '::5:0:0:ffff/128',
 951             '1:0:0:4:0:0:7:8': '1::4:0:0:7:8/128',
 952             '0:0:0:0:0:0:0:0': '::/128',
 953             '0:0:0:0:0:0:0:0/0': '::/0',
 954             '0:0:0:0:0:0:0:1': '::1/128',
 955             '2001:0658:022a:cafe:0000:0000:0000:0000/66':
 956             '2001:658:22a:cafe::/66',
 957             '::1.2.3.4': '::102:304/128',
 958             '1:2:3:4:5:ffff:1.2.3.4': '1:2:3:4:5:ffff:102:304/128',
 959             '::7:6:5:4:3:2:1': '0:7:6:5:4:3:2:1/128',
 960             '::7:6:5:4:3:2:0': '0:7:6:5:4:3:2:0/128',
 961             '7:6:5:4:3:2:1::': '7:6:5:4:3:2:1:0/128',
 962             '0:6:5:4:3:2:1::': '0:6:5:4:3:2:1:0/128',
 963             }
 964         for uncompressed, compressed in test_addresses.items():
 965             self.assertEqual(compressed, str(ipaddr.IPv6Network(uncompressed)))
 966
 967     def testExplodeShortHandIpStr(self):
 968         addr1 = ipaddr.IPv6Network('2001::1')
 969         addr2 = ipaddr.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
 970         self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0001/128',
 971                          addr1.exploded)
 972         self.assertEqual('0000:0000:0000:0000:0000:0000:0000:0001/128',
 973                          ipaddr.IPv6Network('::1/128').exploded)
 974         # issue 77
 975         self.assertEqual('2001:0000:5ef5:79fd:0000:059d:a0e5:0ba1',
 976                          addr2.exploded)
 977
 978     def testIntRepresentation(self):
 979         self.assertEqual(16909060, int(self.ipv4))
 980         self.assertEqual(42540616829182469433547762482097946625, int(self.ipv6))
 981
 982     def testHexRepresentation(self):
 983         self.assertEqual(hex(0x1020304),
 984                          hex(self.ipv4))
 985
 986         self.assertEqual(hex(0x20010658022ACAFE0200000000000001),
 987                          hex(self.ipv6))
 988
 989     # backwards compatibility
 990     def testBackwardsCompability(self):
 991         self.assertEqual(ipaddr.CollapseAddrList(
 992             [ipaddr.IPNetwork('1.1.0.0/24'), ipaddr.IPNetwork('1.1.1.0/24')]),
 993                          [ipaddr.IPNetwork('1.1.0.0/23')])
 994
 995         self.assertEqual(ipaddr.IPNetwork('::42:0/112').AddressExclude(
 996             ipaddr.IPNetwork('::42:8000/113')),
 997                          [ipaddr.IPNetwork('::42:0/113')])
 998
 999         self.assertTrue(ipaddr.IPNetwork('1::/8').CompareNetworks(
1000             ipaddr.IPNetwork('2::/9')) < 0)
1001
1002         self.assertEqual(ipaddr.IPNetwork('1::/16').Contains(
1003             ipaddr.IPNetwork('2::/16')), False)
1004
1005         self.assertEqual(ipaddr.IPNetwork('0.0.0.0/0').Subnet(),
1006                          [ipaddr.IPNetwork('0.0.0.0/1'),
1007                           ipaddr.IPNetwork('128.0.0.0/1')])
1008         self.assertEqual(ipaddr.IPNetwork('::/127').Subnet(),
1009                          [ipaddr.IPNetwork('::/128'),
1010                           ipaddr.IPNetwork('::1/128')])
1011
1012         self.assertEqual(ipaddr.IPNetwork('1.0.0.0/32').Supernet(),
1013                          ipaddr.IPNetwork('1.0.0.0/31'))
1014         self.assertEqual(ipaddr.IPNetwork('::/121').Supernet(),
1015                          ipaddr.IPNetwork('::/120'))
1016
1017         self.assertEqual(ipaddr.IPNetwork('10.0.0.2').IsRFC1918(), True)
1018         self.assertEqual(ipaddr.IPNetwork('10.0.0.0').IsMulticast(), False)
1019         self.assertEqual(ipaddr.IPNetwork('127.255.255.255').IsLoopback(), True)
1020         self.assertEqual(ipaddr.IPNetwork('169.255.255.255').IsLinkLocal(),
1021                          False)
1022
1023     def testForceVersion(self):
1024         self.assertEqual(ipaddr.IPNetwork(1).version, 4)
1025         self.assertEqual(ipaddr.IPNetwork(1, version=6).version, 6)
1026
1027     def testWithStar(self):
1028         self.assertEqual(str(self.ipv4.with_prefixlen), "1.2.3.4/24")
1029         self.assertEqual(str(self.ipv4.with_netmask), "1.2.3.4/255.255.255.0")
1030         self.assertEqual(str(self.ipv4.with_hostmask), "1.2.3.4/0.0.0.255")
1031
1032         self.assertEqual(str(self.ipv6.with_prefixlen),
1033                          '2001:658:22a:cafe:200::1/64')
1034         # rfc3513 sec 2.3 says that ipv6 only uses cidr notation for
1035         # subnets
1036         self.assertEqual(str(self.ipv6.with_netmask),
1037                          '2001:658:22a:cafe:200::1/64')
1038         # this probably don't make much sense, but it's included for
1039         # compatibility with ipv4
1040         self.assertEqual(str(self.ipv6.with_hostmask),
1041                          '2001:658:22a:cafe:200::1/::ffff:ffff:ffff:ffff')
1042
1043     def testNetworkElementCaching(self):
1044         # V4 - make sure we're empty
1045         self.assertFalse(self.ipv4._cache.has_key('network'))
1046         self.assertFalse(self.ipv4._cache.has_key('broadcast'))
1047         self.assertFalse(self.ipv4._cache.has_key('hostmask'))
1048
1049         # V4 - populate and test
1050         self.assertEqual(self.ipv4.network, ipaddr.IPv4Address('1.2.3.0'))
1051         self.assertEqual(self.ipv4.broadcast, ipaddr.IPv4Address('1.2.3.255'))
1052         self.assertEqual(self.ipv4.hostmask, ipaddr.IPv4Address('0.0.0.255'))
1053
1054         # V4 - check we're cached
1055         self.assertTrue(self.ipv4._cache.has_key('network'))
1056         self.assertTrue(self.ipv4._cache.has_key('broadcast'))
1057         self.assertTrue(self.ipv4._cache.has_key('hostmask'))
1058
1059         # V6 - make sure we're empty
1060         self.assertFalse(self.ipv6._cache.has_key('network'))
1061         self.assertFalse(self.ipv6._cache.has_key('broadcast'))
1062         self.assertFalse(self.ipv6._cache.has_key('hostmask'))
1063
1064         # V6 - populate and test
1065         self.assertEqual(self.ipv6.network,
1066                          ipaddr.IPv6Address('2001:658:22a:cafe::'))
1067         self.assertEqual(self.ipv6.broadcast, ipaddr.IPv6Address(
1068             '2001:658:22a:cafe:ffff:ffff:ffff:ffff'))
1069         self.assertEqual(self.ipv6.hostmask,
1070                          ipaddr.IPv6Address('::ffff:ffff:ffff:ffff'))
1071
1072         # V6 - check we're cached
1073         self.assertTrue(self.ipv6._cache.has_key('network'))
1074         self.assertTrue(self.ipv6._cache.has_key('broadcast'))
1075         self.assertTrue(self.ipv6._cache.has_key('hostmask'))
1076
1077     def testTeredo(self):
1078         # stolen from wikipedia
1079         server = ipaddr.IPv4Address('65.54.227.120')
1080         client = ipaddr.IPv4Address('192.0.2.45')
1081         teredo_addr = '2001:0000:4136:e378:8000:63bf:3fff:fdd2'
1082         self.assertEqual((server, client),
1083                          ipaddr.IPAddress(teredo_addr).teredo)
1084         bad_addr = '2000::4136:e378:8000:63bf:3fff:fdd2'
1085         self.assertFalse(ipaddr.IPAddress(bad_addr).teredo)
1086         bad_addr = '2001:0001:4136:e378:8000:63bf:3fff:fdd2'
1087         self.assertFalse(ipaddr.IPAddress(bad_addr).teredo)
1088
1089         # i77
1090         teredo_addr = ipaddr.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
1091         self.assertEqual((ipaddr.IPv4Address('94.245.121.253'),
1092                           ipaddr.IPv4Address('95.26.244.94')),
1093                          teredo_addr.teredo)
1094
1095
1096     def testsixtofour(self):
1097         sixtofouraddr = ipaddr.IPAddress('2002:ac1d:2d64::1')
1098         bad_addr = ipaddr.IPAddress('2000:ac1d:2d64::1')
1099         self.assertEqual(ipaddr.IPv4Address('172.29.45.100'),
1100                          sixtofouraddr.sixtofour)
1101         self.assertFalse(bad_addr.sixtofour)
1102
1103
1104 if __name__ == '__main__':
1105     unittest.main()