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