Debian Codegraph @

Lib/test/test_ipaddress.py

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