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