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