1# Copyright 2007 Google Inc. 2# Licensed to PSF under a Contributor Agreement. 3 4"""Unittest for ipaddress module.""" 5 6 7import unittest 8import re 9import contextlib 10import functools 11import operator 12import pickle 13import ipaddress 14import weakref 15from test.support import LARGEST, SMALLEST 16 17 18class BaseTestCase(unittest.TestCase): 19 # One big change in ipaddress over the original ipaddr module is 20 # error reporting that tries to assume users *don't know the rules* 21 # for what constitutes an RFC compliant IP address 22 23 # Ensuring these errors are emitted correctly in all relevant cases 24 # meant moving to a more systematic test structure that allows the 25 # test structure to map more directly to the module structure 26 27 # Note that if the constructors are refactored so that addresses with 28 # multiple problems get classified differently, that's OK - just 29 # move the affected examples to the newly appropriate test case. 30 31 # There is some duplication between the original relatively ad hoc 32 # test suite and the new systematic tests. While some redundancy in 33 # testing is considered preferable to accidentally deleting a valid 34 # test, the original test suite will likely be reduced over time as 35 # redundant tests are identified. 36 37 @property 38 def factory(self): 39 raise NotImplementedError 40 41 @contextlib.contextmanager 42 def assertCleanError(self, exc_type, details, *args): 43 """ 44 Ensure exception does not display a context by default 45 46 Wraps unittest.TestCase.assertRaisesRegex 47 """ 48 if args: 49 details = details % args 50 cm = self.assertRaisesRegex(exc_type, details) 51 with cm as exc: 52 yield exc 53 # Ensure we produce clean tracebacks on failure 54 if exc.exception.__context__ is not None: 55 self.assertTrue(exc.exception.__suppress_context__) 56 57 def assertAddressError(self, details, *args): 58 """Ensure a clean AddressValueError""" 59 return self.assertCleanError(ipaddress.AddressValueError, 60 details, *args) 61 62 def assertNetmaskError(self, details, *args): 63 """Ensure a clean NetmaskValueError""" 64 return self.assertCleanError(ipaddress.NetmaskValueError, 65 details, *args) 66 67 def assertInstancesEqual(self, lhs, rhs): 68 """Check constructor arguments produce equivalent instances""" 69 self.assertEqual(self.factory(lhs), self.factory(rhs)) 70 71 72class CommonTestMixin: 73 74 def test_empty_address(self): 75 with self.assertAddressError("Address cannot be empty"): 76 self.factory("") 77 78 def test_floats_rejected(self): 79 with self.assertAddressError(re.escape(repr("1.0"))): 80 self.factory(1.0) 81 82 def test_not_an_index_issue15559(self): 83 # Implementing __index__ makes for a very nasty interaction with the 84 # bytes constructor. Thus, we disallow implicit use as an integer 85 self.assertRaises(TypeError, operator.index, self.factory(1)) 86 self.assertRaises(TypeError, hex, self.factory(1)) 87 self.assertRaises(TypeError, bytes, self.factory(1)) 88 89 def pickle_test(self, addr): 90 for proto in range(pickle.HIGHEST_PROTOCOL + 1): 91 with self.subTest(proto=proto): 92 x = self.factory(addr) 93 y = pickle.loads(pickle.dumps(x, proto)) 94 self.assertEqual(y, x) 95 96 97class CommonTestMixin_v4(CommonTestMixin): 98 99 def test_leading_zeros(self): 100 # bpo-36384: no leading zeros to avoid ambiguity with octal notation 101 msg = "Leading zeros are not permitted in '\d+'" 102 addresses = [ 103 "000.000.000.000", 104 "192.168.000.001", 105 "016.016.016.016", 106 "192.168.000.001", 107 "001.000.008.016", 108 "01.2.3.40", 109 "1.02.3.40", 110 "1.2.03.40", 111 "1.2.3.040", 112 ] 113 for address in addresses: 114 with self.subTest(address=address): 115 with self.assertAddressError(msg): 116 self.factory(address) 117 118 def test_int(self): 119 self.assertInstancesEqual(0, "0.0.0.0") 120 self.assertInstancesEqual(3232235521, "192.168.0.1") 121 122 def test_packed(self): 123 self.assertInstancesEqual(bytes.fromhex("00000000"), "0.0.0.0") 124 self.assertInstancesEqual(bytes.fromhex("c0a80001"), "192.168.0.1") 125 126 def test_negative_ints_rejected(self): 127 msg = "-1 (< 0) is not permitted as an IPv4 address" 128 with self.assertAddressError(re.escape(msg)): 129 self.factory(-1) 130 131 def test_large_ints_rejected(self): 132 msg = "%d (>= 2**32) is not permitted as an IPv4 address" 133 with self.assertAddressError(re.escape(msg % 2**32)): 134 self.factory(2**32) 135 136 def test_bad_packed_length(self): 137 def assertBadLength(length): 138 addr = b'\0' * length 139 msg = "%r (len %d != 4) is not permitted as an IPv4 address" 140 with self.assertAddressError(re.escape(msg % (addr, length))): 141 self.factory(addr) 142 143 assertBadLength(3) 144 assertBadLength(5) 145 146 147class CommonTestMixin_v6(CommonTestMixin): 148 149 def test_leading_zeros(self): 150 self.assertInstancesEqual("0000::0000", "::") 151 self.assertInstancesEqual("000::c0a8:0001", "::c0a8:1") 152 153 def test_int(self): 154 self.assertInstancesEqual(0, "::") 155 self.assertInstancesEqual(3232235521, "::c0a8:1") 156 157 def test_packed(self): 158 addr = b'\0'*12 + bytes.fromhex("00000000") 159 self.assertInstancesEqual(addr, "::") 160 addr = b'\0'*12 + bytes.fromhex("c0a80001") 161 self.assertInstancesEqual(addr, "::c0a8:1") 162 addr = bytes.fromhex("c0a80001") + b'\0'*12 163 self.assertInstancesEqual(addr, "c0a8:1::") 164 165 def test_negative_ints_rejected(self): 166 msg = "-1 (< 0) is not permitted as an IPv6 address" 167 with self.assertAddressError(re.escape(msg)): 168 self.factory(-1) 169 170 def test_large_ints_rejected(self): 171 msg = "%d (>= 2**128) is not permitted as an IPv6 address" 172 with self.assertAddressError(re.escape(msg % 2**128)): 173 self.factory(2**128) 174 175 def test_bad_packed_length(self): 176 def assertBadLength(length): 177 addr = b'\0' * length 178 msg = "%r (len %d != 16) is not permitted as an IPv6 address" 179 with self.assertAddressError(re.escape(msg % (addr, length))): 180 self.factory(addr) 181 self.factory(addr) 182 183 assertBadLength(15) 184 assertBadLength(17) 185 186 187class AddressTestCase_v4(BaseTestCase, CommonTestMixin_v4): 188 factory = ipaddress.IPv4Address 189 190 def test_network_passed_as_address(self): 191 addr = "127.0.0.1/24" 192 with self.assertAddressError("Unexpected '/' in %r", addr): 193 ipaddress.IPv4Address(addr) 194 195 def test_bad_address_split(self): 196 def assertBadSplit(addr): 197 with self.assertAddressError("Expected 4 octets in %r", addr): 198 ipaddress.IPv4Address(addr) 199 200 assertBadSplit("127.0.1") 201 assertBadSplit("42.42.42.42.42") 202 assertBadSplit("42.42.42") 203 assertBadSplit("42.42") 204 assertBadSplit("42") 205 assertBadSplit("42..42.42.42") 206 assertBadSplit("42.42.42.42.") 207 assertBadSplit("42.42.42.42...") 208 assertBadSplit(".42.42.42.42") 209 assertBadSplit("...42.42.42.42") 210 assertBadSplit("016.016.016") 211 assertBadSplit("016.016") 212 assertBadSplit("016") 213 assertBadSplit("000") 214 assertBadSplit("0x0a.0x0a.0x0a") 215 assertBadSplit("0x0a.0x0a") 216 assertBadSplit("0x0a") 217 assertBadSplit(".") 218 assertBadSplit("bogus") 219 assertBadSplit("bogus.com") 220 assertBadSplit("1000") 221 assertBadSplit("1000000000000000") 222 assertBadSplit("192.168.0.1.com") 223 224 def test_empty_octet(self): 225 def assertBadOctet(addr): 226 with self.assertAddressError("Empty octet not permitted in %r", 227 addr): 228 ipaddress.IPv4Address(addr) 229 230 assertBadOctet("42..42.42") 231 assertBadOctet("...") 232 233 def test_invalid_characters(self): 234 def assertBadOctet(addr, octet): 235 msg = "Only decimal digits permitted in %r in %r" % (octet, addr) 236 with self.assertAddressError(re.escape(msg)): 237 ipaddress.IPv4Address(addr) 238 239 assertBadOctet("0x0a.0x0a.0x0a.0x0a", "0x0a") 240 assertBadOctet("0xa.0x0a.0x0a.0x0a", "0xa") 241 assertBadOctet("42.42.42.-0", "-0") 242 assertBadOctet("42.42.42.+0", "+0") 243 assertBadOctet("42.42.42.-42", "-42") 244 assertBadOctet("+1.+2.+3.4", "+1") 245 assertBadOctet("1.2.3.4e0", "4e0") 246 assertBadOctet("1.2.3.4::", "4::") 247 assertBadOctet("1.a.2.3", "a") 248 249 def test_octet_length(self): 250 def assertBadOctet(addr, octet): 251 msg = "At most 3 characters permitted in %r in %r" 252 with self.assertAddressError(re.escape(msg % (octet, addr))): 253 ipaddress.IPv4Address(addr) 254 255 assertBadOctet("0000.000.000.000", "0000") 256 assertBadOctet("12345.67899.-54321.-98765", "12345") 257 258 def test_octet_limit(self): 259 def assertBadOctet(addr, octet): 260 msg = "Octet %d (> 255) not permitted in %r" % (octet, addr) 261 with self.assertAddressError(re.escape(msg)): 262 ipaddress.IPv4Address(addr) 263 264 assertBadOctet("257.0.0.0", 257) 265 assertBadOctet("192.168.0.999", 999) 266 267 def test_pickle(self): 268 self.pickle_test('192.0.2.1') 269 270 def test_weakref(self): 271 weakref.ref(self.factory('192.0.2.1')) 272 273 274class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6): 275 factory = ipaddress.IPv6Address 276 277 def test_network_passed_as_address(self): 278 addr = "::1/24" 279 with self.assertAddressError("Unexpected '/' in %r", addr): 280 ipaddress.IPv6Address(addr) 281 282 def test_bad_address_split_v6_not_enough_parts(self): 283 def assertBadSplit(addr): 284 msg = "At least 3 parts expected in %r" 285 with self.assertAddressError(msg, addr): 286 ipaddress.IPv6Address(addr) 287 288 assertBadSplit(":") 289 assertBadSplit(":1") 290 assertBadSplit("FEDC:9878") 291 292 def test_bad_address_split_v6_too_many_colons(self): 293 def assertBadSplit(addr): 294 msg = "At most 8 colons permitted in %r" 295 with self.assertAddressError(msg, addr): 296 ipaddress.IPv6Address(addr) 297 298 assertBadSplit("9:8:7:6:5:4:3::2:1") 299 assertBadSplit("10:9:8:7:6:5:4:3:2:1") 300 assertBadSplit("::8:7:6:5:4:3:2:1") 301 assertBadSplit("8:7:6:5:4:3:2:1::") 302 # A trailing IPv4 address is two parts 303 assertBadSplit("10:9:8:7:6:5:4:3:42.42.42.42") 304 305 def test_bad_address_split_v6_too_many_parts(self): 306 def assertBadSplit(addr): 307 msg = "Exactly 8 parts expected without '::' in %r" 308 with self.assertAddressError(msg, addr): 309 ipaddress.IPv6Address(addr) 310 311 assertBadSplit("3ffe:0:0:0:0:0:0:0:1") 312 assertBadSplit("9:8:7:6:5:4:3:2:1") 313 assertBadSplit("7:6:5:4:3:2:1") 314 # A trailing IPv4 address is two parts 315 assertBadSplit("9:8:7:6:5:4:3:42.42.42.42") 316 assertBadSplit("7:6:5:4:3:42.42.42.42") 317 318 def test_bad_address_split_v6_too_many_parts_with_double_colon(self): 319 def assertBadSplit(addr): 320 msg = "Expected at most 7 other parts with '::' in %r" 321 with self.assertAddressError(msg, addr): 322 ipaddress.IPv6Address(addr) 323 324 assertBadSplit("1:2:3:4::5:6:7:8") 325 326 def test_bad_address_split_v6_repeated_double_colon(self): 327 def assertBadSplit(addr): 328 msg = "At most one '::' permitted in %r" 329 with self.assertAddressError(msg, addr): 330 ipaddress.IPv6Address(addr) 331 332 assertBadSplit("3ffe::1::1") 333 assertBadSplit("1::2::3::4:5") 334 assertBadSplit("2001::db:::1") 335 assertBadSplit("3ffe::1::") 336 assertBadSplit("::3ffe::1") 337 assertBadSplit(":3ffe::1::1") 338 assertBadSplit("3ffe::1::1:") 339 assertBadSplit(":3ffe::1::1:") 340 assertBadSplit(":::") 341 assertBadSplit('2001:db8:::1') 342 343 def test_bad_address_split_v6_leading_colon(self): 344 def assertBadSplit(addr): 345 msg = "Leading ':' only permitted as part of '::' in %r" 346 with self.assertAddressError(msg, addr): 347 ipaddress.IPv6Address(addr) 348 349 assertBadSplit(":2001:db8::1") 350 assertBadSplit(":1:2:3:4:5:6:7") 351 assertBadSplit(":1:2:3:4:5:6:") 352 assertBadSplit(":6:5:4:3:2:1::") 353 354 def test_bad_address_split_v6_trailing_colon(self): 355 def assertBadSplit(addr): 356 msg = "Trailing ':' only permitted as part of '::' in %r" 357 with self.assertAddressError(msg, addr): 358 ipaddress.IPv6Address(addr) 359 360 assertBadSplit("2001:db8::1:") 361 assertBadSplit("1:2:3:4:5:6:7:") 362 assertBadSplit("::1.2.3.4:") 363 assertBadSplit("::7:6:5:4:3:2:") 364 365 def test_bad_v4_part_in(self): 366 def assertBadAddressPart(addr, v4_error): 367 with self.assertAddressError("%s in %r", v4_error, addr): 368 ipaddress.IPv6Address(addr) 369 370 assertBadAddressPart("3ffe::1.net", "Expected 4 octets in '1.net'") 371 assertBadAddressPart("3ffe::127.0.1", 372 "Expected 4 octets in '127.0.1'") 373 assertBadAddressPart("::1.2.3", 374 "Expected 4 octets in '1.2.3'") 375 assertBadAddressPart("::1.2.3.4.5", 376 "Expected 4 octets in '1.2.3.4.5'") 377 assertBadAddressPart("3ffe::1.1.1.net", 378 "Only decimal digits permitted in 'net' " 379 "in '1.1.1.net'") 380 381 def test_invalid_characters(self): 382 def assertBadPart(addr, part): 383 msg = "Only hex digits permitted in %r in %r" % (part, addr) 384 with self.assertAddressError(re.escape(msg)): 385 ipaddress.IPv6Address(addr) 386 387 assertBadPart("3ffe::goog", "goog") 388 assertBadPart("3ffe::-0", "-0") 389 assertBadPart("3ffe::+0", "+0") 390 assertBadPart("3ffe::-1", "-1") 391 assertBadPart("1.2.3.4::", "1.2.3.4") 392 assertBadPart('1234:axy::b', "axy") 393 394 def test_part_length(self): 395 def assertBadPart(addr, part): 396 msg = "At most 4 characters permitted in %r in %r" 397 with self.assertAddressError(msg, part, addr): 398 ipaddress.IPv6Address(addr) 399 400 assertBadPart("::00000", "00000") 401 assertBadPart("3ffe::10000", "10000") 402 assertBadPart("02001:db8::", "02001") 403 assertBadPart('2001:888888::1', "888888") 404 405 def test_pickle(self): 406 self.pickle_test('2001:db8::') 407 408 def test_weakref(self): 409 weakref.ref(self.factory('2001:db8::')) 410 411 412class NetmaskTestMixin_v4(CommonTestMixin_v4): 413 """Input validation on interfaces and networks is very similar""" 414 415 def test_no_mask(self): 416 for address in ('1.2.3.4', 0x01020304, b'\x01\x02\x03\x04'): 417 net = self.factory(address) 418 self.assertEqual(str(net), '1.2.3.4/32') 419 self.assertEqual(str(net.netmask), '255.255.255.255') 420 self.assertEqual(str(net.hostmask), '0.0.0.0') 421 # IPv4Network has prefixlen, but IPv4Interface doesn't. 422 # Should we add it to IPv4Interface too? (bpo-36392) 423 424 def test_split_netmask(self): 425 addr = "1.2.3.4/32/24" 426 with self.assertAddressError("Only one '/' permitted in %r" % addr): 427 self.factory(addr) 428 429 def test_address_errors(self): 430 def assertBadAddress(addr, details): 431 with self.assertAddressError(details): 432 self.factory(addr) 433 434 assertBadAddress("/", "Address cannot be empty") 435 assertBadAddress("/8", "Address cannot be empty") 436 assertBadAddress("bogus", "Expected 4 octets") 437 assertBadAddress("google.com", "Expected 4 octets") 438 assertBadAddress("10/8", "Expected 4 octets") 439 assertBadAddress("::1.2.3.4", "Only decimal digits") 440 assertBadAddress("1.2.3.256", re.escape("256 (> 255)")) 441 442 def test_valid_netmask(self): 443 self.assertEqual(str(self.factory('192.0.2.0/255.255.255.0')), 444 '192.0.2.0/24') 445 for i in range(0, 33): 446 # Generate and re-parse the CIDR format (trivial). 447 net_str = '0.0.0.0/%d' % i 448 net = self.factory(net_str) 449 self.assertEqual(str(net), net_str) 450 # Generate and re-parse the expanded netmask. 451 self.assertEqual( 452 str(self.factory('0.0.0.0/%s' % net.netmask)), net_str) 453 # Zero prefix is treated as decimal. 454 self.assertEqual(str(self.factory('0.0.0.0/0%d' % i)), net_str) 455 # Generate and re-parse the expanded hostmask. The ambiguous 456 # cases (/0 and /32) are treated as netmasks. 457 if i in (32, 0): 458 net_str = '0.0.0.0/%d' % (32 - i) 459 self.assertEqual( 460 str(self.factory('0.0.0.0/%s' % net.hostmask)), net_str) 461 462 def test_netmask_errors(self): 463 def assertBadNetmask(addr, netmask): 464 msg = "%r is not a valid netmask" % netmask 465 with self.assertNetmaskError(re.escape(msg)): 466 self.factory("%s/%s" % (addr, netmask)) 467 468 assertBadNetmask("1.2.3.4", "") 469 assertBadNetmask("1.2.3.4", "-1") 470 assertBadNetmask("1.2.3.4", "+1") 471 assertBadNetmask("1.2.3.4", " 1 ") 472 assertBadNetmask("1.2.3.4", "0x1") 473 assertBadNetmask("1.2.3.4", "33") 474 assertBadNetmask("1.2.3.4", "254.254.255.256") 475 assertBadNetmask("1.2.3.4", "1.a.2.3") 476 assertBadNetmask("1.1.1.1", "254.xyz.2.3") 477 assertBadNetmask("1.1.1.1", "240.255.0.0") 478 assertBadNetmask("1.1.1.1", "255.254.128.0") 479 assertBadNetmask("1.1.1.1", "0.1.127.255") 480 assertBadNetmask("1.1.1.1", "pudding") 481 assertBadNetmask("1.1.1.1", "::") 482 483 def test_netmask_in_tuple_errors(self): 484 def assertBadNetmask(addr, netmask): 485 msg = "%r is not a valid netmask" % netmask 486 with self.assertNetmaskError(re.escape(msg)): 487 self.factory((addr, netmask)) 488 assertBadNetmask("1.1.1.1", -1) 489 assertBadNetmask("1.1.1.1", 33) 490 491 def test_pickle(self): 492 self.pickle_test('192.0.2.0/27') 493 self.pickle_test('192.0.2.0/31') # IPV4LENGTH - 1 494 self.pickle_test('192.0.2.0') # IPV4LENGTH 495 496 497class InterfaceTestCase_v4(BaseTestCase, NetmaskTestMixin_v4): 498 factory = ipaddress.IPv4Interface 499 500 501class NetworkTestCase_v4(BaseTestCase, NetmaskTestMixin_v4): 502 factory = ipaddress.IPv4Network 503 504 def test_subnet_of(self): 505 # containee left of container 506 self.assertFalse( 507 self.factory('10.0.0.0/30').subnet_of( 508 self.factory('10.0.1.0/24'))) 509 # containee inside container 510 self.assertTrue( 511 self.factory('10.0.0.0/30').subnet_of( 512 self.factory('10.0.0.0/24'))) 513 # containee right of container 514 self.assertFalse( 515 self.factory('10.0.0.0/30').subnet_of( 516 self.factory('10.0.1.0/24'))) 517 # containee larger than container 518 self.assertFalse( 519 self.factory('10.0.1.0/24').subnet_of( 520 self.factory('10.0.0.0/30'))) 521 522 def test_supernet_of(self): 523 # containee left of container 524 self.assertFalse( 525 self.factory('10.0.0.0/30').supernet_of( 526 self.factory('10.0.1.0/24'))) 527 # containee inside container 528 self.assertFalse( 529 self.factory('10.0.0.0/30').supernet_of( 530 self.factory('10.0.0.0/24'))) 531 # containee right of container 532 self.assertFalse( 533 self.factory('10.0.0.0/30').supernet_of( 534 self.factory('10.0.1.0/24'))) 535 # containee larger than container 536 self.assertTrue( 537 self.factory('10.0.0.0/24').supernet_of( 538 self.factory('10.0.0.0/30'))) 539 540 def test_subnet_of_mixed_types(self): 541 with self.assertRaises(TypeError): 542 ipaddress.IPv4Network('10.0.0.0/30').supernet_of( 543 ipaddress.IPv6Network('::1/128')) 544 with self.assertRaises(TypeError): 545 ipaddress.IPv6Network('::1/128').supernet_of( 546 ipaddress.IPv4Network('10.0.0.0/30')) 547 with self.assertRaises(TypeError): 548 ipaddress.IPv4Network('10.0.0.0/30').subnet_of( 549 ipaddress.IPv6Network('::1/128')) 550 with self.assertRaises(TypeError): 551 ipaddress.IPv6Network('::1/128').subnet_of( 552 ipaddress.IPv4Network('10.0.0.0/30')) 553 554 555class NetmaskTestMixin_v6(CommonTestMixin_v6): 556 """Input validation on interfaces and networks is very similar""" 557 558 def test_no_mask(self): 559 for address in ('::1', 1, b'\x00'*15 + b'\x01'): 560 net = self.factory(address) 561 self.assertEqual(str(net), '::1/128') 562 self.assertEqual(str(net.netmask), 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff') 563 self.assertEqual(str(net.hostmask), '::') 564 # IPv6Network has prefixlen, but IPv6Interface doesn't. 565 # Should we add it to IPv4Interface too? (bpo-36392) 566 567 def test_split_netmask(self): 568 addr = "cafe:cafe::/128/190" 569 with self.assertAddressError("Only one '/' permitted in %r" % addr): 570 self.factory(addr) 571 572 def test_address_errors(self): 573 def assertBadAddress(addr, details): 574 with self.assertAddressError(details): 575 self.factory(addr) 576 577 assertBadAddress("/", "Address cannot be empty") 578 assertBadAddress("/8", "Address cannot be empty") 579 assertBadAddress("google.com", "At least 3 parts") 580 assertBadAddress("1.2.3.4", "At least 3 parts") 581 assertBadAddress("10/8", "At least 3 parts") 582 assertBadAddress("1234:axy::b", "Only hex digits") 583 584 def test_valid_netmask(self): 585 # We only support CIDR for IPv6, because expanded netmasks are not 586 # standard notation. 587 self.assertEqual(str(self.factory('2001:db8::/32')), '2001:db8::/32') 588 for i in range(0, 129): 589 # Generate and re-parse the CIDR format (trivial). 590 net_str = '::/%d' % i 591 self.assertEqual(str(self.factory(net_str)), net_str) 592 # Zero prefix is treated as decimal. 593 self.assertEqual(str(self.factory('::/0%d' % i)), net_str) 594 595 def test_netmask_errors(self): 596 def assertBadNetmask(addr, netmask): 597 msg = "%r is not a valid netmask" % netmask 598 with self.assertNetmaskError(re.escape(msg)): 599 self.factory("%s/%s" % (addr, netmask)) 600 601 assertBadNetmask("::1", "") 602 assertBadNetmask("::1", "::1") 603 assertBadNetmask("::1", "1::") 604 assertBadNetmask("::1", "-1") 605 assertBadNetmask("::1", "+1") 606 assertBadNetmask("::1", " 1 ") 607 assertBadNetmask("::1", "0x1") 608 assertBadNetmask("::1", "129") 609 assertBadNetmask("::1", "1.2.3.4") 610 assertBadNetmask("::1", "pudding") 611 assertBadNetmask("::", "::") 612 613 def test_netmask_in_tuple_errors(self): 614 def assertBadNetmask(addr, netmask): 615 msg = "%r is not a valid netmask" % netmask 616 with self.assertNetmaskError(re.escape(msg)): 617 self.factory((addr, netmask)) 618 assertBadNetmask("::1", -1) 619 assertBadNetmask("::1", 129) 620 621 def test_pickle(self): 622 self.pickle_test('2001:db8::1000/124') 623 self.pickle_test('2001:db8::1000/127') # IPV6LENGTH - 1 624 self.pickle_test('2001:db8::1000') # IPV6LENGTH 625 626 627class InterfaceTestCase_v6(BaseTestCase, NetmaskTestMixin_v6): 628 factory = ipaddress.IPv6Interface 629 630 631class NetworkTestCase_v6(BaseTestCase, NetmaskTestMixin_v6): 632 factory = ipaddress.IPv6Network 633 634 def test_subnet_of(self): 635 # containee left of container 636 self.assertFalse( 637 self.factory('2000:999::/56').subnet_of( 638 self.factory('2000:aaa::/48'))) 639 # containee inside container 640 self.assertTrue( 641 self.factory('2000:aaa::/56').subnet_of( 642 self.factory('2000:aaa::/48'))) 643 # containee right of container 644 self.assertFalse( 645 self.factory('2000:bbb::/56').subnet_of( 646 self.factory('2000:aaa::/48'))) 647 # containee larger than container 648 self.assertFalse( 649 self.factory('2000:aaa::/48').subnet_of( 650 self.factory('2000:aaa::/56'))) 651 652 def test_supernet_of(self): 653 # containee left of container 654 self.assertFalse( 655 self.factory('2000:999::/56').supernet_of( 656 self.factory('2000:aaa::/48'))) 657 # containee inside container 658 self.assertFalse( 659 self.factory('2000:aaa::/56').supernet_of( 660 self.factory('2000:aaa::/48'))) 661 # containee right of container 662 self.assertFalse( 663 self.factory('2000:bbb::/56').supernet_of( 664 self.factory('2000:aaa::/48'))) 665 # containee larger than container 666 self.assertTrue( 667 self.factory('2000:aaa::/48').supernet_of( 668 self.factory('2000:aaa::/56'))) 669 670 671class FactoryFunctionErrors(BaseTestCase): 672 673 def assertFactoryError(self, factory, kind): 674 """Ensure a clean ValueError with the expected message""" 675 addr = "camelot" 676 msg = '%r does not appear to be an IPv4 or IPv6 %s' 677 with self.assertCleanError(ValueError, msg, addr, kind): 678 factory(addr) 679 680 def test_ip_address(self): 681 self.assertFactoryError(ipaddress.ip_address, "address") 682 683 def test_ip_interface(self): 684 self.assertFactoryError(ipaddress.ip_interface, "interface") 685 686 def test_ip_network(self): 687 self.assertFactoryError(ipaddress.ip_network, "network") 688 689 690class ComparisonTests(unittest.TestCase): 691 692 v4addr = ipaddress.IPv4Address(1) 693 v4net = ipaddress.IPv4Network(1) 694 v4intf = ipaddress.IPv4Interface(1) 695 v6addr = ipaddress.IPv6Address(1) 696 v6net = ipaddress.IPv6Network(1) 697 v6intf = ipaddress.IPv6Interface(1) 698 699 v4_addresses = [v4addr, v4intf] 700 v4_objects = v4_addresses + [v4net] 701 v6_addresses = [v6addr, v6intf] 702 v6_objects = v6_addresses + [v6net] 703 704 objects = v4_objects + v6_objects 705 706 v4addr2 = ipaddress.IPv4Address(2) 707 v4net2 = ipaddress.IPv4Network(2) 708 v4intf2 = ipaddress.IPv4Interface(2) 709 v6addr2 = ipaddress.IPv6Address(2) 710 v6net2 = ipaddress.IPv6Network(2) 711 v6intf2 = ipaddress.IPv6Interface(2) 712 713 def test_foreign_type_equality(self): 714 # __eq__ should never raise TypeError directly 715 other = object() 716 for obj in self.objects: 717 self.assertNotEqual(obj, other) 718 self.assertFalse(obj == other) 719 self.assertEqual(obj.__eq__(other), NotImplemented) 720 self.assertEqual(obj.__ne__(other), NotImplemented) 721 722 def test_mixed_type_equality(self): 723 # Ensure none of the internal objects accidentally 724 # expose the right set of attributes to become "equal" 725 for lhs in self.objects: 726 for rhs in self.objects: 727 if lhs is rhs: 728 continue 729 self.assertNotEqual(lhs, rhs) 730 731 def test_same_type_equality(self): 732 for obj in self.objects: 733 self.assertEqual(obj, obj) 734 self.assertLessEqual(obj, obj) 735 self.assertGreaterEqual(obj, obj) 736 737 def test_same_type_ordering(self): 738 for lhs, rhs in ( 739 (self.v4addr, self.v4addr2), 740 (self.v4net, self.v4net2), 741 (self.v4intf, self.v4intf2), 742 (self.v6addr, self.v6addr2), 743 (self.v6net, self.v6net2), 744 (self.v6intf, self.v6intf2), 745 ): 746 self.assertNotEqual(lhs, rhs) 747 self.assertLess(lhs, rhs) 748 self.assertLessEqual(lhs, rhs) 749 self.assertGreater(rhs, lhs) 750 self.assertGreaterEqual(rhs, lhs) 751 self.assertFalse(lhs > rhs) 752 self.assertFalse(rhs < lhs) 753 self.assertFalse(lhs >= rhs) 754 self.assertFalse(rhs <= lhs) 755 756 def test_containment(self): 757 for obj in self.v4_addresses: 758 self.assertIn(obj, self.v4net) 759 for obj in self.v6_addresses: 760 self.assertIn(obj, self.v6net) 761 for obj in self.v4_objects + [self.v6net]: 762 self.assertNotIn(obj, self.v6net) 763 for obj in self.v6_objects + [self.v4net]: 764 self.assertNotIn(obj, self.v4net) 765 766 def test_mixed_type_ordering(self): 767 for lhs in self.objects: 768 for rhs in self.objects: 769 if isinstance(lhs, type(rhs)) or isinstance(rhs, type(lhs)): 770 continue 771 self.assertRaises(TypeError, lambda: lhs < rhs) 772 self.assertRaises(TypeError, lambda: lhs > rhs) 773 self.assertRaises(TypeError, lambda: lhs <= rhs) 774 self.assertRaises(TypeError, lambda: lhs >= rhs) 775 776 def test_foreign_type_ordering(self): 777 other = object() 778 for obj in self.objects: 779 with self.assertRaises(TypeError): 780 obj < other 781 with self.assertRaises(TypeError): 782 obj > other 783 with self.assertRaises(TypeError): 784 obj <= other 785 with self.assertRaises(TypeError): 786 obj >= other 787 self.assertTrue(obj < LARGEST) 788 self.assertFalse(obj > LARGEST) 789 self.assertTrue(obj <= LARGEST) 790 self.assertFalse(obj >= LARGEST) 791 self.assertFalse(obj < SMALLEST) 792 self.assertTrue(obj > SMALLEST) 793 self.assertFalse(obj <= SMALLEST) 794 self.assertTrue(obj >= SMALLEST) 795 796 def test_mixed_type_key(self): 797 # with get_mixed_type_key, you can sort addresses and network. 798 v4_ordered = [self.v4addr, self.v4net, self.v4intf] 799 v6_ordered = [self.v6addr, self.v6net, self.v6intf] 800 self.assertEqual(v4_ordered, 801 sorted(self.v4_objects, 802 key=ipaddress.get_mixed_type_key)) 803 self.assertEqual(v6_ordered, 804 sorted(self.v6_objects, 805 key=ipaddress.get_mixed_type_key)) 806 self.assertEqual(v4_ordered + v6_ordered, 807 sorted(self.objects, 808 key=ipaddress.get_mixed_type_key)) 809 self.assertEqual(NotImplemented, ipaddress.get_mixed_type_key(object)) 810 811 def test_incompatible_versions(self): 812 # These should always raise TypeError 813 v4addr = ipaddress.ip_address('1.1.1.1') 814 v4net = ipaddress.ip_network('1.1.1.1') 815 v6addr = ipaddress.ip_address('::1') 816 v6net = ipaddress.ip_network('::1') 817 818 self.assertRaises(TypeError, v4addr.__lt__, v6addr) 819 self.assertRaises(TypeError, v4addr.__gt__, v6addr) 820 self.assertRaises(TypeError, v4net.__lt__, v6net) 821 self.assertRaises(TypeError, v4net.__gt__, v6net) 822 823 self.assertRaises(TypeError, v6addr.__lt__, v4addr) 824 self.assertRaises(TypeError, v6addr.__gt__, v4addr) 825 self.assertRaises(TypeError, v6net.__lt__, v4net) 826 self.assertRaises(TypeError, v6net.__gt__, v4net) 827 828 829class IpaddrUnitTest(unittest.TestCase): 830 831 def setUp(self): 832 self.ipv4_address = ipaddress.IPv4Address('1.2.3.4') 833 self.ipv4_interface = ipaddress.IPv4Interface('1.2.3.4/24') 834 self.ipv4_network = ipaddress.IPv4Network('1.2.3.0/24') 835 #self.ipv4_hostmask = ipaddress.IPv4Interface('10.0.0.1/0.255.255.255') 836 self.ipv6_address = ipaddress.IPv6Interface( 837 '2001:658:22a:cafe:200:0:0:1') 838 self.ipv6_interface = ipaddress.IPv6Interface( 839 '2001:658:22a:cafe:200:0:0:1/64') 840 self.ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/64') 841 842 def testRepr(self): 843 self.assertEqual("IPv4Interface('1.2.3.4/32')", 844 repr(ipaddress.IPv4Interface('1.2.3.4'))) 845 self.assertEqual("IPv6Interface('::1/128')", 846 repr(ipaddress.IPv6Interface('::1'))) 847 848 # issue #16531: constructing IPv4Network from an (address, mask) tuple 849 def testIPv4Tuple(self): 850 # /32 851 ip = ipaddress.IPv4Address('192.0.2.1') 852 net = ipaddress.IPv4Network('192.0.2.1/32') 853 self.assertEqual(ipaddress.IPv4Network(('192.0.2.1', 32)), net) 854 self.assertEqual(ipaddress.IPv4Network((ip, 32)), net) 855 self.assertEqual(ipaddress.IPv4Network((3221225985, 32)), net) 856 self.assertEqual(ipaddress.IPv4Network(('192.0.2.1', 857 '255.255.255.255')), net) 858 self.assertEqual(ipaddress.IPv4Network((ip, 859 '255.255.255.255')), net) 860 self.assertEqual(ipaddress.IPv4Network((3221225985, 861 '255.255.255.255')), net) 862 # strict=True and host bits set 863 with self.assertRaises(ValueError): 864 ipaddress.IPv4Network(('192.0.2.1', 24)) 865 with self.assertRaises(ValueError): 866 ipaddress.IPv4Network((ip, 24)) 867 with self.assertRaises(ValueError): 868 ipaddress.IPv4Network((3221225985, 24)) 869 with self.assertRaises(ValueError): 870 ipaddress.IPv4Network(('192.0.2.1', '255.255.255.0')) 871 with self.assertRaises(ValueError): 872 ipaddress.IPv4Network((ip, '255.255.255.0')) 873 with self.assertRaises(ValueError): 874 ipaddress.IPv4Network((3221225985, '255.255.255.0')) 875 # strict=False and host bits set 876 net = ipaddress.IPv4Network('192.0.2.0/24') 877 self.assertEqual(ipaddress.IPv4Network(('192.0.2.1', 24), 878 strict=False), net) 879 self.assertEqual(ipaddress.IPv4Network((ip, 24), 880 strict=False), net) 881 self.assertEqual(ipaddress.IPv4Network((3221225985, 24), 882 strict=False), net) 883 self.assertEqual(ipaddress.IPv4Network(('192.0.2.1', 884 '255.255.255.0'), 885 strict=False), net) 886 self.assertEqual(ipaddress.IPv4Network((ip, 887 '255.255.255.0'), 888 strict=False), net) 889 self.assertEqual(ipaddress.IPv4Network((3221225985, 890 '255.255.255.0'), 891 strict=False), net) 892 893 # /24 894 ip = ipaddress.IPv4Address('192.0.2.0') 895 net = ipaddress.IPv4Network('192.0.2.0/24') 896 self.assertEqual(ipaddress.IPv4Network(('192.0.2.0', 897 '255.255.255.0')), net) 898 self.assertEqual(ipaddress.IPv4Network((ip, 899 '255.255.255.0')), net) 900 self.assertEqual(ipaddress.IPv4Network((3221225984, 901 '255.255.255.0')), net) 902 self.assertEqual(ipaddress.IPv4Network(('192.0.2.0', 24)), net) 903 self.assertEqual(ipaddress.IPv4Network((ip, 24)), net) 904 self.assertEqual(ipaddress.IPv4Network((3221225984, 24)), net) 905 906 self.assertEqual(ipaddress.IPv4Interface(('192.0.2.1', 24)), 907 ipaddress.IPv4Interface('192.0.2.1/24')) 908 self.assertEqual(ipaddress.IPv4Interface((3221225985, 24)), 909 ipaddress.IPv4Interface('192.0.2.1/24')) 910 911 # issue #16531: constructing IPv6Network from an (address, mask) tuple 912 def testIPv6Tuple(self): 913 # /128 914 ip = ipaddress.IPv6Address('2001:db8::') 915 net = ipaddress.IPv6Network('2001:db8::/128') 916 self.assertEqual(ipaddress.IPv6Network(('2001:db8::', '128')), 917 net) 918 self.assertEqual(ipaddress.IPv6Network( 919 (42540766411282592856903984951653826560, 128)), 920 net) 921 self.assertEqual(ipaddress.IPv6Network((ip, '128')), 922 net) 923 ip = ipaddress.IPv6Address('2001:db8::') 924 net = ipaddress.IPv6Network('2001:db8::/96') 925 self.assertEqual(ipaddress.IPv6Network(('2001:db8::', '96')), 926 net) 927 self.assertEqual(ipaddress.IPv6Network( 928 (42540766411282592856903984951653826560, 96)), 929 net) 930 self.assertEqual(ipaddress.IPv6Network((ip, '96')), 931 net) 932 933 # strict=True and host bits set 934 ip = ipaddress.IPv6Address('2001:db8::1') 935 with self.assertRaises(ValueError): 936 ipaddress.IPv6Network(('2001:db8::1', 96)) 937 with self.assertRaises(ValueError): 938 ipaddress.IPv6Network(( 939 42540766411282592856903984951653826561, 96)) 940 with self.assertRaises(ValueError): 941 ipaddress.IPv6Network((ip, 96)) 942 # strict=False and host bits set 943 net = ipaddress.IPv6Network('2001:db8::/96') 944 self.assertEqual(ipaddress.IPv6Network(('2001:db8::1', 96), 945 strict=False), 946 net) 947 self.assertEqual(ipaddress.IPv6Network( 948 (42540766411282592856903984951653826561, 96), 949 strict=False), 950 net) 951 self.assertEqual(ipaddress.IPv6Network((ip, 96), strict=False), 952 net) 953 954 # /96 955 self.assertEqual(ipaddress.IPv6Interface(('2001:db8::1', '96')), 956 ipaddress.IPv6Interface('2001:db8::1/96')) 957 self.assertEqual(ipaddress.IPv6Interface( 958 (42540766411282592856903984951653826561, '96')), 959 ipaddress.IPv6Interface('2001:db8::1/96')) 960 961 # issue57 962 def testAddressIntMath(self): 963 self.assertEqual(ipaddress.IPv4Address('1.1.1.1') + 255, 964 ipaddress.IPv4Address('1.1.2.0')) 965 self.assertEqual(ipaddress.IPv4Address('1.1.1.1') - 256, 966 ipaddress.IPv4Address('1.1.0.1')) 967 self.assertEqual(ipaddress.IPv6Address('::1') + (2**16 - 2), 968 ipaddress.IPv6Address('::ffff')) 969 self.assertEqual(ipaddress.IPv6Address('::ffff') - (2**16 - 2), 970 ipaddress.IPv6Address('::1')) 971 972 def testInvalidIntToBytes(self): 973 self.assertRaises(ValueError, ipaddress.v4_int_to_packed, -1) 974 self.assertRaises(ValueError, ipaddress.v4_int_to_packed, 975 2 ** ipaddress.IPV4LENGTH) 976 self.assertRaises(ValueError, ipaddress.v6_int_to_packed, -1) 977 self.assertRaises(ValueError, ipaddress.v6_int_to_packed, 978 2 ** ipaddress.IPV6LENGTH) 979 980 def testInternals(self): 981 ip1 = ipaddress.IPv4Address('10.10.10.10') 982 ip2 = ipaddress.IPv4Address('10.10.10.11') 983 ip3 = ipaddress.IPv4Address('10.10.10.12') 984 self.assertEqual(list(ipaddress._find_address_range([ip1])), 985 [(ip1, ip1)]) 986 self.assertEqual(list(ipaddress._find_address_range([ip1, ip3])), 987 [(ip1, ip1), (ip3, ip3)]) 988 self.assertEqual(list(ipaddress._find_address_range([ip1, ip2, ip3])), 989 [(ip1, ip3)]) 990 self.assertEqual(128, ipaddress._count_righthand_zero_bits(0, 128)) 991 self.assertEqual("IPv4Network('1.2.3.0/24')", repr(self.ipv4_network)) 992 993 def testGetNetwork(self): 994 self.assertEqual(int(self.ipv4_network.network_address), 16909056) 995 self.assertEqual(str(self.ipv4_network.network_address), '1.2.3.0') 996 997 self.assertEqual(int(self.ipv6_network.network_address), 998 42540616829182469433403647294022090752) 999 self.assertEqual(str(self.ipv6_network.network_address), 1000 '2001:658:22a:cafe::') 1001 self.assertEqual(str(self.ipv6_network.hostmask), 1002 '::ffff:ffff:ffff:ffff') 1003 1004 def testIpFromInt(self): 1005 self.assertEqual(self.ipv4_interface._ip, 1006 ipaddress.IPv4Interface(16909060)._ip) 1007 1008 ipv4 = ipaddress.ip_network('1.2.3.4') 1009 ipv6 = ipaddress.ip_network('2001:658:22a:cafe:200:0:0:1') 1010 self.assertEqual(ipv4, ipaddress.ip_network(int(ipv4.network_address))) 1011 self.assertEqual(ipv6, ipaddress.ip_network(int(ipv6.network_address))) 1012 1013 v6_int = 42540616829182469433547762482097946625 1014 self.assertEqual(self.ipv6_interface._ip, 1015 ipaddress.IPv6Interface(v6_int)._ip) 1016 1017 self.assertEqual(ipaddress.ip_network(self.ipv4_address._ip).version, 1018 4) 1019 self.assertEqual(ipaddress.ip_network(self.ipv6_address._ip).version, 1020 6) 1021 1022 def testIpFromPacked(self): 1023 address = ipaddress.ip_address 1024 self.assertEqual(self.ipv4_interface._ip, 1025 ipaddress.ip_interface(b'\x01\x02\x03\x04')._ip) 1026 self.assertEqual(address('255.254.253.252'), 1027 address(b'\xff\xfe\xfd\xfc')) 1028 self.assertEqual(self.ipv6_interface.ip, 1029 ipaddress.ip_interface( 1030 b'\x20\x01\x06\x58\x02\x2a\xca\xfe' 1031 b'\x02\x00\x00\x00\x00\x00\x00\x01').ip) 1032 self.assertEqual(address('ffff:2:3:4:ffff::'), 1033 address(b'\xff\xff\x00\x02\x00\x03\x00\x04' + 1034 b'\xff\xff' + b'\x00' * 6)) 1035 self.assertEqual(address('::'), 1036 address(b'\x00' * 16)) 1037 1038 def testGetIp(self): 1039 self.assertEqual(int(self.ipv4_interface.ip), 16909060) 1040 self.assertEqual(str(self.ipv4_interface.ip), '1.2.3.4') 1041 1042 self.assertEqual(int(self.ipv6_interface.ip), 1043 42540616829182469433547762482097946625) 1044 self.assertEqual(str(self.ipv6_interface.ip), 1045 '2001:658:22a:cafe:200::1') 1046 1047 def testGetNetmask(self): 1048 self.assertEqual(int(self.ipv4_network.netmask), 4294967040) 1049 self.assertEqual(str(self.ipv4_network.netmask), '255.255.255.0') 1050 self.assertEqual(int(self.ipv6_network.netmask), 1051 340282366920938463444927863358058659840) 1052 self.assertEqual(self.ipv6_network.prefixlen, 64) 1053 1054 def testZeroNetmask(self): 1055 ipv4_zero_netmask = ipaddress.IPv4Interface('1.2.3.4/0') 1056 self.assertEqual(int(ipv4_zero_netmask.network.netmask), 0) 1057 self.assertEqual(ipv4_zero_netmask._prefix_from_prefix_string('0'), 0) 1058 1059 ipv6_zero_netmask = ipaddress.IPv6Interface('::1/0') 1060 self.assertEqual(int(ipv6_zero_netmask.network.netmask), 0) 1061 self.assertEqual(ipv6_zero_netmask._prefix_from_prefix_string('0'), 0) 1062 1063 def testIPv4Net(self): 1064 net = ipaddress.IPv4Network('127.0.0.0/0.0.0.255') 1065 self.assertEqual(net.prefixlen, 24) 1066 1067 def testGetBroadcast(self): 1068 self.assertEqual(int(self.ipv4_network.broadcast_address), 16909311) 1069 self.assertEqual(str(self.ipv4_network.broadcast_address), '1.2.3.255') 1070 1071 self.assertEqual(int(self.ipv6_network.broadcast_address), 1072 42540616829182469451850391367731642367) 1073 self.assertEqual(str(self.ipv6_network.broadcast_address), 1074 '2001:658:22a:cafe:ffff:ffff:ffff:ffff') 1075 1076 def testGetPrefixlen(self): 1077 self.assertEqual(self.ipv4_interface.network.prefixlen, 24) 1078 self.assertEqual(self.ipv6_interface.network.prefixlen, 64) 1079 1080 def testGetSupernet(self): 1081 self.assertEqual(self.ipv4_network.supernet().prefixlen, 23) 1082 self.assertEqual(str(self.ipv4_network.supernet().network_address), 1083 '1.2.2.0') 1084 self.assertEqual( 1085 ipaddress.IPv4Interface('0.0.0.0/0').network.supernet(), 1086 ipaddress.IPv4Network('0.0.0.0/0')) 1087 1088 self.assertEqual(self.ipv6_network.supernet().prefixlen, 63) 1089 self.assertEqual(str(self.ipv6_network.supernet().network_address), 1090 '2001:658:22a:cafe::') 1091 self.assertEqual(ipaddress.IPv6Interface('::0/0').network.supernet(), 1092 ipaddress.IPv6Network('::0/0')) 1093 1094 def testGetSupernet3(self): 1095 self.assertEqual(self.ipv4_network.supernet(3).prefixlen, 21) 1096 self.assertEqual(str(self.ipv4_network.supernet(3).network_address), 1097 '1.2.0.0') 1098 1099 self.assertEqual(self.ipv6_network.supernet(3).prefixlen, 61) 1100 self.assertEqual(str(self.ipv6_network.supernet(3).network_address), 1101 '2001:658:22a:caf8::') 1102 1103 def testGetSupernet4(self): 1104 self.assertRaises(ValueError, self.ipv4_network.supernet, 1105 prefixlen_diff=2, new_prefix=1) 1106 self.assertRaises(ValueError, self.ipv4_network.supernet, 1107 new_prefix=25) 1108 self.assertEqual(self.ipv4_network.supernet(prefixlen_diff=2), 1109 self.ipv4_network.supernet(new_prefix=22)) 1110 1111 self.assertRaises(ValueError, self.ipv6_network.supernet, 1112 prefixlen_diff=2, new_prefix=1) 1113 self.assertRaises(ValueError, self.ipv6_network.supernet, 1114 new_prefix=65) 1115 self.assertEqual(self.ipv6_network.supernet(prefixlen_diff=2), 1116 self.ipv6_network.supernet(new_prefix=62)) 1117 1118 def testHosts(self): 1119 hosts = list(self.ipv4_network.hosts()) 1120 self.assertEqual(254, len(hosts)) 1121 self.assertEqual(ipaddress.IPv4Address('1.2.3.1'), hosts[0]) 1122 self.assertEqual(ipaddress.IPv4Address('1.2.3.254'), hosts[-1]) 1123 1124 ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/120') 1125 hosts = list(ipv6_network.hosts()) 1126 self.assertEqual(255, len(hosts)) 1127 self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::1'), hosts[0]) 1128 self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::ff'), hosts[-1]) 1129 1130 # special case where only 1 bit is left for address 1131 addrs = [ipaddress.IPv4Address('2.0.0.0'), 1132 ipaddress.IPv4Address('2.0.0.1')] 1133 str_args = '2.0.0.0/31' 1134 tpl_args = ('2.0.0.0', 31) 1135 self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts())) 1136 self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts())) 1137 self.assertEqual(list(ipaddress.ip_network(str_args).hosts()), 1138 list(ipaddress.ip_network(tpl_args).hosts())) 1139 1140 # special case where the network is a /32 1141 addrs = [ipaddress.IPv4Address('1.2.3.4')] 1142 str_args = '1.2.3.4/32' 1143 tpl_args = ('1.2.3.4', 32) 1144 self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts())) 1145 self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts())) 1146 self.assertEqual(list(ipaddress.ip_network(str_args).hosts()), 1147 list(ipaddress.ip_network(tpl_args).hosts())) 1148 1149 addrs = [ipaddress.IPv6Address('2001:658:22a:cafe::'), 1150 ipaddress.IPv6Address('2001:658:22a:cafe::1')] 1151 str_args = '2001:658:22a:cafe::/127' 1152 tpl_args = ('2001:658:22a:cafe::', 127) 1153 self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts())) 1154 self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts())) 1155 self.assertEqual(list(ipaddress.ip_network(str_args).hosts()), 1156 list(ipaddress.ip_network(tpl_args).hosts())) 1157 1158 addrs = [ipaddress.IPv6Address('2001:658:22a:cafe::1'), ] 1159 str_args = '2001:658:22a:cafe::1/128' 1160 tpl_args = ('2001:658:22a:cafe::1', 128) 1161 self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts())) 1162 self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts())) 1163 self.assertEqual(list(ipaddress.ip_network(str_args).hosts()), 1164 list(ipaddress.ip_network(tpl_args).hosts())) 1165 1166 def testFancySubnetting(self): 1167 self.assertEqual(sorted(self.ipv4_network.subnets(prefixlen_diff=3)), 1168 sorted(self.ipv4_network.subnets(new_prefix=27))) 1169 self.assertRaises(ValueError, list, 1170 self.ipv4_network.subnets(new_prefix=23)) 1171 self.assertRaises(ValueError, list, 1172 self.ipv4_network.subnets(prefixlen_diff=3, 1173 new_prefix=27)) 1174 self.assertEqual(sorted(self.ipv6_network.subnets(prefixlen_diff=4)), 1175 sorted(self.ipv6_network.subnets(new_prefix=68))) 1176 self.assertRaises(ValueError, list, 1177 self.ipv6_network.subnets(new_prefix=63)) 1178 self.assertRaises(ValueError, list, 1179 self.ipv6_network.subnets(prefixlen_diff=4, 1180 new_prefix=68)) 1181 1182 def testGetSubnets(self): 1183 self.assertEqual(list(self.ipv4_network.subnets())[0].prefixlen, 25) 1184 self.assertEqual(str(list( 1185 self.ipv4_network.subnets())[0].network_address), 1186 '1.2.3.0') 1187 self.assertEqual(str(list( 1188 self.ipv4_network.subnets())[1].network_address), 1189 '1.2.3.128') 1190 1191 self.assertEqual(list(self.ipv6_network.subnets())[0].prefixlen, 65) 1192 1193 def testGetSubnetForSingle32(self): 1194 ip = ipaddress.IPv4Network('1.2.3.4/32') 1195 subnets1 = [str(x) for x in ip.subnets()] 1196 subnets2 = [str(x) for x in ip.subnets(2)] 1197 self.assertEqual(subnets1, ['1.2.3.4/32']) 1198 self.assertEqual(subnets1, subnets2) 1199 1200 def testGetSubnetForSingle128(self): 1201 ip = ipaddress.IPv6Network('::1/128') 1202 subnets1 = [str(x) for x in ip.subnets()] 1203 subnets2 = [str(x) for x in ip.subnets(2)] 1204 self.assertEqual(subnets1, ['::1/128']) 1205 self.assertEqual(subnets1, subnets2) 1206 1207 def testSubnet2(self): 1208 ips = [str(x) for x in self.ipv4_network.subnets(2)] 1209 self.assertEqual( 1210 ips, 1211 ['1.2.3.0/26', '1.2.3.64/26', '1.2.3.128/26', '1.2.3.192/26']) 1212 1213 ipsv6 = [str(x) for x in self.ipv6_network.subnets(2)] 1214 self.assertEqual( 1215 ipsv6, 1216 ['2001:658:22a:cafe::/66', 1217 '2001:658:22a:cafe:4000::/66', 1218 '2001:658:22a:cafe:8000::/66', 1219 '2001:658:22a:cafe:c000::/66']) 1220 1221 def testGetSubnets3(self): 1222 subnets = [str(x) for x in self.ipv4_network.subnets(8)] 1223 self.assertEqual(subnets[:3], 1224 ['1.2.3.0/32', '1.2.3.1/32', '1.2.3.2/32']) 1225 self.assertEqual(subnets[-3:], 1226 ['1.2.3.253/32', '1.2.3.254/32', '1.2.3.255/32']) 1227 self.assertEqual(len(subnets), 256) 1228 1229 ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/120') 1230 subnets = [str(x) for x in ipv6_network.subnets(8)] 1231 self.assertEqual(subnets[:3], 1232 ['2001:658:22a:cafe::/128', 1233 '2001:658:22a:cafe::1/128', 1234 '2001:658:22a:cafe::2/128']) 1235 self.assertEqual(subnets[-3:], 1236 ['2001:658:22a:cafe::fd/128', 1237 '2001:658:22a:cafe::fe/128', 1238 '2001:658:22a:cafe::ff/128']) 1239 self.assertEqual(len(subnets), 256) 1240 1241 def testSubnetFailsForLargeCidrDiff(self): 1242 self.assertRaises(ValueError, list, 1243 self.ipv4_interface.network.subnets(9)) 1244 self.assertRaises(ValueError, list, 1245 self.ipv4_network.subnets(9)) 1246 self.assertRaises(ValueError, list, 1247 self.ipv6_interface.network.subnets(65)) 1248 self.assertRaises(ValueError, list, 1249 self.ipv6_network.subnets(65)) 1250 1251 def testSupernetFailsForLargeCidrDiff(self): 1252 self.assertRaises(ValueError, 1253 self.ipv4_interface.network.supernet, 25) 1254 self.assertRaises(ValueError, 1255 self.ipv6_interface.network.supernet, 65) 1256 1257 def testSubnetFailsForNegativeCidrDiff(self): 1258 self.assertRaises(ValueError, list, 1259 self.ipv4_interface.network.subnets(-1)) 1260 self.assertRaises(ValueError, list, 1261 self.ipv4_network.subnets(-1)) 1262 self.assertRaises(ValueError, list, 1263 self.ipv6_interface.network.subnets(-1)) 1264 self.assertRaises(ValueError, list, 1265 self.ipv6_network.subnets(-1)) 1266 1267 def testGetNum_Addresses(self): 1268 self.assertEqual(self.ipv4_network.num_addresses, 256) 1269 self.assertEqual(list(self.ipv4_network.subnets())[0].num_addresses, 1270 128) 1271 self.assertEqual(self.ipv4_network.supernet().num_addresses, 512) 1272 1273 self.assertEqual(self.ipv6_network.num_addresses, 18446744073709551616) 1274 self.assertEqual(list(self.ipv6_network.subnets())[0].num_addresses, 1275 9223372036854775808) 1276 self.assertEqual(self.ipv6_network.supernet().num_addresses, 1277 36893488147419103232) 1278 1279 def testContains(self): 1280 self.assertIn(ipaddress.IPv4Interface('1.2.3.128/25'), 1281 self.ipv4_network) 1282 self.assertNotIn(ipaddress.IPv4Interface('1.2.4.1/24'), 1283 self.ipv4_network) 1284 # We can test addresses and string as well. 1285 addr1 = ipaddress.IPv4Address('1.2.3.37') 1286 self.assertIn(addr1, self.ipv4_network) 1287 # issue 61, bad network comparison on like-ip'd network objects 1288 # with identical broadcast addresses. 1289 self.assertFalse(ipaddress.IPv4Network('1.1.0.0/16').__contains__( 1290 ipaddress.IPv4Network('1.0.0.0/15'))) 1291 1292 def testNth(self): 1293 self.assertEqual(str(self.ipv4_network[5]), '1.2.3.5') 1294 self.assertRaises(IndexError, self.ipv4_network.__getitem__, 256) 1295 1296 self.assertEqual(str(self.ipv6_network[5]), 1297 '2001:658:22a:cafe::5') 1298 self.assertRaises(IndexError, self.ipv6_network.__getitem__, 1 << 64) 1299 1300 def testGetitem(self): 1301 # http://code.google.com/p/ipaddr-py/issues/detail?id=15 1302 addr = ipaddress.IPv4Network('172.31.255.128/255.255.255.240') 1303 self.assertEqual(28, addr.prefixlen) 1304 addr_list = list(addr) 1305 self.assertEqual('172.31.255.128', str(addr_list[0])) 1306 self.assertEqual('172.31.255.128', str(addr[0])) 1307 self.assertEqual('172.31.255.143', str(addr_list[-1])) 1308 self.assertEqual('172.31.255.143', str(addr[-1])) 1309 self.assertEqual(addr_list[-1], addr[-1]) 1310 1311 def testEqual(self): 1312 self.assertTrue(self.ipv4_interface == 1313 ipaddress.IPv4Interface('1.2.3.4/24')) 1314 self.assertFalse(self.ipv4_interface == 1315 ipaddress.IPv4Interface('1.2.3.4/23')) 1316 self.assertFalse(self.ipv4_interface == 1317 ipaddress.IPv6Interface('::1.2.3.4/24')) 1318 self.assertFalse(self.ipv4_interface == '') 1319 self.assertFalse(self.ipv4_interface == []) 1320 self.assertFalse(self.ipv4_interface == 2) 1321 1322 self.assertTrue(self.ipv6_interface == 1323 ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64')) 1324 self.assertFalse(self.ipv6_interface == 1325 ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63')) 1326 self.assertFalse(self.ipv6_interface == 1327 ipaddress.IPv4Interface('1.2.3.4/23')) 1328 self.assertFalse(self.ipv6_interface == '') 1329 self.assertFalse(self.ipv6_interface == []) 1330 self.assertFalse(self.ipv6_interface == 2) 1331 1332 def testNotEqual(self): 1333 self.assertFalse(self.ipv4_interface != 1334 ipaddress.IPv4Interface('1.2.3.4/24')) 1335 self.assertTrue(self.ipv4_interface != 1336 ipaddress.IPv4Interface('1.2.3.4/23')) 1337 self.assertTrue(self.ipv4_interface != 1338 ipaddress.IPv6Interface('::1.2.3.4/24')) 1339 self.assertTrue(self.ipv4_interface != '') 1340 self.assertTrue(self.ipv4_interface != []) 1341 self.assertTrue(self.ipv4_interface != 2) 1342 1343 self.assertTrue(self.ipv4_address != 1344 ipaddress.IPv4Address('1.2.3.5')) 1345 self.assertTrue(self.ipv4_address != '') 1346 self.assertTrue(self.ipv4_address != []) 1347 self.assertTrue(self.ipv4_address != 2) 1348 1349 self.assertFalse(self.ipv6_interface != 1350 ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64')) 1351 self.assertTrue(self.ipv6_interface != 1352 ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63')) 1353 self.assertTrue(self.ipv6_interface != 1354 ipaddress.IPv4Interface('1.2.3.4/23')) 1355 self.assertTrue(self.ipv6_interface != '') 1356 self.assertTrue(self.ipv6_interface != []) 1357 self.assertTrue(self.ipv6_interface != 2) 1358 1359 self.assertTrue(self.ipv6_address != 1360 ipaddress.IPv4Address('1.2.3.4')) 1361 self.assertTrue(self.ipv6_address != '') 1362 self.assertTrue(self.ipv6_address != []) 1363 self.assertTrue(self.ipv6_address != 2) 1364 1365 def testSlash32Constructor(self): 1366 self.assertEqual(str(ipaddress.IPv4Interface( 1367 '1.2.3.4/255.255.255.255')), '1.2.3.4/32') 1368 1369 def testSlash128Constructor(self): 1370 self.assertEqual(str(ipaddress.IPv6Interface('::1/128')), 1371 '::1/128') 1372 1373 def testSlash0Constructor(self): 1374 self.assertEqual(str(ipaddress.IPv4Interface('1.2.3.4/0.0.0.0')), 1375 '1.2.3.4/0') 1376 1377 def testCollapsing(self): 1378 # test only IP addresses including some duplicates 1379 ip1 = ipaddress.IPv4Address('1.1.1.0') 1380 ip2 = ipaddress.IPv4Address('1.1.1.1') 1381 ip3 = ipaddress.IPv4Address('1.1.1.2') 1382 ip4 = ipaddress.IPv4Address('1.1.1.3') 1383 ip5 = ipaddress.IPv4Address('1.1.1.4') 1384 ip6 = ipaddress.IPv4Address('1.1.1.0') 1385 # check that addresses are subsumed properly. 1386 collapsed = ipaddress.collapse_addresses( 1387 [ip1, ip2, ip3, ip4, ip5, ip6]) 1388 self.assertEqual(list(collapsed), 1389 [ipaddress.IPv4Network('1.1.1.0/30'), 1390 ipaddress.IPv4Network('1.1.1.4/32')]) 1391 1392 # test a mix of IP addresses and networks including some duplicates 1393 ip1 = ipaddress.IPv4Address('1.1.1.0') 1394 ip2 = ipaddress.IPv4Address('1.1.1.1') 1395 ip3 = ipaddress.IPv4Address('1.1.1.2') 1396 ip4 = ipaddress.IPv4Address('1.1.1.3') 1397 #ip5 = ipaddress.IPv4Interface('1.1.1.4/30') 1398 #ip6 = ipaddress.IPv4Interface('1.1.1.4/30') 1399 # check that addresses are subsumed properly. 1400 collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4]) 1401 self.assertEqual(list(collapsed), 1402 [ipaddress.IPv4Network('1.1.1.0/30')]) 1403 1404 # test only IP networks 1405 ip1 = ipaddress.IPv4Network('1.1.0.0/24') 1406 ip2 = ipaddress.IPv4Network('1.1.1.0/24') 1407 ip3 = ipaddress.IPv4Network('1.1.2.0/24') 1408 ip4 = ipaddress.IPv4Network('1.1.3.0/24') 1409 ip5 = ipaddress.IPv4Network('1.1.4.0/24') 1410 # stored in no particular order b/c we want CollapseAddr to call 1411 # [].sort 1412 ip6 = ipaddress.IPv4Network('1.1.0.0/22') 1413 # check that addresses are subsumed properly. 1414 collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4, ip5, 1415 ip6]) 1416 self.assertEqual(list(collapsed), 1417 [ipaddress.IPv4Network('1.1.0.0/22'), 1418 ipaddress.IPv4Network('1.1.4.0/24')]) 1419 1420 # test that two addresses are supernet'ed properly 1421 collapsed = ipaddress.collapse_addresses([ip1, ip2]) 1422 self.assertEqual(list(collapsed), 1423 [ipaddress.IPv4Network('1.1.0.0/23')]) 1424 1425 # test same IP networks 1426 ip_same1 = ip_same2 = ipaddress.IPv4Network('1.1.1.1/32') 1427 self.assertEqual(list(ipaddress.collapse_addresses( 1428 [ip_same1, ip_same2])), 1429 [ip_same1]) 1430 1431 # test same IP addresses 1432 ip_same1 = ip_same2 = ipaddress.IPv4Address('1.1.1.1') 1433 self.assertEqual(list(ipaddress.collapse_addresses( 1434 [ip_same1, ip_same2])), 1435 [ipaddress.ip_network('1.1.1.1/32')]) 1436 ip1 = ipaddress.IPv6Network('2001::/100') 1437 ip2 = ipaddress.IPv6Network('2001::/120') 1438 ip3 = ipaddress.IPv6Network('2001::/96') 1439 # test that ipv6 addresses are subsumed properly. 1440 collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3]) 1441 self.assertEqual(list(collapsed), [ip3]) 1442 1443 # the toejam test 1444 addr_tuples = [ 1445 (ipaddress.ip_address('1.1.1.1'), 1446 ipaddress.ip_address('::1')), 1447 (ipaddress.IPv4Network('1.1.0.0/24'), 1448 ipaddress.IPv6Network('2001::/120')), 1449 (ipaddress.IPv4Network('1.1.0.0/32'), 1450 ipaddress.IPv6Network('2001::/128')), 1451 ] 1452 for ip1, ip2 in addr_tuples: 1453 self.assertRaises(TypeError, ipaddress.collapse_addresses, 1454 [ip1, ip2]) 1455 1456 def testSummarizing(self): 1457 #ip = ipaddress.ip_address 1458 #ipnet = ipaddress.ip_network 1459 summarize = ipaddress.summarize_address_range 1460 ip1 = ipaddress.ip_address('1.1.1.0') 1461 ip2 = ipaddress.ip_address('1.1.1.255') 1462 1463 # summarize works only for IPv4 & IPv6 1464 class IPv7Address(ipaddress.IPv6Address): 1465 @property 1466 def version(self): 1467 return 7 1468 ip_invalid1 = IPv7Address('::1') 1469 ip_invalid2 = IPv7Address('::1') 1470 self.assertRaises(ValueError, list, 1471 summarize(ip_invalid1, ip_invalid2)) 1472 # test that a summary over ip4 & ip6 fails 1473 self.assertRaises(TypeError, list, 1474 summarize(ip1, ipaddress.IPv6Address('::1'))) 1475 # test a /24 is summarized properly 1476 self.assertEqual(list(summarize(ip1, ip2))[0], 1477 ipaddress.ip_network('1.1.1.0/24')) 1478 # test an IPv4 range that isn't on a network byte boundary 1479 ip2 = ipaddress.ip_address('1.1.1.8') 1480 self.assertEqual(list(summarize(ip1, ip2)), 1481 [ipaddress.ip_network('1.1.1.0/29'), 1482 ipaddress.ip_network('1.1.1.8')]) 1483 # all! 1484 ip1 = ipaddress.IPv4Address(0) 1485 ip2 = ipaddress.IPv4Address(ipaddress.IPv4Address._ALL_ONES) 1486 self.assertEqual([ipaddress.IPv4Network('0.0.0.0/0')], 1487 list(summarize(ip1, ip2))) 1488 1489 ip1 = ipaddress.ip_address('1::') 1490 ip2 = ipaddress.ip_address('1:ffff:ffff:ffff:ffff:ffff:ffff:ffff') 1491 # test an IPv6 is summarized properly 1492 self.assertEqual(list(summarize(ip1, ip2))[0], 1493 ipaddress.ip_network('1::/16')) 1494 # test an IPv6 range that isn't on a network byte boundary 1495 ip2 = ipaddress.ip_address('2::') 1496 self.assertEqual(list(summarize(ip1, ip2)), 1497 [ipaddress.ip_network('1::/16'), 1498 ipaddress.ip_network('2::/128')]) 1499 1500 # test exception raised when first is greater than last 1501 self.assertRaises(ValueError, list, 1502 summarize(ipaddress.ip_address('1.1.1.0'), 1503 ipaddress.ip_address('1.1.0.0'))) 1504 # test exception raised when first and last aren't IP addresses 1505 self.assertRaises(TypeError, list, 1506 summarize(ipaddress.ip_network('1.1.1.0'), 1507 ipaddress.ip_network('1.1.0.0'))) 1508 self.assertRaises(TypeError, list, 1509 summarize(ipaddress.ip_network('1.1.1.0'), 1510 ipaddress.ip_network('1.1.0.0'))) 1511 # test exception raised when first and last are not same version 1512 self.assertRaises(TypeError, list, 1513 summarize(ipaddress.ip_address('::'), 1514 ipaddress.ip_network('1.1.0.0'))) 1515 1516 def testAddressComparison(self): 1517 self.assertTrue(ipaddress.ip_address('1.1.1.1') <= 1518 ipaddress.ip_address('1.1.1.1')) 1519 self.assertTrue(ipaddress.ip_address('1.1.1.1') <= 1520 ipaddress.ip_address('1.1.1.2')) 1521 self.assertTrue(ipaddress.ip_address('::1') <= 1522 ipaddress.ip_address('::1')) 1523 self.assertTrue(ipaddress.ip_address('::1') <= 1524 ipaddress.ip_address('::2')) 1525 1526 def testInterfaceComparison(self): 1527 self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') == 1528 ipaddress.ip_interface('1.1.1.1/24')) 1529 self.assertTrue(ipaddress.ip_interface('1.1.1.1/16') < 1530 ipaddress.ip_interface('1.1.1.1/24')) 1531 self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') < 1532 ipaddress.ip_interface('1.1.1.2/24')) 1533 self.assertTrue(ipaddress.ip_interface('1.1.1.2/16') < 1534 ipaddress.ip_interface('1.1.1.1/24')) 1535 self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') > 1536 ipaddress.ip_interface('1.1.1.1/16')) 1537 self.assertTrue(ipaddress.ip_interface('1.1.1.2/24') > 1538 ipaddress.ip_interface('1.1.1.1/24')) 1539 self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') > 1540 ipaddress.ip_interface('1.1.1.2/16')) 1541 1542 self.assertTrue(ipaddress.ip_interface('::1/64') == 1543 ipaddress.ip_interface('::1/64')) 1544 self.assertTrue(ipaddress.ip_interface('::1/64') < 1545 ipaddress.ip_interface('::1/80')) 1546 self.assertTrue(ipaddress.ip_interface('::1/64') < 1547 ipaddress.ip_interface('::2/64')) 1548 self.assertTrue(ipaddress.ip_interface('::2/48') < 1549 ipaddress.ip_interface('::1/64')) 1550 self.assertTrue(ipaddress.ip_interface('::1/80') > 1551 ipaddress.ip_interface('::1/64')) 1552 self.assertTrue(ipaddress.ip_interface('::2/64') > 1553 ipaddress.ip_interface('::1/64')) 1554 self.assertTrue(ipaddress.ip_interface('::1/64') > 1555 ipaddress.ip_interface('::2/48')) 1556 1557 def testNetworkComparison(self): 1558 # ip1 and ip2 have the same network address 1559 ip1 = ipaddress.IPv4Network('1.1.1.0/24') 1560 ip2 = ipaddress.IPv4Network('1.1.1.0/32') 1561 ip3 = ipaddress.IPv4Network('1.1.2.0/24') 1562 1563 self.assertTrue(ip1 < ip3) 1564 self.assertTrue(ip3 > ip2) 1565 1566 self.assertEqual(ip1.compare_networks(ip1), 0) 1567 1568 # if addresses are the same, sort by netmask 1569 self.assertEqual(ip1.compare_networks(ip2), -1) 1570 self.assertEqual(ip2.compare_networks(ip1), 1) 1571 1572 self.assertEqual(ip1.compare_networks(ip3), -1) 1573 self.assertEqual(ip3.compare_networks(ip1), 1) 1574 self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key()) 1575 1576 ip1 = ipaddress.IPv6Network('2001:2000::/96') 1577 ip2 = ipaddress.IPv6Network('2001:2001::/96') 1578 ip3 = ipaddress.IPv6Network('2001:ffff:2000::/96') 1579 1580 self.assertTrue(ip1 < ip3) 1581 self.assertTrue(ip3 > ip2) 1582 self.assertEqual(ip1.compare_networks(ip3), -1) 1583 self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key()) 1584 1585 # Test comparing different protocols. 1586 # Should always raise a TypeError. 1587 self.assertRaises(TypeError, 1588 self.ipv4_network.compare_networks, 1589 self.ipv6_network) 1590 ipv6 = ipaddress.IPv6Interface('::/0') 1591 ipv4 = ipaddress.IPv4Interface('0.0.0.0/0') 1592 self.assertRaises(TypeError, ipv4.__lt__, ipv6) 1593 self.assertRaises(TypeError, ipv4.__gt__, ipv6) 1594 self.assertRaises(TypeError, ipv6.__lt__, ipv4) 1595 self.assertRaises(TypeError, ipv6.__gt__, ipv4) 1596 1597 # Regression test for issue 19. 1598 ip1 = ipaddress.ip_network('10.1.2.128/25') 1599 self.assertFalse(ip1 < ip1) 1600 self.assertFalse(ip1 > ip1) 1601 ip2 = ipaddress.ip_network('10.1.3.0/24') 1602 self.assertTrue(ip1 < ip2) 1603 self.assertFalse(ip2 < ip1) 1604 self.assertFalse(ip1 > ip2) 1605 self.assertTrue(ip2 > ip1) 1606 ip3 = ipaddress.ip_network('10.1.3.0/25') 1607 self.assertTrue(ip2 < ip3) 1608 self.assertFalse(ip3 < ip2) 1609 self.assertFalse(ip2 > ip3) 1610 self.assertTrue(ip3 > ip2) 1611 1612 # Regression test for issue 28. 1613 ip1 = ipaddress.ip_network('10.10.10.0/31') 1614 ip2 = ipaddress.ip_network('10.10.10.0') 1615 ip3 = ipaddress.ip_network('10.10.10.2/31') 1616 ip4 = ipaddress.ip_network('10.10.10.2') 1617 sorted = [ip1, ip2, ip3, ip4] 1618 unsorted = [ip2, ip4, ip1, ip3] 1619 unsorted.sort() 1620 self.assertEqual(sorted, unsorted) 1621 unsorted = [ip4, ip1, ip3, ip2] 1622 unsorted.sort() 1623 self.assertEqual(sorted, unsorted) 1624 self.assertIs(ip1.__lt__(ipaddress.ip_address('10.10.10.0')), 1625 NotImplemented) 1626 self.assertIs(ip2.__lt__(ipaddress.ip_address('10.10.10.0')), 1627 NotImplemented) 1628 1629 # <=, >= 1630 self.assertTrue(ipaddress.ip_network('1.1.1.1') <= 1631 ipaddress.ip_network('1.1.1.1')) 1632 self.assertTrue(ipaddress.ip_network('1.1.1.1') <= 1633 ipaddress.ip_network('1.1.1.2')) 1634 self.assertFalse(ipaddress.ip_network('1.1.1.2') <= 1635 ipaddress.ip_network('1.1.1.1')) 1636 self.assertTrue(ipaddress.ip_network('::1') <= 1637 ipaddress.ip_network('::1')) 1638 self.assertTrue(ipaddress.ip_network('::1') <= 1639 ipaddress.ip_network('::2')) 1640 self.assertFalse(ipaddress.ip_network('::2') <= 1641 ipaddress.ip_network('::1')) 1642 1643 def testStrictNetworks(self): 1644 self.assertRaises(ValueError, ipaddress.ip_network, '192.168.1.1/24') 1645 self.assertRaises(ValueError, ipaddress.ip_network, '::1/120') 1646 1647 def testOverlaps(self): 1648 other = ipaddress.IPv4Network('1.2.3.0/30') 1649 other2 = ipaddress.IPv4Network('1.2.2.0/24') 1650 other3 = ipaddress.IPv4Network('1.2.2.64/26') 1651 self.assertTrue(self.ipv4_network.overlaps(other)) 1652 self.assertFalse(self.ipv4_network.overlaps(other2)) 1653 self.assertTrue(other2.overlaps(other3)) 1654 1655 def testEmbeddedIpv4(self): 1656 ipv4_string = '192.168.0.1' 1657 ipv4 = ipaddress.IPv4Interface(ipv4_string) 1658 v4compat_ipv6 = ipaddress.IPv6Interface('::%s' % ipv4_string) 1659 self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip)) 1660 v4mapped_ipv6 = ipaddress.IPv6Interface('::ffff:%s' % ipv4_string) 1661 self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip) 1662 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface, 1663 '2001:1.1.1.1:1.1.1.1') 1664 1665 # Issue 67: IPv6 with embedded IPv4 address not recognized. 1666 def testIPv6AddressTooLarge(self): 1667 # RFC4291 2.5.5.2 1668 self.assertEqual(ipaddress.ip_address('::FFFF:192.0.2.1'), 1669 ipaddress.ip_address('::FFFF:c000:201')) 1670 # RFC4291 2.2 (part 3) x::d.d.d.d 1671 self.assertEqual(ipaddress.ip_address('FFFF::192.0.2.1'), 1672 ipaddress.ip_address('FFFF::c000:201')) 1673 1674 def testIPVersion(self): 1675 self.assertEqual(self.ipv4_address.version, 4) 1676 self.assertEqual(self.ipv6_address.version, 6) 1677 1678 def testMaxPrefixLength(self): 1679 self.assertEqual(self.ipv4_interface.max_prefixlen, 32) 1680 self.assertEqual(self.ipv6_interface.max_prefixlen, 128) 1681 1682 def testPacked(self): 1683 self.assertEqual(self.ipv4_address.packed, 1684 b'\x01\x02\x03\x04') 1685 self.assertEqual(ipaddress.IPv4Interface('255.254.253.252').packed, 1686 b'\xff\xfe\xfd\xfc') 1687 self.assertEqual(self.ipv6_address.packed, 1688 b'\x20\x01\x06\x58\x02\x2a\xca\xfe' 1689 b'\x02\x00\x00\x00\x00\x00\x00\x01') 1690 self.assertEqual(ipaddress.IPv6Interface('ffff:2:3:4:ffff::').packed, 1691 b'\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff' 1692 + b'\x00' * 6) 1693 self.assertEqual(ipaddress.IPv6Interface('::1:0:0:0:0').packed, 1694 b'\x00' * 6 + b'\x00\x01' + b'\x00' * 8) 1695 1696 def testIpType(self): 1697 ipv4net = ipaddress.ip_network('1.2.3.4') 1698 ipv4addr = ipaddress.ip_address('1.2.3.4') 1699 ipv6net = ipaddress.ip_network('::1.2.3.4') 1700 ipv6addr = ipaddress.ip_address('::1.2.3.4') 1701 self.assertEqual(ipaddress.IPv4Network, type(ipv4net)) 1702 self.assertEqual(ipaddress.IPv4Address, type(ipv4addr)) 1703 self.assertEqual(ipaddress.IPv6Network, type(ipv6net)) 1704 self.assertEqual(ipaddress.IPv6Address, type(ipv6addr)) 1705 1706 def testReservedIpv4(self): 1707 # test networks 1708 self.assertEqual(True, ipaddress.ip_interface( 1709 '224.1.1.1/31').is_multicast) 1710 self.assertEqual(False, ipaddress.ip_network('240.0.0.0').is_multicast) 1711 self.assertEqual(True, ipaddress.ip_network('240.0.0.0').is_reserved) 1712 1713 self.assertEqual(True, ipaddress.ip_interface( 1714 '192.168.1.1/17').is_private) 1715 self.assertEqual(False, ipaddress.ip_network('192.169.0.0').is_private) 1716 self.assertEqual(True, ipaddress.ip_network( 1717 '10.255.255.255').is_private) 1718 self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_private) 1719 self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_reserved) 1720 self.assertEqual(True, ipaddress.ip_network( 1721 '172.31.255.255').is_private) 1722 self.assertEqual(False, ipaddress.ip_network('172.32.0.0').is_private) 1723 self.assertEqual(True, 1724 ipaddress.ip_network('169.254.1.0/24').is_link_local) 1725 1726 self.assertEqual(True, 1727 ipaddress.ip_interface( 1728 '169.254.100.200/24').is_link_local) 1729 self.assertEqual(False, 1730 ipaddress.ip_interface( 1731 '169.255.100.200/24').is_link_local) 1732 1733 self.assertEqual(True, 1734 ipaddress.ip_network( 1735 '127.100.200.254/32').is_loopback) 1736 self.assertEqual(True, ipaddress.ip_network( 1737 '127.42.0.0/16').is_loopback) 1738 self.assertEqual(False, ipaddress.ip_network('128.0.0.0').is_loopback) 1739 self.assertEqual(False, 1740 ipaddress.ip_network('100.64.0.0/10').is_private) 1741 self.assertEqual(False, ipaddress.ip_network('100.64.0.0/10').is_global) 1742 1743 self.assertEqual(True, 1744 ipaddress.ip_network('192.0.2.128/25').is_private) 1745 self.assertEqual(True, 1746 ipaddress.ip_network('192.0.3.0/24').is_global) 1747 1748 # test addresses 1749 self.assertEqual(True, ipaddress.ip_address('0.0.0.0').is_unspecified) 1750 self.assertEqual(True, ipaddress.ip_address('224.1.1.1').is_multicast) 1751 self.assertEqual(False, ipaddress.ip_address('240.0.0.0').is_multicast) 1752 self.assertEqual(True, ipaddress.ip_address('240.0.0.1').is_reserved) 1753 self.assertEqual(False, 1754 ipaddress.ip_address('239.255.255.255').is_reserved) 1755 1756 self.assertEqual(True, ipaddress.ip_address('192.168.1.1').is_private) 1757 self.assertEqual(False, ipaddress.ip_address('192.169.0.0').is_private) 1758 self.assertEqual(True, ipaddress.ip_address( 1759 '10.255.255.255').is_private) 1760 self.assertEqual(False, ipaddress.ip_address('11.0.0.0').is_private) 1761 self.assertEqual(True, ipaddress.ip_address( 1762 '172.31.255.255').is_private) 1763 self.assertEqual(False, ipaddress.ip_address('172.32.0.0').is_private) 1764 1765 self.assertEqual(True, 1766 ipaddress.ip_address('169.254.100.200').is_link_local) 1767 self.assertEqual(False, 1768 ipaddress.ip_address('169.255.100.200').is_link_local) 1769 1770 self.assertTrue(ipaddress.ip_address('192.0.7.1').is_global) 1771 self.assertFalse(ipaddress.ip_address('203.0.113.1').is_global) 1772 1773 self.assertEqual(True, 1774 ipaddress.ip_address('127.100.200.254').is_loopback) 1775 self.assertEqual(True, ipaddress.ip_address('127.42.0.0').is_loopback) 1776 self.assertEqual(False, ipaddress.ip_address('128.0.0.0').is_loopback) 1777 self.assertEqual(True, ipaddress.ip_network('0.0.0.0').is_unspecified) 1778 1779 def testReservedIpv6(self): 1780 1781 self.assertEqual(True, ipaddress.ip_network('ffff::').is_multicast) 1782 self.assertEqual(True, ipaddress.ip_network(2**128 - 1).is_multicast) 1783 self.assertEqual(True, ipaddress.ip_network('ff00::').is_multicast) 1784 self.assertEqual(False, ipaddress.ip_network('fdff::').is_multicast) 1785 1786 self.assertEqual(True, ipaddress.ip_network('fecf::').is_site_local) 1787 self.assertEqual(True, ipaddress.ip_network( 1788 'feff:ffff:ffff:ffff::').is_site_local) 1789 self.assertEqual(False, ipaddress.ip_network( 1790 'fbf:ffff::').is_site_local) 1791 self.assertEqual(False, ipaddress.ip_network('ff00::').is_site_local) 1792 1793 self.assertEqual(True, ipaddress.ip_network('fc00::').is_private) 1794 self.assertEqual(True, ipaddress.ip_network( 1795 'fc00:ffff:ffff:ffff::').is_private) 1796 self.assertEqual(False, ipaddress.ip_network('fbff:ffff::').is_private) 1797 self.assertEqual(False, ipaddress.ip_network('fe00::').is_private) 1798 1799 self.assertEqual(True, ipaddress.ip_network('fea0::').is_link_local) 1800 self.assertEqual(True, ipaddress.ip_network( 1801 'febf:ffff::').is_link_local) 1802 self.assertEqual(False, ipaddress.ip_network( 1803 'fe7f:ffff::').is_link_local) 1804 self.assertEqual(False, ipaddress.ip_network('fec0::').is_link_local) 1805 1806 self.assertEqual(True, ipaddress.ip_interface('0:0::0:01').is_loopback) 1807 self.assertEqual(False, ipaddress.ip_interface('::1/127').is_loopback) 1808 self.assertEqual(False, ipaddress.ip_network('::').is_loopback) 1809 self.assertEqual(False, ipaddress.ip_network('::2').is_loopback) 1810 1811 self.assertEqual(True, ipaddress.ip_network('0::0').is_unspecified) 1812 self.assertEqual(False, ipaddress.ip_network('::1').is_unspecified) 1813 self.assertEqual(False, ipaddress.ip_network('::/127').is_unspecified) 1814 1815 self.assertEqual(True, 1816 ipaddress.ip_network('2001::1/128').is_private) 1817 self.assertEqual(True, 1818 ipaddress.ip_network('200::1/128').is_global) 1819 # test addresses 1820 self.assertEqual(True, ipaddress.ip_address('ffff::').is_multicast) 1821 self.assertEqual(True, ipaddress.ip_address(2**128 - 1).is_multicast) 1822 self.assertEqual(True, ipaddress.ip_address('ff00::').is_multicast) 1823 self.assertEqual(False, ipaddress.ip_address('fdff::').is_multicast) 1824 1825 self.assertEqual(True, ipaddress.ip_address('fecf::').is_site_local) 1826 self.assertEqual(True, ipaddress.ip_address( 1827 'feff:ffff:ffff:ffff::').is_site_local) 1828 self.assertEqual(False, ipaddress.ip_address( 1829 'fbf:ffff::').is_site_local) 1830 self.assertEqual(False, ipaddress.ip_address('ff00::').is_site_local) 1831 1832 self.assertEqual(True, ipaddress.ip_address('fc00::').is_private) 1833 self.assertEqual(True, ipaddress.ip_address( 1834 'fc00:ffff:ffff:ffff::').is_private) 1835 self.assertEqual(False, ipaddress.ip_address('fbff:ffff::').is_private) 1836 self.assertEqual(False, ipaddress.ip_address('fe00::').is_private) 1837 1838 self.assertEqual(True, ipaddress.ip_address('fea0::').is_link_local) 1839 self.assertEqual(True, ipaddress.ip_address( 1840 'febf:ffff::').is_link_local) 1841 self.assertEqual(False, ipaddress.ip_address( 1842 'fe7f:ffff::').is_link_local) 1843 self.assertEqual(False, ipaddress.ip_address('fec0::').is_link_local) 1844 1845 self.assertEqual(True, ipaddress.ip_address('0:0::0:01').is_loopback) 1846 self.assertEqual(True, ipaddress.ip_address('::1').is_loopback) 1847 self.assertEqual(False, ipaddress.ip_address('::2').is_loopback) 1848 1849 self.assertEqual(True, ipaddress.ip_address('0::0').is_unspecified) 1850 self.assertEqual(False, ipaddress.ip_address('::1').is_unspecified) 1851 1852 # some generic IETF reserved addresses 1853 self.assertEqual(True, ipaddress.ip_address('100::').is_reserved) 1854 self.assertEqual(True, ipaddress.ip_network('4000::1/128').is_reserved) 1855 1856 def testIpv4Mapped(self): 1857 self.assertEqual( 1858 ipaddress.ip_address('::ffff:192.168.1.1').ipv4_mapped, 1859 ipaddress.ip_address('192.168.1.1')) 1860 self.assertEqual(ipaddress.ip_address('::c0a8:101').ipv4_mapped, None) 1861 self.assertEqual(ipaddress.ip_address('::ffff:c0a8:101').ipv4_mapped, 1862 ipaddress.ip_address('192.168.1.1')) 1863 1864 def testAddrExclude(self): 1865 addr1 = ipaddress.ip_network('10.1.1.0/24') 1866 addr2 = ipaddress.ip_network('10.1.1.0/26') 1867 addr3 = ipaddress.ip_network('10.2.1.0/24') 1868 addr4 = ipaddress.ip_address('10.1.1.0') 1869 addr5 = ipaddress.ip_network('2001:db8::0/32') 1870 addr6 = ipaddress.ip_network('10.1.1.5/32') 1871 self.assertEqual(sorted(list(addr1.address_exclude(addr2))), 1872 [ipaddress.ip_network('10.1.1.64/26'), 1873 ipaddress.ip_network('10.1.1.128/25')]) 1874 self.assertRaises(ValueError, list, addr1.address_exclude(addr3)) 1875 self.assertRaises(TypeError, list, addr1.address_exclude(addr4)) 1876 self.assertRaises(TypeError, list, addr1.address_exclude(addr5)) 1877 self.assertEqual(list(addr1.address_exclude(addr1)), []) 1878 self.assertEqual(sorted(list(addr1.address_exclude(addr6))), 1879 [ipaddress.ip_network('10.1.1.0/30'), 1880 ipaddress.ip_network('10.1.1.4/32'), 1881 ipaddress.ip_network('10.1.1.6/31'), 1882 ipaddress.ip_network('10.1.1.8/29'), 1883 ipaddress.ip_network('10.1.1.16/28'), 1884 ipaddress.ip_network('10.1.1.32/27'), 1885 ipaddress.ip_network('10.1.1.64/26'), 1886 ipaddress.ip_network('10.1.1.128/25')]) 1887 1888 def testHash(self): 1889 self.assertEqual(hash(ipaddress.ip_interface('10.1.1.0/24')), 1890 hash(ipaddress.ip_interface('10.1.1.0/24'))) 1891 self.assertEqual(hash(ipaddress.ip_network('10.1.1.0/24')), 1892 hash(ipaddress.ip_network('10.1.1.0/24'))) 1893 self.assertEqual(hash(ipaddress.ip_address('10.1.1.0')), 1894 hash(ipaddress.ip_address('10.1.1.0'))) 1895 # i70 1896 self.assertEqual(hash(ipaddress.ip_address('1.2.3.4')), 1897 hash(ipaddress.ip_address( 1898 int(ipaddress.ip_address('1.2.3.4')._ip)))) 1899 ip1 = ipaddress.ip_address('10.1.1.0') 1900 ip2 = ipaddress.ip_address('1::') 1901 dummy = {} 1902 dummy[self.ipv4_address] = None 1903 dummy[self.ipv6_address] = None 1904 dummy[ip1] = None 1905 dummy[ip2] = None 1906 self.assertIn(self.ipv4_address, dummy) 1907 self.assertIn(ip2, dummy) 1908 1909 def testIPBases(self): 1910 net = self.ipv4_network 1911 self.assertEqual('1.2.3.0/24', net.compressed) 1912 net = self.ipv6_network 1913 self.assertRaises(ValueError, net._string_from_ip_int, 2**128 + 1) 1914 1915 def testIPv6NetworkHelpers(self): 1916 net = self.ipv6_network 1917 self.assertEqual('2001:658:22a:cafe::/64', net.with_prefixlen) 1918 self.assertEqual('2001:658:22a:cafe::/ffff:ffff:ffff:ffff::', 1919 net.with_netmask) 1920 self.assertEqual('2001:658:22a:cafe::/::ffff:ffff:ffff:ffff', 1921 net.with_hostmask) 1922 self.assertEqual('2001:658:22a:cafe::/64', str(net)) 1923 1924 def testIPv4NetworkHelpers(self): 1925 net = self.ipv4_network 1926 self.assertEqual('1.2.3.0/24', net.with_prefixlen) 1927 self.assertEqual('1.2.3.0/255.255.255.0', net.with_netmask) 1928 self.assertEqual('1.2.3.0/0.0.0.255', net.with_hostmask) 1929 self.assertEqual('1.2.3.0/24', str(net)) 1930 1931 def testCopyConstructor(self): 1932 addr1 = ipaddress.ip_network('10.1.1.0/24') 1933 addr2 = ipaddress.ip_network(addr1) 1934 addr3 = ipaddress.ip_interface('2001:658:22a:cafe:200::1/64') 1935 addr4 = ipaddress.ip_interface(addr3) 1936 addr5 = ipaddress.IPv4Address('1.1.1.1') 1937 addr6 = ipaddress.IPv6Address('2001:658:22a:cafe:200::1') 1938 1939 self.assertEqual(addr1, addr2) 1940 self.assertEqual(addr3, addr4) 1941 self.assertEqual(addr5, ipaddress.IPv4Address(addr5)) 1942 self.assertEqual(addr6, ipaddress.IPv6Address(addr6)) 1943 1944 def testCompressIPv6Address(self): 1945 test_addresses = { 1946 '1:2:3:4:5:6:7:8': '1:2:3:4:5:6:7:8/128', 1947 '2001:0:0:4:0:0:0:8': '2001:0:0:4::8/128', 1948 '2001:0:0:4:5:6:7:8': '2001::4:5:6:7:8/128', 1949 '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128', 1950 '0:0:3:0:0:0:0:ffff': '0:0:3::ffff/128', 1951 '0:0:0:4:0:0:0:ffff': '::4:0:0:0:ffff/128', 1952 '0:0:0:0:5:0:0:ffff': '::5:0:0:ffff/128', 1953 '1:0:0:4:0:0:7:8': '1::4:0:0:7:8/128', 1954 '0:0:0:0:0:0:0:0': '::/128', 1955 '0:0:0:0:0:0:0:0/0': '::/0', 1956 '0:0:0:0:0:0:0:1': '::1/128', 1957 '2001:0658:022a:cafe:0000:0000:0000:0000/66': 1958 '2001:658:22a:cafe::/66', 1959 '::1.2.3.4': '::102:304/128', 1960 '1:2:3:4:5:ffff:1.2.3.4': '1:2:3:4:5:ffff:102:304/128', 1961 '::7:6:5:4:3:2:1': '0:7:6:5:4:3:2:1/128', 1962 '::7:6:5:4:3:2:0': '0:7:6:5:4:3:2:0/128', 1963 '7:6:5:4:3:2:1::': '7:6:5:4:3:2:1:0/128', 1964 '0:6:5:4:3:2:1::': '0:6:5:4:3:2:1:0/128', 1965 } 1966 for uncompressed, compressed in list(test_addresses.items()): 1967 self.assertEqual(compressed, str(ipaddress.IPv6Interface( 1968 uncompressed))) 1969 1970 def testExplodeShortHandIpStr(self): 1971 addr1 = ipaddress.IPv6Interface('2001::1') 1972 addr2 = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1') 1973 addr3 = ipaddress.IPv6Network('2001::/96') 1974 addr4 = ipaddress.IPv4Address('192.168.178.1') 1975 self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0001/128', 1976 addr1.exploded) 1977 self.assertEqual('0000:0000:0000:0000:0000:0000:0000:0001/128', 1978 ipaddress.IPv6Interface('::1/128').exploded) 1979 # issue 77 1980 self.assertEqual('2001:0000:5ef5:79fd:0000:059d:a0e5:0ba1', 1981 addr2.exploded) 1982 self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0000/96', 1983 addr3.exploded) 1984 self.assertEqual('192.168.178.1', addr4.exploded) 1985 1986 def testReversePointer(self): 1987 addr1 = ipaddress.IPv4Address('127.0.0.1') 1988 addr2 = ipaddress.IPv6Address('2001:db8::1') 1989 self.assertEqual('1.0.0.127.in-addr.arpa', addr1.reverse_pointer) 1990 self.assertEqual('1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.' + 1991 'b.d.0.1.0.0.2.ip6.arpa', 1992 addr2.reverse_pointer) 1993 1994 def testIntRepresentation(self): 1995 self.assertEqual(16909060, int(self.ipv4_address)) 1996 self.assertEqual(42540616829182469433547762482097946625, 1997 int(self.ipv6_address)) 1998 1999 def testForceVersion(self): 2000 self.assertEqual(ipaddress.ip_network(1).version, 4) 2001 self.assertEqual(ipaddress.IPv6Network(1).version, 6) 2002 2003 def testWithStar(self): 2004 self.assertEqual(self.ipv4_interface.with_prefixlen, "1.2.3.4/24") 2005 self.assertEqual(self.ipv4_interface.with_netmask, 2006 "1.2.3.4/255.255.255.0") 2007 self.assertEqual(self.ipv4_interface.with_hostmask, 2008 "1.2.3.4/0.0.0.255") 2009 2010 self.assertEqual(self.ipv6_interface.with_prefixlen, 2011 '2001:658:22a:cafe:200::1/64') 2012 self.assertEqual(self.ipv6_interface.with_netmask, 2013 '2001:658:22a:cafe:200::1/ffff:ffff:ffff:ffff::') 2014 # this probably don't make much sense, but it's included for 2015 # compatibility with ipv4 2016 self.assertEqual(self.ipv6_interface.with_hostmask, 2017 '2001:658:22a:cafe:200::1/::ffff:ffff:ffff:ffff') 2018 2019 def testNetworkElementCaching(self): 2020 # V4 - make sure we're empty 2021 self.assertNotIn('broadcast_address', self.ipv4_network.__dict__) 2022 self.assertNotIn('hostmask', self.ipv4_network.__dict__) 2023 2024 # V4 - populate and test 2025 self.assertEqual(self.ipv4_network.broadcast_address, 2026 ipaddress.IPv4Address('1.2.3.255')) 2027 self.assertEqual(self.ipv4_network.hostmask, 2028 ipaddress.IPv4Address('0.0.0.255')) 2029 2030 # V4 - check we're cached 2031 self.assertIn('broadcast_address', self.ipv4_network.__dict__) 2032 self.assertIn('hostmask', self.ipv4_network.__dict__) 2033 2034 # V6 - make sure we're empty 2035 self.assertNotIn('broadcast_address', self.ipv6_network.__dict__) 2036 self.assertNotIn('hostmask', self.ipv6_network.__dict__) 2037 2038 # V6 - populate and test 2039 self.assertEqual(self.ipv6_network.network_address, 2040 ipaddress.IPv6Address('2001:658:22a:cafe::')) 2041 self.assertEqual(self.ipv6_interface.network.network_address, 2042 ipaddress.IPv6Address('2001:658:22a:cafe::')) 2043 2044 self.assertEqual( 2045 self.ipv6_network.broadcast_address, 2046 ipaddress.IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff')) 2047 self.assertEqual(self.ipv6_network.hostmask, 2048 ipaddress.IPv6Address('::ffff:ffff:ffff:ffff')) 2049 self.assertEqual( 2050 self.ipv6_interface.network.broadcast_address, 2051 ipaddress.IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff')) 2052 self.assertEqual(self.ipv6_interface.network.hostmask, 2053 ipaddress.IPv6Address('::ffff:ffff:ffff:ffff')) 2054 2055 # V6 - check we're cached 2056 self.assertIn('broadcast_address', self.ipv6_network.__dict__) 2057 self.assertIn('hostmask', self.ipv6_network.__dict__) 2058 self.assertIn('broadcast_address', self.ipv6_interface.network.__dict__) 2059 self.assertIn('hostmask', self.ipv6_interface.network.__dict__) 2060 2061 def testTeredo(self): 2062 # stolen from wikipedia 2063 server = ipaddress.IPv4Address('65.54.227.120') 2064 client = ipaddress.IPv4Address('192.0.2.45') 2065 teredo_addr = '2001:0000:4136:e378:8000:63bf:3fff:fdd2' 2066 self.assertEqual((server, client), 2067 ipaddress.ip_address(teredo_addr).teredo) 2068 bad_addr = '2000::4136:e378:8000:63bf:3fff:fdd2' 2069 self.assertFalse(ipaddress.ip_address(bad_addr).teredo) 2070 bad_addr = '2001:0001:4136:e378:8000:63bf:3fff:fdd2' 2071 self.assertFalse(ipaddress.ip_address(bad_addr).teredo) 2072 2073 # i77 2074 teredo_addr = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1') 2075 self.assertEqual((ipaddress.IPv4Address('94.245.121.253'), 2076 ipaddress.IPv4Address('95.26.244.94')), 2077 teredo_addr.teredo) 2078 2079 def testsixtofour(self): 2080 sixtofouraddr = ipaddress.ip_address('2002:ac1d:2d64::1') 2081 bad_addr = ipaddress.ip_address('2000:ac1d:2d64::1') 2082 self.assertEqual(ipaddress.IPv4Address('172.29.45.100'), 2083 sixtofouraddr.sixtofour) 2084 self.assertFalse(bad_addr.sixtofour) 2085 2086 # issue41004 Hash collisions in IPv4Interface and IPv6Interface 2087 def testV4HashIsNotConstant(self): 2088 ipv4_address1 = ipaddress.IPv4Interface("1.2.3.4") 2089 ipv4_address2 = ipaddress.IPv4Interface("2.3.4.5") 2090 self.assertNotEqual(ipv4_address1.__hash__(), ipv4_address2.__hash__()) 2091 2092 # issue41004 Hash collisions in IPv4Interface and IPv6Interface 2093 def testV6HashIsNotConstant(self): 2094 ipv6_address1 = ipaddress.IPv6Interface("2001:658:22a:cafe:200:0:0:1") 2095 ipv6_address2 = ipaddress.IPv6Interface("2001:658:22a:cafe:200:0:0:2") 2096 self.assertNotEqual(ipv6_address1.__hash__(), ipv6_address2.__hash__()) 2097 2098 2099if __name__ == '__main__': 2100 unittest.main() 2101