blob: 619fa4451f4e105ddf87bb4e1e53cab8f8acc4cb [file] [log] [blame]
Nick Coghlandc9b2552012-05-20 21:01:57 +10001# Copyright 2007 Google Inc.
2# Licensed to PSF under a Contributor Agreement.
Nick Coghlandc9b2552012-05-20 21:01:57 +10003
Nick Coghlanaff73f92012-05-27 00:57:25 +10004"""Unittest for ipaddress module."""
Nick Coghlandc9b2552012-05-20 21:01:57 +10005
6
7import unittest
Nick Coghlan36f8dcd2012-07-07 19:23:53 +10008import re
9import contextlib
Nick Coghlandc9b2552012-05-20 21:01:57 +100010import ipaddress
11
Nick Coghlan07c4e332012-07-08 23:06:45 +100012class BaseTestCase(unittest.TestCase):
Nick Coghlan36f8dcd2012-07-07 19:23:53 +100013 # One big change in ipaddress over the original ipaddr module is
14 # error reporting that tries to assume users *don't know the rules*
15 # for what constitutes an RFC compliant IP address
16
Nick Coghlan07c4e332012-07-08 23:06:45 +100017 # Ensuring these errors are emitted correctly in all relevant cases
18 # meant moving to a more systematic test structure that allows the
19 # test structure to map more directly to the module structure
20
Nick Coghlan36f8dcd2012-07-07 19:23:53 +100021 # Note that if the constructors are refactored so that addresses with
22 # multiple problems get classified differently, that's OK - just
23 # move the affected examples to the newly appropriate test case.
24
Nick Coghlan07c4e332012-07-08 23:06:45 +100025 # There is some duplication between the original relatively ad hoc
26 # test suite and the new systematic tests. While some redundancy in
27 # testing is considered preferable to accidentally deleting a valid
28 # test, the original test suite will likely be reduced over time as
29 # redundant tests are identified.
Nick Coghlan36f8dcd2012-07-07 19:23:53 +100030
Nick Coghlan297b1432012-07-08 17:11:04 +100031 @property
32 def factory(self):
33 raise NotImplementedError
34
Nick Coghlan36f8dcd2012-07-07 19:23:53 +100035 @contextlib.contextmanager
36 def assertCleanError(self, exc_type, details, *args):
37 """
38 Ensure exception does not display a context by default
39
40 Wraps unittest.TestCase.assertRaisesRegex
41 """
42 if args:
43 details = details % args
44 cm = self.assertRaisesRegex(exc_type, details)
45 with cm as exc:
46 yield exc
47 # Ensure we produce clean tracebacks on failure
48 if exc.exception.__context__ is not None:
49 self.assertTrue(exc.exception.__suppress_context__)
50
51 def assertAddressError(self, details, *args):
52 """Ensure a clean AddressValueError"""
53 return self.assertCleanError(ipaddress.AddressValueError,
54 details, *args)
55
56 def assertNetmaskError(self, details, *args):
57 """Ensure a clean NetmaskValueError"""
58 return self.assertCleanError(ipaddress.NetmaskValueError,
59 details, *args)
60
Nick Coghlan07c4e332012-07-08 23:06:45 +100061 def assertInstancesEqual(self, lhs, rhs):
62 """Check constructor arguments produce equivalent instances"""
63 self.assertEqual(self.factory(lhs), self.factory(rhs))
64
65class CommonTestMixin:
Nick Coghlan36f8dcd2012-07-07 19:23:53 +100066
67 def test_empty_address(self):
68 with self.assertAddressError("Address cannot be empty"):
Nick Coghlan297b1432012-07-08 17:11:04 +100069 self.factory("")
70
71 def test_floats_rejected(self):
72 with self.assertAddressError(re.escape(repr("1.0"))):
73 self.factory(1.0)
74
Nick Coghlan07c4e332012-07-08 23:06:45 +100075class CommonTestMixin_v4(CommonTestMixin):
76
77 def test_leading_zeros(self):
78 self.assertInstancesEqual("000.000.000.000", "0.0.0.0")
79 self.assertInstancesEqual("192.168.000.001", "192.168.0.1")
80
81 def test_int(self):
82 self.assertInstancesEqual(0, "0.0.0.0")
83 self.assertInstancesEqual(3232235521, "192.168.0.1")
84
85 def test_packed(self):
86 self.assertInstancesEqual(bytes.fromhex("00000000"), "0.0.0.0")
87 self.assertInstancesEqual(bytes.fromhex("c0a80001"), "192.168.0.1")
Nick Coghlan297b1432012-07-08 17:11:04 +100088
89 def test_negative_ints_rejected(self):
90 msg = "-1 (< 0) is not permitted as an IPv4 address"
91 with self.assertAddressError(re.escape(msg)):
92 self.factory(-1)
93
94 def test_large_ints_rejected(self):
95 msg = "%d (>= 2**32) is not permitted as an IPv4 address"
96 with self.assertAddressError(re.escape(msg % 2**32)):
97 self.factory(2**32)
98
99 def test_bad_packed_length(self):
100 def assertBadLength(length):
Nick Coghlan07c4e332012-07-08 23:06:45 +1000101 addr = bytes(length)
Nick Coghlan297b1432012-07-08 17:11:04 +1000102 msg = "%r (len %d != 4) is not permitted as an IPv4 address"
103 with self.assertAddressError(re.escape(msg % (addr, length))):
104 self.factory(addr)
105
106 assertBadLength(3)
107 assertBadLength(5)
108
Nick Coghlan07c4e332012-07-08 23:06:45 +1000109class CommonTestMixin_v6(CommonTestMixin):
110
111 def test_leading_zeros(self):
112 self.assertInstancesEqual("0000::0000", "::")
113 self.assertInstancesEqual("000::c0a8:0001", "::c0a8:1")
114
115 def test_int(self):
116 self.assertInstancesEqual(0, "::")
117 self.assertInstancesEqual(3232235521, "::c0a8:1")
118
119 def test_packed(self):
120 addr = bytes(12) + bytes.fromhex("00000000")
121 self.assertInstancesEqual(addr, "::")
122 addr = bytes(12) + bytes.fromhex("c0a80001")
123 self.assertInstancesEqual(addr, "::c0a8:1")
124 addr = bytes.fromhex("c0a80001") + bytes(12)
125 self.assertInstancesEqual(addr, "c0a8:1::")
Nick Coghlan297b1432012-07-08 17:11:04 +1000126
127 def test_negative_ints_rejected(self):
128 msg = "-1 (< 0) is not permitted as an IPv6 address"
129 with self.assertAddressError(re.escape(msg)):
130 self.factory(-1)
131
132 def test_large_ints_rejected(self):
133 msg = "%d (>= 2**128) is not permitted as an IPv6 address"
134 with self.assertAddressError(re.escape(msg % 2**128)):
135 self.factory(2**128)
136
137 def test_bad_packed_length(self):
138 def assertBadLength(length):
Nick Coghlan07c4e332012-07-08 23:06:45 +1000139 addr = bytes(length)
Nick Coghlan297b1432012-07-08 17:11:04 +1000140 msg = "%r (len %d != 16) is not permitted as an IPv6 address"
141 with self.assertAddressError(re.escape(msg % (addr, length))):
142 self.factory(addr)
143 self.factory(addr)
144
145 assertBadLength(15)
146 assertBadLength(17)
147
148
Nick Coghlan07c4e332012-07-08 23:06:45 +1000149class AddressTestCase_v4(BaseTestCase, CommonTestMixin_v4):
Nick Coghlan297b1432012-07-08 17:11:04 +1000150 factory = ipaddress.IPv4Address
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000151
152 def test_network_passed_as_address(self):
153 addr = "127.0.0.1/24"
154 with self.assertAddressError("Unexpected '/' in %r", addr):
155 ipaddress.IPv4Address(addr)
156
157 def test_bad_address_split(self):
158 def assertBadSplit(addr):
159 with self.assertAddressError("Expected 4 octets in %r", addr):
160 ipaddress.IPv4Address(addr)
161
162 assertBadSplit("127.0.1")
163 assertBadSplit("42.42.42.42.42")
164 assertBadSplit("42.42.42")
165 assertBadSplit("42.42")
166 assertBadSplit("42")
167 assertBadSplit("42..42.42.42")
168 assertBadSplit("42.42.42.42.")
169 assertBadSplit("42.42.42.42...")
170 assertBadSplit(".42.42.42.42")
171 assertBadSplit("...42.42.42.42")
172 assertBadSplit("016.016.016")
173 assertBadSplit("016.016")
174 assertBadSplit("016")
175 assertBadSplit("000")
176 assertBadSplit("0x0a.0x0a.0x0a")
177 assertBadSplit("0x0a.0x0a")
178 assertBadSplit("0x0a")
179 assertBadSplit(".")
180 assertBadSplit("bogus")
181 assertBadSplit("bogus.com")
182 assertBadSplit("1000")
183 assertBadSplit("1000000000000000")
184 assertBadSplit("192.168.0.1.com")
185
186 def test_empty_octet(self):
187 def assertBadOctet(addr):
188 with self.assertAddressError("Empty octet not permitted in %r",
189 addr):
190 ipaddress.IPv4Address(addr)
191
192 assertBadOctet("42..42.42")
193 assertBadOctet("...")
194
195 def test_invalid_characters(self):
196 def assertBadOctet(addr, octet):
197 msg = "Only decimal digits permitted in %r in %r" % (octet, addr)
198 with self.assertAddressError(re.escape(msg)):
199 ipaddress.IPv4Address(addr)
200
201 assertBadOctet("0x0a.0x0a.0x0a.0x0a", "0x0a")
Nick Coghlan07c4e332012-07-08 23:06:45 +1000202 assertBadOctet("0xa.0x0a.0x0a.0x0a", "0xa")
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000203 assertBadOctet("42.42.42.-0", "-0")
204 assertBadOctet("42.42.42.+0", "+0")
205 assertBadOctet("42.42.42.-42", "-42")
206 assertBadOctet("+1.+2.+3.4", "+1")
207 assertBadOctet("1.2.3.4e0", "4e0")
208 assertBadOctet("1.2.3.4::", "4::")
209 assertBadOctet("1.a.2.3", "a")
210
Nick Coghlan07c4e332012-07-08 23:06:45 +1000211 def test_octal_decimal_ambiguity(self):
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000212 def assertBadOctet(addr, octet):
Nick Coghlan07c4e332012-07-08 23:06:45 +1000213 msg = "Ambiguous (octal/decimal) value in %r not permitted in %r"
214 with self.assertAddressError(re.escape(msg % (octet, addr))):
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000215 ipaddress.IPv4Address(addr)
216
217 assertBadOctet("016.016.016.016", "016")
218 assertBadOctet("001.000.008.016", "008")
Nick Coghlan07c4e332012-07-08 23:06:45 +1000219
220 def test_octet_length(self):
221 def assertBadOctet(addr, octet):
222 msg = "At most 3 characters permitted in %r in %r"
223 with self.assertAddressError(re.escape(msg % (octet, addr))):
224 ipaddress.IPv4Address(addr)
225
226 assertBadOctet("0000.000.000.000", "0000")
227 assertBadOctet("12345.67899.-54321.-98765", "12345")
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000228
229 def test_octet_limit(self):
230 def assertBadOctet(addr, octet):
Nick Coghlanb582ecc2012-07-07 22:15:22 +1000231 msg = "Octet %d (> 255) not permitted in %r" % (octet, addr)
232 with self.assertAddressError(re.escape(msg)):
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000233 ipaddress.IPv4Address(addr)
234
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000235 assertBadOctet("257.0.0.0", 257)
Nick Coghlan07c4e332012-07-08 23:06:45 +1000236 assertBadOctet("192.168.0.999", 999)
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000237
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000238
Nick Coghlan07c4e332012-07-08 23:06:45 +1000239class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6):
Nick Coghlan297b1432012-07-08 17:11:04 +1000240 factory = ipaddress.IPv6Address
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000241
242 def test_network_passed_as_address(self):
243 addr = "::1/24"
244 with self.assertAddressError("Unexpected '/' in %r", addr):
245 ipaddress.IPv6Address(addr)
246
247 def test_bad_address_split_v6_not_enough_parts(self):
248 def assertBadSplit(addr):
249 msg = "At least 3 parts expected in %r"
250 with self.assertAddressError(msg, addr):
251 ipaddress.IPv6Address(addr)
252
253 assertBadSplit(":")
254 assertBadSplit(":1")
255 assertBadSplit("FEDC:9878")
256
257 def test_bad_address_split_v6_too_many_colons(self):
258 def assertBadSplit(addr):
259 msg = "At most 8 colons permitted in %r"
260 with self.assertAddressError(msg, addr):
261 ipaddress.IPv6Address(addr)
262
263 assertBadSplit("9:8:7:6:5:4:3::2:1")
264 assertBadSplit("10:9:8:7:6:5:4:3:2:1")
265 assertBadSplit("::8:7:6:5:4:3:2:1")
266 assertBadSplit("8:7:6:5:4:3:2:1::")
267 # A trailing IPv4 address is two parts
268 assertBadSplit("10:9:8:7:6:5:4:3:42.42.42.42")
269
270 def test_bad_address_split_v6_too_many_parts(self):
271 def assertBadSplit(addr):
272 msg = "Exactly 8 parts expected without '::' in %r"
273 with self.assertAddressError(msg, addr):
274 ipaddress.IPv6Address(addr)
275
276 assertBadSplit("3ffe:0:0:0:0:0:0:0:1")
277 assertBadSplit("9:8:7:6:5:4:3:2:1")
278 assertBadSplit("7:6:5:4:3:2:1")
279 # A trailing IPv4 address is two parts
280 assertBadSplit("9:8:7:6:5:4:3:42.42.42.42")
281 assertBadSplit("7:6:5:4:3:42.42.42.42")
282
283 def test_bad_address_split_v6_too_many_parts_with_double_colon(self):
284 def assertBadSplit(addr):
285 msg = "Expected at most 7 other parts with '::' in %r"
286 with self.assertAddressError(msg, addr):
287 ipaddress.IPv6Address(addr)
288
289 assertBadSplit("1:2:3:4::5:6:7:8")
290
291 def test_bad_address_split_v6_repeated_double_colon(self):
292 def assertBadSplit(addr):
293 msg = "At most one '::' permitted in %r"
294 with self.assertAddressError(msg, addr):
295 ipaddress.IPv6Address(addr)
296
297 assertBadSplit("3ffe::1::1")
298 assertBadSplit("1::2::3::4:5")
299 assertBadSplit("2001::db:::1")
300 assertBadSplit("3ffe::1::")
301 assertBadSplit("::3ffe::1")
302 assertBadSplit(":3ffe::1::1")
303 assertBadSplit("3ffe::1::1:")
304 assertBadSplit(":3ffe::1::1:")
305 assertBadSplit(":::")
306 assertBadSplit('2001:db8:::1')
307
308 def test_bad_address_split_v6_leading_colon(self):
309 def assertBadSplit(addr):
310 msg = "Leading ':' only permitted as part of '::' in %r"
311 with self.assertAddressError(msg, addr):
312 ipaddress.IPv6Address(addr)
313
314 assertBadSplit(":2001:db8::1")
315 assertBadSplit(":1:2:3:4:5:6:7")
316 assertBadSplit(":1:2:3:4:5:6:")
317 assertBadSplit(":6:5:4:3:2:1::")
318
319 def test_bad_address_split_v6_trailing_colon(self):
320 def assertBadSplit(addr):
321 msg = "Trailing ':' only permitted as part of '::' in %r"
322 with self.assertAddressError(msg, addr):
323 ipaddress.IPv6Address(addr)
324
325 assertBadSplit("2001:db8::1:")
326 assertBadSplit("1:2:3:4:5:6:7:")
327 assertBadSplit("::1.2.3.4:")
328 assertBadSplit("::7:6:5:4:3:2:")
329
330 def test_bad_v4_part_in(self):
331 def assertBadAddressPart(addr, v4_error):
332 with self.assertAddressError("%s in %r", v4_error, addr):
333 ipaddress.IPv6Address(addr)
334
335 assertBadAddressPart("3ffe::1.net", "Expected 4 octets in '1.net'")
336 assertBadAddressPart("3ffe::127.0.1",
337 "Expected 4 octets in '127.0.1'")
338 assertBadAddressPart("::1.2.3",
339 "Expected 4 octets in '1.2.3'")
340 assertBadAddressPart("::1.2.3.4.5",
341 "Expected 4 octets in '1.2.3.4.5'")
342 assertBadAddressPart("3ffe::1.1.1.net",
343 "Only decimal digits permitted in 'net' "
344 "in '1.1.1.net'")
345
346 def test_invalid_characters(self):
347 def assertBadPart(addr, part):
348 msg = "Only hex digits permitted in %r in %r" % (part, addr)
349 with self.assertAddressError(re.escape(msg)):
350 ipaddress.IPv6Address(addr)
351
352 assertBadPart("3ffe::goog", "goog")
353 assertBadPart("3ffe::-0", "-0")
354 assertBadPart("3ffe::+0", "+0")
355 assertBadPart("3ffe::-1", "-1")
356 assertBadPart("1.2.3.4::", "1.2.3.4")
357 assertBadPart('1234:axy::b', "axy")
358
359 def test_part_length(self):
360 def assertBadPart(addr, part):
361 msg = "At most 4 characters permitted in %r in %r"
362 with self.assertAddressError(msg, part, addr):
363 ipaddress.IPv6Address(addr)
364
Nick Coghlan07c4e332012-07-08 23:06:45 +1000365 assertBadPart("::00000", "00000")
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000366 assertBadPart("3ffe::10000", "10000")
367 assertBadPart("02001:db8::", "02001")
368 assertBadPart('2001:888888::1', "888888")
369
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000370
Nick Coghlan07c4e332012-07-08 23:06:45 +1000371class NetmaskTestMixin_v4(CommonTestMixin_v4):
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000372 """Input validation on interfaces and networks is very similar"""
373
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000374 def test_split_netmask(self):
375 addr = "1.2.3.4/32/24"
376 with self.assertAddressError("Only one '/' permitted in %r" % addr):
377 self.factory(addr)
378
379 def test_address_errors(self):
380 def assertBadAddress(addr, details):
381 with self.assertAddressError(details):
382 self.factory(addr)
383
Nick Coghlan297b1432012-07-08 17:11:04 +1000384 assertBadAddress("/", "Address cannot be empty")
385 assertBadAddress("/8", "Address cannot be empty")
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000386 assertBadAddress("bogus", "Expected 4 octets")
387 assertBadAddress("google.com", "Expected 4 octets")
388 assertBadAddress("10/8", "Expected 4 octets")
389 assertBadAddress("::1.2.3.4", "Only decimal digits")
Nick Coghlanb582ecc2012-07-07 22:15:22 +1000390 assertBadAddress("1.2.3.256", re.escape("256 (> 255)"))
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000391
392 def test_netmask_errors(self):
393 def assertBadNetmask(addr, netmask):
394 msg = "%r is not a valid netmask"
395 with self.assertNetmaskError(msg % netmask):
396 self.factory("%s/%s" % (addr, netmask))
397
398 assertBadNetmask("1.2.3.4", "")
399 assertBadNetmask("1.2.3.4", "33")
400 assertBadNetmask("1.2.3.4", "254.254.255.256")
Nick Coghlan07c4e332012-07-08 23:06:45 +1000401 assertBadNetmask("1.1.1.1", "254.xyz.2.3")
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000402 assertBadNetmask("1.1.1.1", "240.255.0.0")
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000403 assertBadNetmask("1.1.1.1", "pudding")
404
Nick Coghlan07c4e332012-07-08 23:06:45 +1000405class InterfaceTestCase_v4(BaseTestCase, NetmaskTestMixin_v4):
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000406 factory = ipaddress.IPv4Interface
407
Nick Coghlan07c4e332012-07-08 23:06:45 +1000408class NetworkTestCase_v4(BaseTestCase, NetmaskTestMixin_v4):
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000409 factory = ipaddress.IPv4Network
410
411
Nick Coghlan07c4e332012-07-08 23:06:45 +1000412class NetmaskTestMixin_v6(CommonTestMixin_v6):
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000413 """Input validation on interfaces and networks is very similar"""
414
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000415 def test_split_netmask(self):
416 addr = "cafe:cafe::/128/190"
417 with self.assertAddressError("Only one '/' permitted in %r" % addr):
418 self.factory(addr)
419
420 def test_address_errors(self):
421 def assertBadAddress(addr, details):
422 with self.assertAddressError(details):
423 self.factory(addr)
424
Nick Coghlan297b1432012-07-08 17:11:04 +1000425 assertBadAddress("/", "Address cannot be empty")
426 assertBadAddress("/8", "Address cannot be empty")
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000427 assertBadAddress("google.com", "At least 3 parts")
428 assertBadAddress("1.2.3.4", "At least 3 parts")
429 assertBadAddress("10/8", "At least 3 parts")
430 assertBadAddress("1234:axy::b", "Only hex digits")
431
432 def test_netmask_errors(self):
433 def assertBadNetmask(addr, netmask):
434 msg = "%r is not a valid netmask"
435 with self.assertNetmaskError(msg % netmask):
436 self.factory("%s/%s" % (addr, netmask))
437
438 assertBadNetmask("::1", "")
439 assertBadNetmask("::1", "::1")
440 assertBadNetmask("::1", "1::")
441 assertBadNetmask("::1", "129")
442 assertBadNetmask("::1", "pudding")
443
Nick Coghlan07c4e332012-07-08 23:06:45 +1000444class InterfaceTestCase_v6(BaseTestCase, NetmaskTestMixin_v6):
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000445 factory = ipaddress.IPv6Interface
446
Nick Coghlan07c4e332012-07-08 23:06:45 +1000447class NetworkTestCase_v6(BaseTestCase, NetmaskTestMixin_v6):
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000448 factory = ipaddress.IPv6Network
449
450
Nick Coghlan07c4e332012-07-08 23:06:45 +1000451class FactoryFunctionErrors(BaseTestCase):
Nick Coghlan36f8dcd2012-07-07 19:23:53 +1000452
453 def assertFactoryError(self, factory, kind):
454 """Ensure a clean ValueError with the expected message"""
455 addr = "camelot"
456 msg = '%r does not appear to be an IPv4 or IPv6 %s'
457 with self.assertCleanError(ValueError, msg, addr, kind):
458 factory(addr)
459
460 def test_ip_address(self):
461 self.assertFactoryError(ipaddress.ip_address, "address")
462
463 def test_ip_interface(self):
464 self.assertFactoryError(ipaddress.ip_interface, "interface")
465
466 def test_ip_network(self):
467 self.assertFactoryError(ipaddress.ip_network, "network")
468
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200469
Nick Coghlan3008ec02012-07-08 00:45:33 +1000470class ComparisonTests(unittest.TestCase):
471
472 v4addr = ipaddress.IPv4Address(1)
473 v4net = ipaddress.IPv4Network(1)
474 v4intf = ipaddress.IPv4Interface(1)
475 v6addr = ipaddress.IPv6Address(1)
476 v6net = ipaddress.IPv6Network(1)
477 v6intf = ipaddress.IPv6Interface(1)
478
479 v4_addresses = [v4addr, v4intf]
480 v4_objects = v4_addresses + [v4net]
481 v6_addresses = [v6addr, v6intf]
482 v6_objects = v6_addresses + [v6net]
483 objects = v4_objects + v6_objects
484
485 def test_foreign_type_equality(self):
486 # __eq__ should never raise TypeError directly
487 other = object()
488 for obj in self.objects:
489 self.assertNotEqual(obj, other)
490 self.assertFalse(obj == other)
491 self.assertEqual(obj.__eq__(other), NotImplemented)
492 self.assertEqual(obj.__ne__(other), NotImplemented)
493
494 def test_mixed_type_equality(self):
495 # Ensure none of the internal objects accidentally
496 # expose the right set of attributes to become "equal"
497 for lhs in self.objects:
498 for rhs in self.objects:
499 if lhs is rhs:
500 continue
501 self.assertNotEqual(lhs, rhs)
502
503 def test_containment(self):
504 for obj in self.v4_addresses:
505 self.assertIn(obj, self.v4net)
506 for obj in self.v6_addresses:
507 self.assertIn(obj, self.v6net)
508 for obj in self.v4_objects + [self.v6net]:
509 self.assertNotIn(obj, self.v6net)
510 for obj in self.v6_objects + [self.v4net]:
511 self.assertNotIn(obj, self.v4net)
512
513 def test_mixed_type_ordering(self):
514 for lhs in self.objects:
515 for rhs in self.objects:
516 if isinstance(lhs, type(rhs)) or isinstance(rhs, type(lhs)):
517 continue
518 self.assertRaises(TypeError, lambda: lhs < rhs)
519 self.assertRaises(TypeError, lambda: lhs > rhs)
520 self.assertRaises(TypeError, lambda: lhs <= rhs)
521 self.assertRaises(TypeError, lambda: lhs >= rhs)
522
523 def test_mixed_type_key(self):
524 # with get_mixed_type_key, you can sort addresses and network.
525 v4_ordered = [self.v4addr, self.v4net, self.v4intf]
526 v6_ordered = [self.v6addr, self.v6net, self.v6intf]
527 self.assertEqual(v4_ordered,
528 sorted(self.v4_objects,
529 key=ipaddress.get_mixed_type_key))
530 self.assertEqual(v6_ordered,
531 sorted(self.v6_objects,
532 key=ipaddress.get_mixed_type_key))
533 self.assertEqual(v4_ordered + v6_ordered,
534 sorted(self.objects,
535 key=ipaddress.get_mixed_type_key))
536 self.assertEqual(NotImplemented, ipaddress.get_mixed_type_key(object))
537
538 def test_incompatible_versions(self):
539 # These should always raise TypeError
540 v4addr = ipaddress.ip_address('1.1.1.1')
541 v4net = ipaddress.ip_network('1.1.1.1')
542 v6addr = ipaddress.ip_address('::1')
543 v6net = ipaddress.ip_address('::1')
544
545 self.assertRaises(TypeError, v4addr.__lt__, v6addr)
546 self.assertRaises(TypeError, v4addr.__gt__, v6addr)
547 self.assertRaises(TypeError, v4net.__lt__, v6net)
548 self.assertRaises(TypeError, v4net.__gt__, v6net)
549
550 self.assertRaises(TypeError, v6addr.__lt__, v4addr)
551 self.assertRaises(TypeError, v6addr.__gt__, v4addr)
552 self.assertRaises(TypeError, v6net.__lt__, v4net)
553 self.assertRaises(TypeError, v6net.__gt__, v4net)
554
555
556
Nick Coghlandc9b2552012-05-20 21:01:57 +1000557class IpaddrUnitTest(unittest.TestCase):
558
559 def setUp(self):
560 self.ipv4_address = ipaddress.IPv4Address('1.2.3.4')
561 self.ipv4_interface = ipaddress.IPv4Interface('1.2.3.4/24')
562 self.ipv4_network = ipaddress.IPv4Network('1.2.3.0/24')
563 #self.ipv4_hostmask = ipaddress.IPv4Interface('10.0.0.1/0.255.255.255')
564 self.ipv6_address = ipaddress.IPv6Interface(
565 '2001:658:22a:cafe:200:0:0:1')
566 self.ipv6_interface = ipaddress.IPv6Interface(
567 '2001:658:22a:cafe:200:0:0:1/64')
568 self.ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/64')
569
570 def testRepr(self):
571 self.assertEqual("IPv4Interface('1.2.3.4/32')",
572 repr(ipaddress.IPv4Interface('1.2.3.4')))
573 self.assertEqual("IPv6Interface('::1/128')",
574 repr(ipaddress.IPv6Interface('::1')))
575
576 # issue57
577 def testAddressIntMath(self):
578 self.assertEqual(ipaddress.IPv4Address('1.1.1.1') + 255,
579 ipaddress.IPv4Address('1.1.2.0'))
580 self.assertEqual(ipaddress.IPv4Address('1.1.1.1') - 256,
581 ipaddress.IPv4Address('1.1.0.1'))
582 self.assertEqual(ipaddress.IPv6Address('::1') + (2**16 - 2),
583 ipaddress.IPv6Address('::ffff'))
584 self.assertEqual(ipaddress.IPv6Address('::ffff') - (2**16 - 2),
585 ipaddress.IPv6Address('::1'))
586
Nick Coghlan3c2570c2012-07-07 01:13:55 +1000587 def testInvalidIntToBytes(self):
588 self.assertRaises(ValueError, ipaddress.v4_int_to_packed, -1)
589 self.assertRaises(ValueError, ipaddress.v4_int_to_packed,
590 2 ** ipaddress.IPV4LENGTH)
591 self.assertRaises(ValueError, ipaddress.v6_int_to_packed, -1)
592 self.assertRaises(ValueError, ipaddress.v6_int_to_packed,
593 2 ** ipaddress.IPV6LENGTH)
594
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200595 def testInternals(self):
596 first, last = ipaddress._find_address_range([
597 ipaddress.IPv4Address('10.10.10.10'),
598 ipaddress.IPv4Address('10.10.10.12')])
599 self.assertEqual(first, last)
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200600 self.assertEqual(128, ipaddress._count_righthand_zero_bits(0, 128))
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200601 self.assertEqual("IPv4Network('1.2.3.0/24')", repr(self.ipv4_network))
602 self.assertEqual('0x1020318', hex(self.ipv4_network))
Nick Coghlandc9b2552012-05-20 21:01:57 +1000603
Nick Coghland9722652012-06-17 16:33:00 +1000604 def testMissingAddressVersion(self):
605 class Broken(ipaddress._BaseAddress):
606 pass
607 broken = Broken('127.0.0.1')
608 with self.assertRaisesRegex(NotImplementedError, "Broken.*version"):
609 broken.version
610
611 def testMissingNetworkVersion(self):
612 class Broken(ipaddress._BaseNetwork):
613 pass
614 broken = Broken('127.0.0.1')
615 with self.assertRaisesRegex(NotImplementedError, "Broken.*version"):
616 broken.version
617
618 def testMissingAddressClass(self):
619 class Broken(ipaddress._BaseNetwork):
620 pass
621 broken = Broken('127.0.0.1')
622 with self.assertRaisesRegex(NotImplementedError, "Broken.*address"):
623 broken._address_class
624
Nick Coghlandc9b2552012-05-20 21:01:57 +1000625 def testGetNetwork(self):
626 self.assertEqual(int(self.ipv4_network.network_address), 16909056)
627 self.assertEqual(str(self.ipv4_network.network_address), '1.2.3.0')
628
629 self.assertEqual(int(self.ipv6_network.network_address),
630 42540616829182469433403647294022090752)
631 self.assertEqual(str(self.ipv6_network.network_address),
632 '2001:658:22a:cafe::')
633 self.assertEqual(str(self.ipv6_network.hostmask),
634 '::ffff:ffff:ffff:ffff')
635
Nick Coghlandc9b2552012-05-20 21:01:57 +1000636 def testIpFromInt(self):
637 self.assertEqual(self.ipv4_interface._ip,
638 ipaddress.IPv4Interface(16909060)._ip)
Nick Coghlandc9b2552012-05-20 21:01:57 +1000639
640 ipv4 = ipaddress.ip_network('1.2.3.4')
641 ipv6 = ipaddress.ip_network('2001:658:22a:cafe:200:0:0:1')
642 self.assertEqual(ipv4, ipaddress.ip_network(int(ipv4)))
643 self.assertEqual(ipv6, ipaddress.ip_network(int(ipv6)))
644
645 v6_int = 42540616829182469433547762482097946625
646 self.assertEqual(self.ipv6_interface._ip,
647 ipaddress.IPv6Interface(v6_int)._ip)
Nick Coghlandc9b2552012-05-20 21:01:57 +1000648
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200649 self.assertEqual(ipaddress.ip_network(self.ipv4_address._ip).version,
650 4)
651 self.assertEqual(ipaddress.ip_network(self.ipv6_address._ip).version,
652 6)
Nick Coghlandc9b2552012-05-20 21:01:57 +1000653
654 def testIpFromPacked(self):
Nick Coghlan5cf896f2012-07-07 01:43:31 +1000655 address = ipaddress.ip_address
Nick Coghlandc9b2552012-05-20 21:01:57 +1000656 self.assertEqual(self.ipv4_interface._ip,
Nick Coghlan5cf896f2012-07-07 01:43:31 +1000657 ipaddress.ip_interface(b'\x01\x02\x03\x04')._ip)
658 self.assertEqual(address('255.254.253.252'),
659 address(b'\xff\xfe\xfd\xfc'))
Nick Coghlandc9b2552012-05-20 21:01:57 +1000660 self.assertEqual(self.ipv6_interface.ip,
661 ipaddress.ip_interface(
Nick Coghlan5cf896f2012-07-07 01:43:31 +1000662 b'\x20\x01\x06\x58\x02\x2a\xca\xfe'
663 b'\x02\x00\x00\x00\x00\x00\x00\x01').ip)
664 self.assertEqual(address('ffff:2:3:4:ffff::'),
665 address(b'\xff\xff\x00\x02\x00\x03\x00\x04' +
666 b'\xff\xff' + b'\x00' * 6))
667 self.assertEqual(address('::'),
668 address(b'\x00' * 16))
669
Nick Coghlandc9b2552012-05-20 21:01:57 +1000670 def testGetIp(self):
671 self.assertEqual(int(self.ipv4_interface.ip), 16909060)
672 self.assertEqual(str(self.ipv4_interface.ip), '1.2.3.4')
673
674 self.assertEqual(int(self.ipv6_interface.ip),
675 42540616829182469433547762482097946625)
676 self.assertEqual(str(self.ipv6_interface.ip),
677 '2001:658:22a:cafe:200::1')
678
679 def testGetNetmask(self):
680 self.assertEqual(int(self.ipv4_network.netmask), 4294967040)
681 self.assertEqual(str(self.ipv4_network.netmask), '255.255.255.0')
682 self.assertEqual(int(self.ipv6_network.netmask),
683 340282366920938463444927863358058659840)
684 self.assertEqual(self.ipv6_network.prefixlen, 64)
685
686 def testZeroNetmask(self):
687 ipv4_zero_netmask = ipaddress.IPv4Interface('1.2.3.4/0')
688 self.assertEqual(int(ipv4_zero_netmask.network.netmask), 0)
689 self.assertTrue(ipv4_zero_netmask.network._is_valid_netmask(
690 str(0)))
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200691 self.assertTrue(ipv4_zero_netmask._is_valid_netmask('0'))
692 self.assertTrue(ipv4_zero_netmask._is_valid_netmask('0.0.0.0'))
693 self.assertFalse(ipv4_zero_netmask._is_valid_netmask('invalid'))
Nick Coghlandc9b2552012-05-20 21:01:57 +1000694
695 ipv6_zero_netmask = ipaddress.IPv6Interface('::1/0')
696 self.assertEqual(int(ipv6_zero_netmask.network.netmask), 0)
697 self.assertTrue(ipv6_zero_netmask.network._is_valid_netmask(
698 str(0)))
699
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200700 def testIPv4NetAndHostmasks(self):
701 net = self.ipv4_network
702 self.assertFalse(net._is_valid_netmask('invalid'))
703 self.assertTrue(net._is_valid_netmask('128.128.128.128'))
704 self.assertFalse(net._is_valid_netmask('128.128.128.127'))
705 self.assertFalse(net._is_valid_netmask('128.128.128.255'))
706 self.assertTrue(net._is_valid_netmask('255.128.128.128'))
707
708 self.assertFalse(net._is_hostmask('invalid'))
709 self.assertTrue(net._is_hostmask('128.255.255.255'))
710 self.assertFalse(net._is_hostmask('255.255.255.255'))
711 self.assertFalse(net._is_hostmask('1.2.3.4'))
712
713 net = ipaddress.IPv4Network('127.0.0.0/0.0.0.255')
714 self.assertEqual(24, net.prefixlen)
715
Nick Coghlandc9b2552012-05-20 21:01:57 +1000716 def testGetBroadcast(self):
717 self.assertEqual(int(self.ipv4_network.broadcast_address), 16909311)
718 self.assertEqual(str(self.ipv4_network.broadcast_address), '1.2.3.255')
719
720 self.assertEqual(int(self.ipv6_network.broadcast_address),
721 42540616829182469451850391367731642367)
722 self.assertEqual(str(self.ipv6_network.broadcast_address),
723 '2001:658:22a:cafe:ffff:ffff:ffff:ffff')
724
725 def testGetPrefixlen(self):
726 self.assertEqual(self.ipv4_interface.prefixlen, 24)
727 self.assertEqual(self.ipv6_interface.prefixlen, 64)
728
729 def testGetSupernet(self):
730 self.assertEqual(self.ipv4_network.supernet().prefixlen, 23)
731 self.assertEqual(str(self.ipv4_network.supernet().network_address),
732 '1.2.2.0')
733 self.assertEqual(
734 ipaddress.IPv4Interface('0.0.0.0/0').network.supernet(),
735 ipaddress.IPv4Network('0.0.0.0/0'))
736
737 self.assertEqual(self.ipv6_network.supernet().prefixlen, 63)
738 self.assertEqual(str(self.ipv6_network.supernet().network_address),
739 '2001:658:22a:cafe::')
740 self.assertEqual(ipaddress.IPv6Interface('::0/0').network.supernet(),
741 ipaddress.IPv6Network('::0/0'))
742
743 def testGetSupernet3(self):
744 self.assertEqual(self.ipv4_network.supernet(3).prefixlen, 21)
745 self.assertEqual(str(self.ipv4_network.supernet(3).network_address),
746 '1.2.0.0')
747
748 self.assertEqual(self.ipv6_network.supernet(3).prefixlen, 61)
749 self.assertEqual(str(self.ipv6_network.supernet(3).network_address),
750 '2001:658:22a:caf8::')
751
752 def testGetSupernet4(self):
753 self.assertRaises(ValueError, self.ipv4_network.supernet,
754 prefixlen_diff=2, new_prefix=1)
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200755 self.assertRaises(ValueError, self.ipv4_network.supernet,
756 new_prefix=25)
Nick Coghlandc9b2552012-05-20 21:01:57 +1000757 self.assertEqual(self.ipv4_network.supernet(prefixlen_diff=2),
758 self.ipv4_network.supernet(new_prefix=22))
759
760 self.assertRaises(ValueError, self.ipv6_network.supernet,
761 prefixlen_diff=2, new_prefix=1)
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200762 self.assertRaises(ValueError, self.ipv6_network.supernet,
763 new_prefix=65)
Nick Coghlandc9b2552012-05-20 21:01:57 +1000764 self.assertEqual(self.ipv6_network.supernet(prefixlen_diff=2),
765 self.ipv6_network.supernet(new_prefix=62))
766
767 def testHosts(self):
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200768 hosts = list(self.ipv4_network.hosts())
769 self.assertEqual(254, len(hosts))
770 self.assertEqual(ipaddress.IPv4Address('1.2.3.1'), hosts[0])
771 self.assertEqual(ipaddress.IPv4Address('1.2.3.254'), hosts[-1])
772
773 # special case where only 1 bit is left for address
Nick Coghlandc9b2552012-05-20 21:01:57 +1000774 self.assertEqual([ipaddress.IPv4Address('2.0.0.0'),
775 ipaddress.IPv4Address('2.0.0.1')],
776 list(ipaddress.ip_network('2.0.0.0/31').hosts()))
777
778 def testFancySubnetting(self):
779 self.assertEqual(sorted(self.ipv4_network.subnets(prefixlen_diff=3)),
780 sorted(self.ipv4_network.subnets(new_prefix=27)))
781 self.assertRaises(ValueError, list,
782 self.ipv4_network.subnets(new_prefix=23))
783 self.assertRaises(ValueError, list,
784 self.ipv4_network.subnets(prefixlen_diff=3,
785 new_prefix=27))
786 self.assertEqual(sorted(self.ipv6_network.subnets(prefixlen_diff=4)),
787 sorted(self.ipv6_network.subnets(new_prefix=68)))
788 self.assertRaises(ValueError, list,
789 self.ipv6_network.subnets(new_prefix=63))
790 self.assertRaises(ValueError, list,
791 self.ipv6_network.subnets(prefixlen_diff=4,
792 new_prefix=68))
793
794 def testGetSubnets(self):
795 self.assertEqual(list(self.ipv4_network.subnets())[0].prefixlen, 25)
796 self.assertEqual(str(list(
797 self.ipv4_network.subnets())[0].network_address),
798 '1.2.3.0')
799 self.assertEqual(str(list(
800 self.ipv4_network.subnets())[1].network_address),
801 '1.2.3.128')
802
803 self.assertEqual(list(self.ipv6_network.subnets())[0].prefixlen, 65)
804
805 def testGetSubnetForSingle32(self):
806 ip = ipaddress.IPv4Network('1.2.3.4/32')
807 subnets1 = [str(x) for x in ip.subnets()]
808 subnets2 = [str(x) for x in ip.subnets(2)]
809 self.assertEqual(subnets1, ['1.2.3.4/32'])
810 self.assertEqual(subnets1, subnets2)
811
812 def testGetSubnetForSingle128(self):
813 ip = ipaddress.IPv6Network('::1/128')
814 subnets1 = [str(x) for x in ip.subnets()]
815 subnets2 = [str(x) for x in ip.subnets(2)]
816 self.assertEqual(subnets1, ['::1/128'])
817 self.assertEqual(subnets1, subnets2)
818
819 def testSubnet2(self):
820 ips = [str(x) for x in self.ipv4_network.subnets(2)]
821 self.assertEqual(
822 ips,
823 ['1.2.3.0/26', '1.2.3.64/26', '1.2.3.128/26', '1.2.3.192/26'])
824
825 ipsv6 = [str(x) for x in self.ipv6_network.subnets(2)]
826 self.assertEqual(
827 ipsv6,
828 ['2001:658:22a:cafe::/66',
829 '2001:658:22a:cafe:4000::/66',
830 '2001:658:22a:cafe:8000::/66',
831 '2001:658:22a:cafe:c000::/66'])
832
833 def testSubnetFailsForLargeCidrDiff(self):
834 self.assertRaises(ValueError, list,
835 self.ipv4_interface.network.subnets(9))
836 self.assertRaises(ValueError, list,
837 self.ipv4_network.subnets(9))
838 self.assertRaises(ValueError, list,
839 self.ipv6_interface.network.subnets(65))
840 self.assertRaises(ValueError, list,
841 self.ipv6_network.subnets(65))
842
843 def testSupernetFailsForLargeCidrDiff(self):
844 self.assertRaises(ValueError,
845 self.ipv4_interface.network.supernet, 25)
846 self.assertRaises(ValueError,
847 self.ipv6_interface.network.supernet, 65)
848
849 def testSubnetFailsForNegativeCidrDiff(self):
850 self.assertRaises(ValueError, list,
851 self.ipv4_interface.network.subnets(-1))
852 self.assertRaises(ValueError, list,
Nick Coghlan2c589102012-05-27 01:03:25 +1000853 self.ipv4_network.subnets(-1))
Nick Coghlandc9b2552012-05-20 21:01:57 +1000854 self.assertRaises(ValueError, list,
855 self.ipv6_interface.network.subnets(-1))
856 self.assertRaises(ValueError, list,
857 self.ipv6_network.subnets(-1))
858
859 def testGetNum_Addresses(self):
860 self.assertEqual(self.ipv4_network.num_addresses, 256)
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200861 self.assertEqual(list(self.ipv4_network.subnets())[0].num_addresses,
862 128)
Nick Coghlandc9b2552012-05-20 21:01:57 +1000863 self.assertEqual(self.ipv4_network.supernet().num_addresses, 512)
864
865 self.assertEqual(self.ipv6_network.num_addresses, 18446744073709551616)
866 self.assertEqual(list(self.ipv6_network.subnets())[0].num_addresses,
867 9223372036854775808)
868 self.assertEqual(self.ipv6_network.supernet().num_addresses,
869 36893488147419103232)
870
871 def testContains(self):
872 self.assertTrue(ipaddress.IPv4Interface('1.2.3.128/25') in
873 self.ipv4_network)
874 self.assertFalse(ipaddress.IPv4Interface('1.2.4.1/24') in
875 self.ipv4_network)
876 # We can test addresses and string as well.
877 addr1 = ipaddress.IPv4Address('1.2.3.37')
878 self.assertTrue(addr1 in self.ipv4_network)
879 # issue 61, bad network comparison on like-ip'd network objects
880 # with identical broadcast addresses.
881 self.assertFalse(ipaddress.IPv4Network('1.1.0.0/16').__contains__(
882 ipaddress.IPv4Network('1.0.0.0/15')))
883
Nick Coghlandc9b2552012-05-20 21:01:57 +1000884 def testNth(self):
885 self.assertEqual(str(self.ipv4_network[5]), '1.2.3.5')
886 self.assertRaises(IndexError, self.ipv4_network.__getitem__, 256)
887
888 self.assertEqual(str(self.ipv6_network[5]),
889 '2001:658:22a:cafe::5')
890
891 def testGetitem(self):
892 # http://code.google.com/p/ipaddr-py/issues/detail?id=15
893 addr = ipaddress.IPv4Network('172.31.255.128/255.255.255.240')
894 self.assertEqual(28, addr.prefixlen)
895 addr_list = list(addr)
896 self.assertEqual('172.31.255.128', str(addr_list[0]))
897 self.assertEqual('172.31.255.128', str(addr[0]))
898 self.assertEqual('172.31.255.143', str(addr_list[-1]))
899 self.assertEqual('172.31.255.143', str(addr[-1]))
900 self.assertEqual(addr_list[-1], addr[-1])
901
902 def testEqual(self):
903 self.assertTrue(self.ipv4_interface ==
904 ipaddress.IPv4Interface('1.2.3.4/24'))
905 self.assertFalse(self.ipv4_interface ==
906 ipaddress.IPv4Interface('1.2.3.4/23'))
907 self.assertFalse(self.ipv4_interface ==
908 ipaddress.IPv6Interface('::1.2.3.4/24'))
909 self.assertFalse(self.ipv4_interface == '')
910 self.assertFalse(self.ipv4_interface == [])
911 self.assertFalse(self.ipv4_interface == 2)
912
913 self.assertTrue(self.ipv6_interface ==
914 ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64'))
915 self.assertFalse(self.ipv6_interface ==
916 ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63'))
917 self.assertFalse(self.ipv6_interface ==
918 ipaddress.IPv4Interface('1.2.3.4/23'))
919 self.assertFalse(self.ipv6_interface == '')
920 self.assertFalse(self.ipv6_interface == [])
921 self.assertFalse(self.ipv6_interface == 2)
922
923 def testNotEqual(self):
924 self.assertFalse(self.ipv4_interface !=
925 ipaddress.IPv4Interface('1.2.3.4/24'))
926 self.assertTrue(self.ipv4_interface !=
927 ipaddress.IPv4Interface('1.2.3.4/23'))
928 self.assertTrue(self.ipv4_interface !=
929 ipaddress.IPv6Interface('::1.2.3.4/24'))
930 self.assertTrue(self.ipv4_interface != '')
931 self.assertTrue(self.ipv4_interface != [])
932 self.assertTrue(self.ipv4_interface != 2)
933
934 self.assertTrue(self.ipv4_address !=
935 ipaddress.IPv4Address('1.2.3.5'))
936 self.assertTrue(self.ipv4_address != '')
937 self.assertTrue(self.ipv4_address != [])
938 self.assertTrue(self.ipv4_address != 2)
939
940 self.assertFalse(self.ipv6_interface !=
941 ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64'))
942 self.assertTrue(self.ipv6_interface !=
943 ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63'))
944 self.assertTrue(self.ipv6_interface !=
945 ipaddress.IPv4Interface('1.2.3.4/23'))
946 self.assertTrue(self.ipv6_interface != '')
947 self.assertTrue(self.ipv6_interface != [])
948 self.assertTrue(self.ipv6_interface != 2)
949
950 self.assertTrue(self.ipv6_address !=
951 ipaddress.IPv4Address('1.2.3.4'))
952 self.assertTrue(self.ipv6_address != '')
953 self.assertTrue(self.ipv6_address != [])
954 self.assertTrue(self.ipv6_address != 2)
955
956 def testSlash32Constructor(self):
957 self.assertEqual(str(ipaddress.IPv4Interface(
958 '1.2.3.4/255.255.255.255')), '1.2.3.4/32')
959
960 def testSlash128Constructor(self):
961 self.assertEqual(str(ipaddress.IPv6Interface('::1/128')),
962 '::1/128')
963
964 def testSlash0Constructor(self):
965 self.assertEqual(str(ipaddress.IPv4Interface('1.2.3.4/0.0.0.0')),
966 '1.2.3.4/0')
967
968 def testCollapsing(self):
969 # test only IP addresses including some duplicates
970 ip1 = ipaddress.IPv4Address('1.1.1.0')
971 ip2 = ipaddress.IPv4Address('1.1.1.1')
972 ip3 = ipaddress.IPv4Address('1.1.1.2')
973 ip4 = ipaddress.IPv4Address('1.1.1.3')
974 ip5 = ipaddress.IPv4Address('1.1.1.4')
975 ip6 = ipaddress.IPv4Address('1.1.1.0')
976 # check that addreses are subsumed properly.
977 collapsed = ipaddress.collapse_addresses(
978 [ip1, ip2, ip3, ip4, ip5, ip6])
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200979 self.assertEqual(list(collapsed),
980 [ipaddress.IPv4Network('1.1.1.0/30'),
981 ipaddress.IPv4Network('1.1.1.4/32')])
Nick Coghlandc9b2552012-05-20 21:01:57 +1000982
983 # test a mix of IP addresses and networks including some duplicates
984 ip1 = ipaddress.IPv4Address('1.1.1.0')
985 ip2 = ipaddress.IPv4Address('1.1.1.1')
986 ip3 = ipaddress.IPv4Address('1.1.1.2')
987 ip4 = ipaddress.IPv4Address('1.1.1.3')
988 #ip5 = ipaddress.IPv4Interface('1.1.1.4/30')
989 #ip6 = ipaddress.IPv4Interface('1.1.1.4/30')
990 # check that addreses are subsumed properly.
991 collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4])
Hynek Schlawack91c5a342012-06-05 11:55:58 +0200992 self.assertEqual(list(collapsed),
993 [ipaddress.IPv4Network('1.1.1.0/30')])
Nick Coghlandc9b2552012-05-20 21:01:57 +1000994
995 # test only IP networks
996 ip1 = ipaddress.IPv4Network('1.1.0.0/24')
997 ip2 = ipaddress.IPv4Network('1.1.1.0/24')
998 ip3 = ipaddress.IPv4Network('1.1.2.0/24')
999 ip4 = ipaddress.IPv4Network('1.1.3.0/24')
1000 ip5 = ipaddress.IPv4Network('1.1.4.0/24')
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001001 # stored in no particular order b/c we want CollapseAddr to call
1002 # [].sort
Nick Coghlandc9b2552012-05-20 21:01:57 +10001003 ip6 = ipaddress.IPv4Network('1.1.0.0/22')
1004 # check that addreses are subsumed properly.
1005 collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4, ip5,
1006 ip6])
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001007 self.assertEqual(list(collapsed),
1008 [ipaddress.IPv4Network('1.1.0.0/22'),
1009 ipaddress.IPv4Network('1.1.4.0/24')])
Nick Coghlandc9b2552012-05-20 21:01:57 +10001010
1011 # test that two addresses are supernet'ed properly
1012 collapsed = ipaddress.collapse_addresses([ip1, ip2])
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001013 self.assertEqual(list(collapsed),
1014 [ipaddress.IPv4Network('1.1.0.0/23')])
Nick Coghlandc9b2552012-05-20 21:01:57 +10001015
1016 # test same IP networks
1017 ip_same1 = ip_same2 = ipaddress.IPv4Network('1.1.1.1/32')
1018 self.assertEqual(list(ipaddress.collapse_addresses(
1019 [ip_same1, ip_same2])),
1020 [ip_same1])
1021
1022 # test same IP addresses
1023 ip_same1 = ip_same2 = ipaddress.IPv4Address('1.1.1.1')
1024 self.assertEqual(list(ipaddress.collapse_addresses(
1025 [ip_same1, ip_same2])),
1026 [ipaddress.ip_network('1.1.1.1/32')])
1027 ip1 = ipaddress.IPv6Network('2001::/100')
1028 ip2 = ipaddress.IPv6Network('2001::/120')
1029 ip3 = ipaddress.IPv6Network('2001::/96')
1030 # test that ipv6 addresses are subsumed properly.
1031 collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3])
1032 self.assertEqual(list(collapsed), [ip3])
1033
1034 # the toejam test
Hynek Schlawack35db5132012-06-01 20:12:17 +02001035 addr_tuples = [
1036 (ipaddress.ip_address('1.1.1.1'),
1037 ipaddress.ip_address('::1')),
1038 (ipaddress.IPv4Network('1.1.0.0/24'),
1039 ipaddress.IPv6Network('2001::/120')),
1040 (ipaddress.IPv4Network('1.1.0.0/32'),
1041 ipaddress.IPv6Network('2001::/128')),
1042 ]
1043 for ip1, ip2 in addr_tuples:
1044 self.assertRaises(TypeError, ipaddress.collapse_addresses,
1045 [ip1, ip2])
Nick Coghlandc9b2552012-05-20 21:01:57 +10001046
1047 def testSummarizing(self):
1048 #ip = ipaddress.ip_address
1049 #ipnet = ipaddress.ip_network
1050 summarize = ipaddress.summarize_address_range
1051 ip1 = ipaddress.ip_address('1.1.1.0')
1052 ip2 = ipaddress.ip_address('1.1.1.255')
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001053
1054 # summarize works only for IPv4 & IPv6
1055 class IPv7Address(ipaddress.IPv6Address):
1056 @property
1057 def version(self):
1058 return 7
1059 ip_invalid1 = IPv7Address('::1')
1060 ip_invalid2 = IPv7Address('::1')
1061 self.assertRaises(ValueError, list,
1062 summarize(ip_invalid1, ip_invalid2))
1063 # test that a summary over ip4 & ip6 fails
1064 self.assertRaises(TypeError, list,
1065 summarize(ip1, ipaddress.IPv6Address('::1')))
1066 # test a /24 is summarized properly
Nick Coghlandc9b2552012-05-20 21:01:57 +10001067 self.assertEqual(list(summarize(ip1, ip2))[0],
1068 ipaddress.ip_network('1.1.1.0/24'))
1069 # test an IPv4 range that isn't on a network byte boundary
1070 ip2 = ipaddress.ip_address('1.1.1.8')
1071 self.assertEqual(list(summarize(ip1, ip2)),
1072 [ipaddress.ip_network('1.1.1.0/29'),
1073 ipaddress.ip_network('1.1.1.8')])
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001074 # all!
1075 ip1 = ipaddress.IPv4Address(0)
1076 ip2 = ipaddress.IPv4Address(ipaddress.IPv4Address._ALL_ONES)
1077 self.assertEqual([ipaddress.IPv4Network('0.0.0.0/0')],
1078 list(summarize(ip1, ip2)))
Nick Coghlandc9b2552012-05-20 21:01:57 +10001079
1080 ip1 = ipaddress.ip_address('1::')
1081 ip2 = ipaddress.ip_address('1:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
1082 # test a IPv6 is sumamrized properly
1083 self.assertEqual(list(summarize(ip1, ip2))[0],
1084 ipaddress.ip_network('1::/16'))
1085 # test an IPv6 range that isn't on a network byte boundary
1086 ip2 = ipaddress.ip_address('2::')
1087 self.assertEqual(list(summarize(ip1, ip2)),
1088 [ipaddress.ip_network('1::/16'),
1089 ipaddress.ip_network('2::/128')])
1090
1091 # test exception raised when first is greater than last
1092 self.assertRaises(ValueError, list,
1093 summarize(ipaddress.ip_address('1.1.1.0'),
1094 ipaddress.ip_address('1.1.0.0')))
1095 # test exception raised when first and last aren't IP addresses
1096 self.assertRaises(TypeError, list,
1097 summarize(ipaddress.ip_network('1.1.1.0'),
1098 ipaddress.ip_network('1.1.0.0')))
1099 self.assertRaises(TypeError, list,
1100 summarize(ipaddress.ip_network('1.1.1.0'),
1101 ipaddress.ip_network('1.1.0.0')))
1102 # test exception raised when first and last are not same version
1103 self.assertRaises(TypeError, list,
1104 summarize(ipaddress.ip_address('::'),
1105 ipaddress.ip_network('1.1.0.0')))
1106
1107 def testAddressComparison(self):
1108 self.assertTrue(ipaddress.ip_address('1.1.1.1') <=
1109 ipaddress.ip_address('1.1.1.1'))
1110 self.assertTrue(ipaddress.ip_address('1.1.1.1') <=
1111 ipaddress.ip_address('1.1.1.2'))
1112 self.assertTrue(ipaddress.ip_address('::1') <=
1113 ipaddress.ip_address('::1'))
1114 self.assertTrue(ipaddress.ip_address('::1') <=
1115 ipaddress.ip_address('::2'))
1116
Nick Coghlan3008ec02012-07-08 00:45:33 +10001117 def testInterfaceComparison(self):
1118 self.assertTrue(ipaddress.ip_interface('1.1.1.1') <=
1119 ipaddress.ip_interface('1.1.1.1'))
1120 self.assertTrue(ipaddress.ip_interface('1.1.1.1') <=
1121 ipaddress.ip_interface('1.1.1.2'))
1122 self.assertTrue(ipaddress.ip_interface('::1') <=
1123 ipaddress.ip_interface('::1'))
1124 self.assertTrue(ipaddress.ip_interface('::1') <=
1125 ipaddress.ip_interface('::2'))
1126
Nick Coghlandc9b2552012-05-20 21:01:57 +10001127 def testNetworkComparison(self):
1128 # ip1 and ip2 have the same network address
1129 ip1 = ipaddress.IPv4Network('1.1.1.0/24')
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001130 ip2 = ipaddress.IPv4Network('1.1.1.0/32')
Nick Coghlandc9b2552012-05-20 21:01:57 +10001131 ip3 = ipaddress.IPv4Network('1.1.2.0/24')
1132
1133 self.assertTrue(ip1 < ip3)
1134 self.assertTrue(ip3 > ip2)
1135
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001136 self.assertEqual(ip1.compare_networks(ip1), 0)
1137
1138 # if addresses are the same, sort by netmask
1139 self.assertEqual(ip1.compare_networks(ip2), -1)
1140 self.assertEqual(ip2.compare_networks(ip1), 1)
1141
Nick Coghlandc9b2552012-05-20 21:01:57 +10001142 self.assertEqual(ip1.compare_networks(ip3), -1)
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001143 self.assertEqual(ip3.compare_networks(ip1), 1)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001144 self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
1145
1146 ip1 = ipaddress.IPv6Network('2001:2000::/96')
1147 ip2 = ipaddress.IPv6Network('2001:2001::/96')
1148 ip3 = ipaddress.IPv6Network('2001:ffff:2000::/96')
1149
1150 self.assertTrue(ip1 < ip3)
1151 self.assertTrue(ip3 > ip2)
1152 self.assertEqual(ip1.compare_networks(ip3), -1)
1153 self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
1154
1155 # Test comparing different protocols.
1156 # Should always raise a TypeError.
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001157 self.assertRaises(TypeError,
1158 self.ipv4_network.compare_networks,
1159 self.ipv6_network)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001160 ipv6 = ipaddress.IPv6Interface('::/0')
1161 ipv4 = ipaddress.IPv4Interface('0.0.0.0/0')
1162 self.assertRaises(TypeError, ipv4.__lt__, ipv6)
1163 self.assertRaises(TypeError, ipv4.__gt__, ipv6)
1164 self.assertRaises(TypeError, ipv6.__lt__, ipv4)
1165 self.assertRaises(TypeError, ipv6.__gt__, ipv4)
1166
1167 # Regression test for issue 19.
1168 ip1 = ipaddress.ip_network('10.1.2.128/25')
1169 self.assertFalse(ip1 < ip1)
1170 self.assertFalse(ip1 > ip1)
1171 ip2 = ipaddress.ip_network('10.1.3.0/24')
1172 self.assertTrue(ip1 < ip2)
1173 self.assertFalse(ip2 < ip1)
1174 self.assertFalse(ip1 > ip2)
1175 self.assertTrue(ip2 > ip1)
1176 ip3 = ipaddress.ip_network('10.1.3.0/25')
1177 self.assertTrue(ip2 < ip3)
1178 self.assertFalse(ip3 < ip2)
1179 self.assertFalse(ip2 > ip3)
1180 self.assertTrue(ip3 > ip2)
1181
1182 # Regression test for issue 28.
1183 ip1 = ipaddress.ip_network('10.10.10.0/31')
1184 ip2 = ipaddress.ip_network('10.10.10.0')
1185 ip3 = ipaddress.ip_network('10.10.10.2/31')
1186 ip4 = ipaddress.ip_network('10.10.10.2')
1187 sorted = [ip1, ip2, ip3, ip4]
1188 unsorted = [ip2, ip4, ip1, ip3]
1189 unsorted.sort()
1190 self.assertEqual(sorted, unsorted)
1191 unsorted = [ip4, ip1, ip3, ip2]
1192 unsorted.sort()
1193 self.assertEqual(sorted, unsorted)
1194 self.assertRaises(TypeError, ip1.__lt__,
1195 ipaddress.ip_address('10.10.10.0'))
1196 self.assertRaises(TypeError, ip2.__lt__,
1197 ipaddress.ip_address('10.10.10.0'))
1198
1199 # <=, >=
1200 self.assertTrue(ipaddress.ip_network('1.1.1.1') <=
1201 ipaddress.ip_network('1.1.1.1'))
1202 self.assertTrue(ipaddress.ip_network('1.1.1.1') <=
1203 ipaddress.ip_network('1.1.1.2'))
1204 self.assertFalse(ipaddress.ip_network('1.1.1.2') <=
1205 ipaddress.ip_network('1.1.1.1'))
1206 self.assertTrue(ipaddress.ip_network('::1') <=
1207 ipaddress.ip_network('::1'))
1208 self.assertTrue(ipaddress.ip_network('::1') <=
1209 ipaddress.ip_network('::2'))
1210 self.assertFalse(ipaddress.ip_network('::2') <=
1211 ipaddress.ip_network('::1'))
1212
1213 def testStrictNetworks(self):
1214 self.assertRaises(ValueError, ipaddress.ip_network, '192.168.1.1/24')
1215 self.assertRaises(ValueError, ipaddress.ip_network, '::1/120')
1216
1217 def testOverlaps(self):
1218 other = ipaddress.IPv4Network('1.2.3.0/30')
1219 other2 = ipaddress.IPv4Network('1.2.2.0/24')
1220 other3 = ipaddress.IPv4Network('1.2.2.64/26')
1221 self.assertTrue(self.ipv4_network.overlaps(other))
1222 self.assertFalse(self.ipv4_network.overlaps(other2))
1223 self.assertTrue(other2.overlaps(other3))
1224
1225 def testEmbeddedIpv4(self):
1226 ipv4_string = '192.168.0.1'
1227 ipv4 = ipaddress.IPv4Interface(ipv4_string)
1228 v4compat_ipv6 = ipaddress.IPv6Interface('::%s' % ipv4_string)
1229 self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
1230 v4mapped_ipv6 = ipaddress.IPv6Interface('::ffff:%s' % ipv4_string)
1231 self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
1232 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
1233 '2001:1.1.1.1:1.1.1.1')
1234
1235 # Issue 67: IPv6 with embedded IPv4 address not recognized.
1236 def testIPv6AddressTooLarge(self):
1237 # RFC4291 2.5.5.2
1238 self.assertEqual(ipaddress.ip_address('::FFFF:192.0.2.1'),
1239 ipaddress.ip_address('::FFFF:c000:201'))
1240 # RFC4291 2.2 (part 3) x::d.d.d.d
1241 self.assertEqual(ipaddress.ip_address('FFFF::192.0.2.1'),
1242 ipaddress.ip_address('FFFF::c000:201'))
1243
1244 def testIPVersion(self):
1245 self.assertEqual(self.ipv4_address.version, 4)
1246 self.assertEqual(self.ipv6_address.version, 6)
1247
1248 def testMaxPrefixLength(self):
1249 self.assertEqual(self.ipv4_interface.max_prefixlen, 32)
1250 self.assertEqual(self.ipv6_interface.max_prefixlen, 128)
1251
1252 def testPacked(self):
1253 self.assertEqual(self.ipv4_address.packed,
Nick Coghlan5cf896f2012-07-07 01:43:31 +10001254 b'\x01\x02\x03\x04')
Nick Coghlandc9b2552012-05-20 21:01:57 +10001255 self.assertEqual(ipaddress.IPv4Interface('255.254.253.252').packed,
Nick Coghlan5cf896f2012-07-07 01:43:31 +10001256 b'\xff\xfe\xfd\xfc')
Nick Coghlandc9b2552012-05-20 21:01:57 +10001257 self.assertEqual(self.ipv6_address.packed,
Nick Coghlan5cf896f2012-07-07 01:43:31 +10001258 b'\x20\x01\x06\x58\x02\x2a\xca\xfe'
1259 b'\x02\x00\x00\x00\x00\x00\x00\x01')
Nick Coghlandc9b2552012-05-20 21:01:57 +10001260 self.assertEqual(ipaddress.IPv6Interface('ffff:2:3:4:ffff::').packed,
Nick Coghlan5cf896f2012-07-07 01:43:31 +10001261 b'\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff'
1262 + b'\x00' * 6)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001263 self.assertEqual(ipaddress.IPv6Interface('::1:0:0:0:0').packed,
Nick Coghlan5cf896f2012-07-07 01:43:31 +10001264 b'\x00' * 6 + b'\x00\x01' + b'\x00' * 8)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001265
1266 def testIpStrFromPrefixlen(self):
1267 ipv4 = ipaddress.IPv4Interface('1.2.3.4/24')
1268 self.assertEqual(ipv4._ip_string_from_prefix(), '255.255.255.0')
1269 self.assertEqual(ipv4._ip_string_from_prefix(28), '255.255.255.240')
1270
1271 def testIpType(self):
1272 ipv4net = ipaddress.ip_network('1.2.3.4')
1273 ipv4addr = ipaddress.ip_address('1.2.3.4')
1274 ipv6net = ipaddress.ip_network('::1.2.3.4')
1275 ipv6addr = ipaddress.ip_address('::1.2.3.4')
1276 self.assertEqual(ipaddress.IPv4Network, type(ipv4net))
1277 self.assertEqual(ipaddress.IPv4Address, type(ipv4addr))
1278 self.assertEqual(ipaddress.IPv6Network, type(ipv6net))
1279 self.assertEqual(ipaddress.IPv6Address, type(ipv6addr))
1280
1281 def testReservedIpv4(self):
1282 # test networks
1283 self.assertEqual(True, ipaddress.ip_interface(
1284 '224.1.1.1/31').is_multicast)
1285 self.assertEqual(False, ipaddress.ip_network('240.0.0.0').is_multicast)
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001286 self.assertEqual(True, ipaddress.ip_network('240.0.0.0').is_reserved)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001287
1288 self.assertEqual(True, ipaddress.ip_interface(
1289 '192.168.1.1/17').is_private)
1290 self.assertEqual(False, ipaddress.ip_network('192.169.0.0').is_private)
1291 self.assertEqual(True, ipaddress.ip_network(
1292 '10.255.255.255').is_private)
1293 self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_private)
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001294 self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_reserved)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001295 self.assertEqual(True, ipaddress.ip_network(
1296 '172.31.255.255').is_private)
1297 self.assertEqual(False, ipaddress.ip_network('172.32.0.0').is_private)
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001298 self.assertEqual(True,
1299 ipaddress.ip_network('169.254.1.0/24').is_link_local)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001300
1301 self.assertEqual(True,
1302 ipaddress.ip_interface(
1303 '169.254.100.200/24').is_link_local)
1304 self.assertEqual(False,
1305 ipaddress.ip_interface(
1306 '169.255.100.200/24').is_link_local)
1307
1308 self.assertEqual(True,
1309 ipaddress.ip_network(
1310 '127.100.200.254/32').is_loopback)
1311 self.assertEqual(True, ipaddress.ip_network(
1312 '127.42.0.0/16').is_loopback)
1313 self.assertEqual(False, ipaddress.ip_network('128.0.0.0').is_loopback)
1314
1315 # test addresses
Hynek Schlawackbcd30442012-06-04 14:19:39 +02001316 self.assertEqual(True, ipaddress.ip_address('0.0.0.0').is_unspecified)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001317 self.assertEqual(True, ipaddress.ip_address('224.1.1.1').is_multicast)
1318 self.assertEqual(False, ipaddress.ip_address('240.0.0.0').is_multicast)
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001319 self.assertEqual(True, ipaddress.ip_address('240.0.0.1').is_reserved)
1320 self.assertEqual(False,
1321 ipaddress.ip_address('239.255.255.255').is_reserved)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001322
1323 self.assertEqual(True, ipaddress.ip_address('192.168.1.1').is_private)
1324 self.assertEqual(False, ipaddress.ip_address('192.169.0.0').is_private)
1325 self.assertEqual(True, ipaddress.ip_address(
1326 '10.255.255.255').is_private)
1327 self.assertEqual(False, ipaddress.ip_address('11.0.0.0').is_private)
1328 self.assertEqual(True, ipaddress.ip_address(
1329 '172.31.255.255').is_private)
1330 self.assertEqual(False, ipaddress.ip_address('172.32.0.0').is_private)
1331
1332 self.assertEqual(True,
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001333 ipaddress.ip_address('169.254.100.200').is_link_local)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001334 self.assertEqual(False,
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001335 ipaddress.ip_address('169.255.100.200').is_link_local)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001336
1337 self.assertEqual(True,
1338 ipaddress.ip_address('127.100.200.254').is_loopback)
1339 self.assertEqual(True, ipaddress.ip_address('127.42.0.0').is_loopback)
1340 self.assertEqual(False, ipaddress.ip_address('128.0.0.0').is_loopback)
1341 self.assertEqual(True, ipaddress.ip_network('0.0.0.0').is_unspecified)
1342
1343 def testReservedIpv6(self):
1344
1345 self.assertEqual(True, ipaddress.ip_network('ffff::').is_multicast)
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001346 self.assertEqual(True, ipaddress.ip_network(2**128 - 1).is_multicast)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001347 self.assertEqual(True, ipaddress.ip_network('ff00::').is_multicast)
1348 self.assertEqual(False, ipaddress.ip_network('fdff::').is_multicast)
1349
1350 self.assertEqual(True, ipaddress.ip_network('fecf::').is_site_local)
1351 self.assertEqual(True, ipaddress.ip_network(
1352 'feff:ffff:ffff:ffff::').is_site_local)
1353 self.assertEqual(False, ipaddress.ip_network(
1354 'fbf:ffff::').is_site_local)
1355 self.assertEqual(False, ipaddress.ip_network('ff00::').is_site_local)
1356
1357 self.assertEqual(True, ipaddress.ip_network('fc00::').is_private)
1358 self.assertEqual(True, ipaddress.ip_network(
1359 'fc00:ffff:ffff:ffff::').is_private)
1360 self.assertEqual(False, ipaddress.ip_network('fbff:ffff::').is_private)
1361 self.assertEqual(False, ipaddress.ip_network('fe00::').is_private)
1362
1363 self.assertEqual(True, ipaddress.ip_network('fea0::').is_link_local)
1364 self.assertEqual(True, ipaddress.ip_network(
1365 'febf:ffff::').is_link_local)
1366 self.assertEqual(False, ipaddress.ip_network(
1367 'fe7f:ffff::').is_link_local)
1368 self.assertEqual(False, ipaddress.ip_network('fec0::').is_link_local)
1369
1370 self.assertEqual(True, ipaddress.ip_interface('0:0::0:01').is_loopback)
1371 self.assertEqual(False, ipaddress.ip_interface('::1/127').is_loopback)
1372 self.assertEqual(False, ipaddress.ip_network('::').is_loopback)
1373 self.assertEqual(False, ipaddress.ip_network('::2').is_loopback)
1374
1375 self.assertEqual(True, ipaddress.ip_network('0::0').is_unspecified)
1376 self.assertEqual(False, ipaddress.ip_network('::1').is_unspecified)
1377 self.assertEqual(False, ipaddress.ip_network('::/127').is_unspecified)
1378
1379 # test addresses
1380 self.assertEqual(True, ipaddress.ip_address('ffff::').is_multicast)
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001381 self.assertEqual(True, ipaddress.ip_address(2**128 - 1).is_multicast)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001382 self.assertEqual(True, ipaddress.ip_address('ff00::').is_multicast)
1383 self.assertEqual(False, ipaddress.ip_address('fdff::').is_multicast)
1384
1385 self.assertEqual(True, ipaddress.ip_address('fecf::').is_site_local)
1386 self.assertEqual(True, ipaddress.ip_address(
1387 'feff:ffff:ffff:ffff::').is_site_local)
1388 self.assertEqual(False, ipaddress.ip_address(
1389 'fbf:ffff::').is_site_local)
1390 self.assertEqual(False, ipaddress.ip_address('ff00::').is_site_local)
1391
1392 self.assertEqual(True, ipaddress.ip_address('fc00::').is_private)
1393 self.assertEqual(True, ipaddress.ip_address(
1394 'fc00:ffff:ffff:ffff::').is_private)
1395 self.assertEqual(False, ipaddress.ip_address('fbff:ffff::').is_private)
1396 self.assertEqual(False, ipaddress.ip_address('fe00::').is_private)
1397
1398 self.assertEqual(True, ipaddress.ip_address('fea0::').is_link_local)
1399 self.assertEqual(True, ipaddress.ip_address(
1400 'febf:ffff::').is_link_local)
1401 self.assertEqual(False, ipaddress.ip_address(
1402 'fe7f:ffff::').is_link_local)
1403 self.assertEqual(False, ipaddress.ip_address('fec0::').is_link_local)
1404
1405 self.assertEqual(True, ipaddress.ip_address('0:0::0:01').is_loopback)
1406 self.assertEqual(True, ipaddress.ip_address('::1').is_loopback)
1407 self.assertEqual(False, ipaddress.ip_address('::2').is_loopback)
1408
1409 self.assertEqual(True, ipaddress.ip_address('0::0').is_unspecified)
1410 self.assertEqual(False, ipaddress.ip_address('::1').is_unspecified)
1411
1412 # some generic IETF reserved addresses
1413 self.assertEqual(True, ipaddress.ip_address('100::').is_reserved)
1414 self.assertEqual(True, ipaddress.ip_network('4000::1/128').is_reserved)
1415
1416 def testIpv4Mapped(self):
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001417 self.assertEqual(
1418 ipaddress.ip_address('::ffff:192.168.1.1').ipv4_mapped,
1419 ipaddress.ip_address('192.168.1.1'))
Nick Coghlandc9b2552012-05-20 21:01:57 +10001420 self.assertEqual(ipaddress.ip_address('::c0a8:101').ipv4_mapped, None)
1421 self.assertEqual(ipaddress.ip_address('::ffff:c0a8:101').ipv4_mapped,
1422 ipaddress.ip_address('192.168.1.1'))
1423
1424 def testAddrExclude(self):
1425 addr1 = ipaddress.ip_network('10.1.1.0/24')
1426 addr2 = ipaddress.ip_network('10.1.1.0/26')
1427 addr3 = ipaddress.ip_network('10.2.1.0/24')
1428 addr4 = ipaddress.ip_address('10.1.1.0')
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001429 addr5 = ipaddress.ip_network('2001:db8::0/32')
Nick Coghlandc9b2552012-05-20 21:01:57 +10001430 self.assertEqual(sorted(list(addr1.address_exclude(addr2))),
1431 [ipaddress.ip_network('10.1.1.64/26'),
1432 ipaddress.ip_network('10.1.1.128/25')])
1433 self.assertRaises(ValueError, list, addr1.address_exclude(addr3))
1434 self.assertRaises(TypeError, list, addr1.address_exclude(addr4))
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001435 self.assertRaises(TypeError, list, addr1.address_exclude(addr5))
Nick Coghlandc9b2552012-05-20 21:01:57 +10001436 self.assertEqual(list(addr1.address_exclude(addr1)), [])
1437
1438 def testHash(self):
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001439 self.assertEqual(hash(ipaddress.ip_interface('10.1.1.0/24')),
1440 hash(ipaddress.ip_interface('10.1.1.0/24')))
Nick Coghlandc9b2552012-05-20 21:01:57 +10001441 self.assertEqual(hash(ipaddress.ip_network('10.1.1.0/24')),
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001442 hash(ipaddress.ip_network('10.1.1.0/24')))
Nick Coghlandc9b2552012-05-20 21:01:57 +10001443 self.assertEqual(hash(ipaddress.ip_address('10.1.1.0')),
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001444 hash(ipaddress.ip_address('10.1.1.0')))
Nick Coghlandc9b2552012-05-20 21:01:57 +10001445 # i70
1446 self.assertEqual(hash(ipaddress.ip_address('1.2.3.4')),
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001447 hash(ipaddress.ip_address(
Nick Coghlandc9b2552012-05-20 21:01:57 +10001448 int(ipaddress.ip_address('1.2.3.4')._ip))))
1449 ip1 = ipaddress.ip_address('10.1.1.0')
1450 ip2 = ipaddress.ip_address('1::')
1451 dummy = {}
1452 dummy[self.ipv4_address] = None
1453 dummy[self.ipv6_address] = None
1454 dummy[ip1] = None
1455 dummy[ip2] = None
1456 self.assertTrue(self.ipv4_address in dummy)
1457 self.assertTrue(ip2 in dummy)
1458
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001459 def testIPBases(self):
1460 net = self.ipv4_network
1461 self.assertEqual('1.2.3.0/24', net.compressed)
1462 self.assertEqual(
1463 net._ip_int_from_prefix(24),
1464 net._ip_int_from_prefix(None))
1465 net = self.ipv6_network
1466 self.assertRaises(ValueError, net._string_from_ip_int, 2**128 + 1)
1467 self.assertEqual(
1468 self.ipv6_address._string_from_ip_int(self.ipv6_address._ip),
1469 self.ipv6_address._string_from_ip_int(None))
1470
Hynek Schlawack454a74d2012-06-04 18:14:02 +02001471 def testIPv6NetworkHelpers(self):
1472 net = self.ipv6_network
1473 self.assertEqual('2001:658:22a:cafe::/64', net.with_prefixlen)
1474 self.assertEqual('2001:658:22a:cafe::/ffff:ffff:ffff:ffff::',
1475 net.with_netmask)
1476 self.assertEqual('2001:658:22a:cafe::/::ffff:ffff:ffff:ffff',
1477 net.with_hostmask)
1478 self.assertEqual('2001:658:22a:cafe::/64', str(net))
1479
1480 def testIPv4NetworkHelpers(self):
1481 net = self.ipv4_network
1482 self.assertEqual('1.2.3.0/24', net.with_prefixlen)
1483 self.assertEqual('1.2.3.0/255.255.255.0', net.with_netmask)
1484 self.assertEqual('1.2.3.0/0.0.0.255', net.with_hostmask)
1485 self.assertEqual('1.2.3.0/24', str(net))
1486
Nick Coghlandc9b2552012-05-20 21:01:57 +10001487 def testCopyConstructor(self):
1488 addr1 = ipaddress.ip_network('10.1.1.0/24')
1489 addr2 = ipaddress.ip_network(addr1)
1490 addr3 = ipaddress.ip_interface('2001:658:22a:cafe:200::1/64')
1491 addr4 = ipaddress.ip_interface(addr3)
1492 addr5 = ipaddress.IPv4Address('1.1.1.1')
1493 addr6 = ipaddress.IPv6Address('2001:658:22a:cafe:200::1')
1494
1495 self.assertEqual(addr1, addr2)
1496 self.assertEqual(addr3, addr4)
1497 self.assertEqual(addr5, ipaddress.IPv4Address(addr5))
1498 self.assertEqual(addr6, ipaddress.IPv6Address(addr6))
1499
1500 def testCompressIPv6Address(self):
1501 test_addresses = {
1502 '1:2:3:4:5:6:7:8': '1:2:3:4:5:6:7:8/128',
1503 '2001:0:0:4:0:0:0:8': '2001:0:0:4::8/128',
1504 '2001:0:0:4:5:6:7:8': '2001::4:5:6:7:8/128',
1505 '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128',
1506 '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128',
1507 '0:0:3:0:0:0:0:ffff': '0:0:3::ffff/128',
1508 '0:0:0:4:0:0:0:ffff': '::4:0:0:0:ffff/128',
1509 '0:0:0:0:5:0:0:ffff': '::5:0:0:ffff/128',
1510 '1:0:0:4:0:0:7:8': '1::4:0:0:7:8/128',
1511 '0:0:0:0:0:0:0:0': '::/128',
1512 '0:0:0:0:0:0:0:0/0': '::/0',
1513 '0:0:0:0:0:0:0:1': '::1/128',
1514 '2001:0658:022a:cafe:0000:0000:0000:0000/66':
1515 '2001:658:22a:cafe::/66',
1516 '::1.2.3.4': '::102:304/128',
1517 '1:2:3:4:5:ffff:1.2.3.4': '1:2:3:4:5:ffff:102:304/128',
1518 '::7:6:5:4:3:2:1': '0:7:6:5:4:3:2:1/128',
1519 '::7:6:5:4:3:2:0': '0:7:6:5:4:3:2:0/128',
1520 '7:6:5:4:3:2:1::': '7:6:5:4:3:2:1:0/128',
1521 '0:6:5:4:3:2:1::': '0:6:5:4:3:2:1:0/128',
1522 }
1523 for uncompressed, compressed in list(test_addresses.items()):
1524 self.assertEqual(compressed, str(ipaddress.IPv6Interface(
1525 uncompressed)))
1526
1527 def testExplodeShortHandIpStr(self):
1528 addr1 = ipaddress.IPv6Interface('2001::1')
1529 addr2 = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
1530 addr3 = ipaddress.IPv6Network('2001::/96')
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001531 addr4 = ipaddress.IPv4Address('192.168.178.1')
Nick Coghlandc9b2552012-05-20 21:01:57 +10001532 self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0001/128',
1533 addr1.exploded)
1534 self.assertEqual('0000:0000:0000:0000:0000:0000:0000:0001/128',
1535 ipaddress.IPv6Interface('::1/128').exploded)
1536 # issue 77
1537 self.assertEqual('2001:0000:5ef5:79fd:0000:059d:a0e5:0ba1',
1538 addr2.exploded)
1539 self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0000/96',
1540 addr3.exploded)
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001541 self.assertEqual('192.168.178.1', addr4.exploded)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001542
1543 def testIntRepresentation(self):
1544 self.assertEqual(16909060, int(self.ipv4_address))
1545 self.assertEqual(42540616829182469433547762482097946625,
1546 int(self.ipv6_address))
1547
1548 def testHexRepresentation(self):
1549 self.assertEqual(hex(0x1020304),
1550 hex(self.ipv4_address))
1551
1552 self.assertEqual(hex(0x20010658022ACAFE0200000000000001),
1553 hex(self.ipv6_address))
1554
1555 def testForceVersion(self):
1556 self.assertEqual(ipaddress.ip_network(1).version, 4)
Nick Coghlan51c30672012-05-27 00:25:58 +10001557 self.assertEqual(ipaddress.IPv6Network(1).version, 6)
Sandro Tosi876ecad2012-05-23 22:26:55 +02001558
Nick Coghlandc9b2552012-05-20 21:01:57 +10001559 def testWithStar(self):
1560 self.assertEqual(str(self.ipv4_interface.with_prefixlen), "1.2.3.4/24")
1561 self.assertEqual(str(self.ipv4_interface.with_netmask),
1562 "1.2.3.4/255.255.255.0")
1563 self.assertEqual(str(self.ipv4_interface.with_hostmask),
1564 "1.2.3.4/0.0.0.255")
1565
1566 self.assertEqual(str(self.ipv6_interface.with_prefixlen),
1567 '2001:658:22a:cafe:200::1/64')
1568 # rfc3513 sec 2.3 says that ipv6 only uses cidr notation for
1569 # subnets
1570 self.assertEqual(str(self.ipv6_interface.with_netmask),
1571 '2001:658:22a:cafe:200::1/64')
1572 # this probably don't make much sense, but it's included for
1573 # compatibility with ipv4
1574 self.assertEqual(str(self.ipv6_interface.with_hostmask),
1575 '2001:658:22a:cafe:200::1/::ffff:ffff:ffff:ffff')
1576
1577 def testNetworkElementCaching(self):
1578 # V4 - make sure we're empty
1579 self.assertFalse('network_address' in self.ipv4_network._cache)
1580 self.assertFalse('broadcast_address' in self.ipv4_network._cache)
1581 self.assertFalse('hostmask' in self.ipv4_network._cache)
1582
1583 # V4 - populate and test
1584 self.assertEqual(self.ipv4_network.network_address,
1585 ipaddress.IPv4Address('1.2.3.0'))
1586 self.assertEqual(self.ipv4_network.broadcast_address,
1587 ipaddress.IPv4Address('1.2.3.255'))
1588 self.assertEqual(self.ipv4_network.hostmask,
1589 ipaddress.IPv4Address('0.0.0.255'))
1590
1591 # V4 - check we're cached
1592 self.assertTrue('broadcast_address' in self.ipv4_network._cache)
1593 self.assertTrue('hostmask' in self.ipv4_network._cache)
1594
1595 # V6 - make sure we're empty
1596 self.assertFalse('broadcast_address' in self.ipv6_network._cache)
1597 self.assertFalse('hostmask' in self.ipv6_network._cache)
1598
1599 # V6 - populate and test
1600 self.assertEqual(self.ipv6_network.network_address,
1601 ipaddress.IPv6Address('2001:658:22a:cafe::'))
1602 self.assertEqual(self.ipv6_interface.network.network_address,
1603 ipaddress.IPv6Address('2001:658:22a:cafe::'))
1604
1605 self.assertEqual(
1606 self.ipv6_network.broadcast_address,
1607 ipaddress.IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff'))
1608 self.assertEqual(self.ipv6_network.hostmask,
1609 ipaddress.IPv6Address('::ffff:ffff:ffff:ffff'))
1610 self.assertEqual(
1611 self.ipv6_interface.network.broadcast_address,
1612 ipaddress.IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff'))
1613 self.assertEqual(self.ipv6_interface.network.hostmask,
1614 ipaddress.IPv6Address('::ffff:ffff:ffff:ffff'))
1615
1616 # V6 - check we're cached
1617 self.assertTrue('broadcast_address' in self.ipv6_network._cache)
1618 self.assertTrue('hostmask' in self.ipv6_network._cache)
Hynek Schlawack91c5a342012-06-05 11:55:58 +02001619 self.assertTrue(
1620 'broadcast_address' in self.ipv6_interface.network._cache)
Nick Coghlandc9b2552012-05-20 21:01:57 +10001621 self.assertTrue('hostmask' in self.ipv6_interface.network._cache)
1622
1623 def testTeredo(self):
1624 # stolen from wikipedia
1625 server = ipaddress.IPv4Address('65.54.227.120')
1626 client = ipaddress.IPv4Address('192.0.2.45')
1627 teredo_addr = '2001:0000:4136:e378:8000:63bf:3fff:fdd2'
1628 self.assertEqual((server, client),
1629 ipaddress.ip_address(teredo_addr).teredo)
1630 bad_addr = '2000::4136:e378:8000:63bf:3fff:fdd2'
1631 self.assertFalse(ipaddress.ip_address(bad_addr).teredo)
1632 bad_addr = '2001:0001:4136:e378:8000:63bf:3fff:fdd2'
1633 self.assertFalse(ipaddress.ip_address(bad_addr).teredo)
1634
1635 # i77
1636 teredo_addr = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
1637 self.assertEqual((ipaddress.IPv4Address('94.245.121.253'),
1638 ipaddress.IPv4Address('95.26.244.94')),
1639 teredo_addr.teredo)
1640
Nick Coghlandc9b2552012-05-20 21:01:57 +10001641 def testsixtofour(self):
1642 sixtofouraddr = ipaddress.ip_address('2002:ac1d:2d64::1')
1643 bad_addr = ipaddress.ip_address('2000:ac1d:2d64::1')
1644 self.assertEqual(ipaddress.IPv4Address('172.29.45.100'),
1645 sixtofouraddr.sixtofour)
1646 self.assertFalse(bad_addr.sixtofour)
1647
Nick Coghlandc9b2552012-05-20 21:01:57 +10001648
1649if __name__ == '__main__':
1650 unittest.main()