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