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