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