Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython2 / 3bc37f2360d634b12190590aeb5de935bece5b78 / . / Lib / test / test_ipaddress.py
blob: 146f9a389fcf5a711d4c4d47be69e5e10e65fca9 [file] [log] [blame]
Nick Coghlandc9b2552012-05-20 21:01:57 +1000[diff] [blame]1#!/usr/bin/python3
2#
3# Copyright 2007 Google Inc.
4# Licensed to PSF under a Contributor Agreement.
5#
6# Licensed under the Apache License, Version 2.0 (the "License");
7# you may not use this file except in compliance with the License.
8# You may obtain a copy of the License at
9#
10# http://www.apache.org/licenses/LICENSE-2.0
11#
12# Unless required by applicable law or agreed to in writing, software
13# distributed under the License is distributed on an "AS IS" BASIS,
14# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15# See the License for the specific language governing permissions and
16# limitations under the License.
17
18"""Unittest for ipaddressmodule."""
19
20
21import unittest
22import time
23import ipaddress
24
25# Compatibility function to cast str to bytes objects
26_cb = lambda bytestr: bytes(bytestr, 'charmap')
27
28class IpaddrUnitTest(unittest.TestCase):
29
30 def setUp(self):
31 self.ipv4_address = ipaddress.IPv4Address('1.2.3.4')
32 self.ipv4_interface = ipaddress.IPv4Interface('1.2.3.4/24')
33 self.ipv4_network = ipaddress.IPv4Network('1.2.3.0/24')
34 #self.ipv4_hostmask = ipaddress.IPv4Interface('10.0.0.1/0.255.255.255')
35 self.ipv6_address = ipaddress.IPv6Interface(
36 '2001:658:22a:cafe:200:0:0:1')
37 self.ipv6_interface = ipaddress.IPv6Interface(
38 '2001:658:22a:cafe:200:0:0:1/64')
39 self.ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/64')
40
41 def testRepr(self):
42 self.assertEqual("IPv4Interface('1.2.3.4/32')",
43 repr(ipaddress.IPv4Interface('1.2.3.4')))
44 self.assertEqual("IPv6Interface('::1/128')",
45 repr(ipaddress.IPv6Interface('::1')))
46
47 # issue57
48 def testAddressIntMath(self):
49 self.assertEqual(ipaddress.IPv4Address('1.1.1.1') + 255,
50 ipaddress.IPv4Address('1.1.2.0'))
51 self.assertEqual(ipaddress.IPv4Address('1.1.1.1') - 256,
52 ipaddress.IPv4Address('1.1.0.1'))
53 self.assertEqual(ipaddress.IPv6Address('::1') + (2**16 - 2),
54 ipaddress.IPv6Address('::ffff'))
55 self.assertEqual(ipaddress.IPv6Address('::ffff') - (2**16 - 2),
56 ipaddress.IPv6Address('::1'))
57
58 def testInvalidStrings(self):
59 def AssertInvalidIP(ip_str):
60 self.assertRaises(ValueError, ipaddress.ip_address, ip_str)
61 AssertInvalidIP("")
62 AssertInvalidIP("016.016.016.016")
63 AssertInvalidIP("016.016.016")
64 AssertInvalidIP("016.016")
65 AssertInvalidIP("016")
66 AssertInvalidIP("000.000.000.000")
67 AssertInvalidIP("000")
68 AssertInvalidIP("0x0a.0x0a.0x0a.0x0a")
69 AssertInvalidIP("0x0a.0x0a.0x0a")
70 AssertInvalidIP("0x0a.0x0a")
71 AssertInvalidIP("0x0a")
72 AssertInvalidIP("42.42.42.42.42")
73 AssertInvalidIP("42.42.42")
74 AssertInvalidIP("42.42")
75 AssertInvalidIP("42")
76 AssertInvalidIP("42..42.42")
77 AssertInvalidIP("42..42.42.42")
78 AssertInvalidIP("42.42.42.42.")
79 AssertInvalidIP("42.42.42.42...")
80 AssertInvalidIP(".42.42.42.42")
81 AssertInvalidIP("...42.42.42.42")
82 AssertInvalidIP("42.42.42.-0")
83 AssertInvalidIP("42.42.42.+0")
84 AssertInvalidIP(".")
85 AssertInvalidIP("...")
86 AssertInvalidIP("bogus")
87 AssertInvalidIP("bogus.com")
88 AssertInvalidIP("192.168.0.1.com")
89 AssertInvalidIP("12345.67899.-54321.-98765")
90 AssertInvalidIP("257.0.0.0")
91 AssertInvalidIP("42.42.42.-42")
92 AssertInvalidIP("3ffe::1.net")
93 AssertInvalidIP("3ffe::1::1")
94 AssertInvalidIP("1::2::3::4:5")
95 AssertInvalidIP("::7:6:5:4:3:2:")
96 AssertInvalidIP(":6:5:4:3:2:1::")
97 AssertInvalidIP("2001::db:::1")
98 AssertInvalidIP("FEDC:9878")
99 AssertInvalidIP("+1.+2.+3.4")
100 AssertInvalidIP("1.2.3.4e0")
101 AssertInvalidIP("::7:6:5:4:3:2:1:0")
102 AssertInvalidIP("7:6:5:4:3:2:1:0::")
103 AssertInvalidIP("9:8:7:6:5:4:3::2:1")
104 AssertInvalidIP("0:1:2:3::4:5:6:7")
105 AssertInvalidIP("3ffe:0:0:0:0:0:0:0:1")
106 AssertInvalidIP("3ffe::10000")
107 AssertInvalidIP("3ffe::goog")
108 AssertInvalidIP("3ffe::-0")
109 AssertInvalidIP("3ffe::+0")
110 AssertInvalidIP("3ffe::-1")
111 AssertInvalidIP(":")
112 AssertInvalidIP(":::")
113 AssertInvalidIP("::1.2.3")
114 AssertInvalidIP("::1.2.3.4.5")
115 AssertInvalidIP("::1.2.3.4:")
116 AssertInvalidIP("1.2.3.4::")
117 AssertInvalidIP("2001:db8::1:")
118 AssertInvalidIP(":2001:db8::1")
119 AssertInvalidIP(":1:2:3:4:5:6:7")
120 AssertInvalidIP("1:2:3:4:5:6:7:")
121 AssertInvalidIP(":1:2:3:4:5:6:")
122
123 self.assertRaises(ipaddress.AddressValueError,
124 ipaddress.IPv4Interface, '')
125 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv4Interface,
126 'google.com')
127 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv4Interface,
128 '::1.2.3.4')
129 self.assertRaises(ipaddress.AddressValueError,
130 ipaddress.IPv6Interface, '')
131 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
132 'google.com')
133 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
134 '1.2.3.4')
135 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
136 'cafe:cafe::/128/190')
137 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
138 '1234:axy::b')
139 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Address,
140 '1234:axy::b')
141 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Address,
142 '2001:db8:::1')
143 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Address,
144 '2001:888888::1')
145 self.assertRaises(ipaddress.AddressValueError,
146 ipaddress.IPv4Address(1)._ip_int_from_string,
147 '1.a.2.3')
148 self.assertEqual(False, ipaddress.IPv4Interface(1)._is_hostmask(
149 '1.a.2.3'))
150
151 def testGetNetwork(self):
152 self.assertEqual(int(self.ipv4_network.network_address), 16909056)
153 self.assertEqual(str(self.ipv4_network.network_address), '1.2.3.0')
154
155 self.assertEqual(int(self.ipv6_network.network_address),
156 42540616829182469433403647294022090752)
157 self.assertEqual(str(self.ipv6_network.network_address),
158 '2001:658:22a:cafe::')
159 self.assertEqual(str(self.ipv6_network.hostmask),
160 '::ffff:ffff:ffff:ffff')
161
162 def testBadVersionComparison(self):
163 # These should always raise TypeError
164 v4addr = ipaddress.ip_address('1.1.1.1')
165 v4net = ipaddress.ip_network('1.1.1.1')
166 v6addr = ipaddress.ip_address('::1')
167 v6net = ipaddress.ip_address('::1')
168
169 self.assertRaises(TypeError, v4addr.__lt__, v6addr)
170 self.assertRaises(TypeError, v4addr.__gt__, v6addr)
171 self.assertRaises(TypeError, v4net.__lt__, v6net)
172 self.assertRaises(TypeError, v4net.__gt__, v6net)
173
174 self.assertRaises(TypeError, v6addr.__lt__, v4addr)
175 self.assertRaises(TypeError, v6addr.__gt__, v4addr)
176 self.assertRaises(TypeError, v6net.__lt__, v4net)
177 self.assertRaises(TypeError, v6net.__gt__, v4net)
178
179 def testMixedTypeComparison(self):
180 v4addr = ipaddress.ip_address('1.1.1.1')
181 v4net = ipaddress.ip_network('1.1.1.1/32')
182 v6addr = ipaddress.ip_address('::1')
183 v6net = ipaddress.ip_network('::1/128')
184
185 self.assertFalse(v4net.__contains__(v6net))
186 self.assertFalse(v6net.__contains__(v4net))
187
188 self.assertRaises(TypeError, lambda: v4addr < v4net)
189 self.assertRaises(TypeError, lambda: v4addr > v4net)
190 self.assertRaises(TypeError, lambda: v4net < v4addr)
191 self.assertRaises(TypeError, lambda: v4net > v4addr)
192
193 self.assertRaises(TypeError, lambda: v6addr < v6net)
194 self.assertRaises(TypeError, lambda: v6addr > v6net)
195 self.assertRaises(TypeError, lambda: v6net < v6addr)
196 self.assertRaises(TypeError, lambda: v6net > v6addr)
197
198 # with get_mixed_type_key, you can sort addresses and network.
199 self.assertEqual([v4addr, v4net],
200 sorted([v4net, v4addr],
201 key=ipaddress.get_mixed_type_key))
202 self.assertEqual([v6addr, v6net],
203 sorted([v6net, v6addr],
204 key=ipaddress.get_mixed_type_key))
205
206 def testIpFromInt(self):
207 self.assertEqual(self.ipv4_interface._ip,
208 ipaddress.IPv4Interface(16909060)._ip)
209 self.assertRaises(ipaddress.AddressValueError,
210 ipaddress.IPv4Interface, 2**32)
211 self.assertRaises(ipaddress.AddressValueError,
212 ipaddress.IPv4Interface, -1)
213
214 ipv4 = ipaddress.ip_network('1.2.3.4')
215 ipv6 = ipaddress.ip_network('2001:658:22a:cafe:200:0:0:1')
216 self.assertEqual(ipv4, ipaddress.ip_network(int(ipv4)))
217 self.assertEqual(ipv6, ipaddress.ip_network(int(ipv6)))
218
219 v6_int = 42540616829182469433547762482097946625
220 self.assertEqual(self.ipv6_interface._ip,
221 ipaddress.IPv6Interface(v6_int)._ip)
222 self.assertRaises(ipaddress.AddressValueError,
223 ipaddress.IPv6Interface, 2**128)
224 self.assertRaises(ipaddress.AddressValueError,
225 ipaddress.IPv6Interface, -1)
226
227 self.assertEqual(ipaddress.ip_network(self.ipv4_address._ip).version, 4)
228 self.assertEqual(ipaddress.ip_network(self.ipv6_address._ip).version, 6)
229
230 def testIpFromPacked(self):
231 ip = ipaddress.ip_network
232
233 self.assertEqual(self.ipv4_interface._ip,
234 ipaddress.ip_interface(_cb('\x01\x02\x03\x04'))._ip)
235 self.assertEqual(ip('255.254.253.252'),
236 ip(_cb('\xff\xfe\xfd\xfc')))
237 self.assertRaises(ValueError, ipaddress.ip_network, _cb('\x00' * 3))
238 self.assertRaises(ValueError, ipaddress.ip_network, _cb('\x00' * 5))
239 self.assertEqual(self.ipv6_interface.ip,
240 ipaddress.ip_interface(
241 _cb('\x20\x01\x06\x58\x02\x2a\xca\xfe'
242 '\x02\x00\x00\x00\x00\x00\x00\x01')).ip)
243 self.assertEqual(ip('ffff:2:3:4:ffff::'),
244 ip(_cb('\xff\xff\x00\x02\x00\x03\x00\x04' +
245 '\xff\xff' + '\x00' * 6)))
246 self.assertEqual(ip('::'),
247 ip(_cb('\x00' * 16)))
248 self.assertRaises(ValueError, ip, _cb('\x00' * 15))
249 self.assertRaises(ValueError, ip, _cb('\x00' * 17))
250
251 def testGetIp(self):
252 self.assertEqual(int(self.ipv4_interface.ip), 16909060)
253 self.assertEqual(str(self.ipv4_interface.ip), '1.2.3.4')
254
255 self.assertEqual(int(self.ipv6_interface.ip),
256 42540616829182469433547762482097946625)
257 self.assertEqual(str(self.ipv6_interface.ip),
258 '2001:658:22a:cafe:200::1')
259
260 def testGetNetmask(self):
261 self.assertEqual(int(self.ipv4_network.netmask), 4294967040)
262 self.assertEqual(str(self.ipv4_network.netmask), '255.255.255.0')
263 self.assertEqual(int(self.ipv6_network.netmask),
264 340282366920938463444927863358058659840)
265 self.assertEqual(self.ipv6_network.prefixlen, 64)
266
267 def testZeroNetmask(self):
268 ipv4_zero_netmask = ipaddress.IPv4Interface('1.2.3.4/0')
269 self.assertEqual(int(ipv4_zero_netmask.network.netmask), 0)
270 self.assertTrue(ipv4_zero_netmask.network._is_valid_netmask(
271 str(0)))
272
273 ipv6_zero_netmask = ipaddress.IPv6Interface('::1/0')
274 self.assertEqual(int(ipv6_zero_netmask.network.netmask), 0)
275 self.assertTrue(ipv6_zero_netmask.network._is_valid_netmask(
276 str(0)))
277
278 def testGetBroadcast(self):
279 self.assertEqual(int(self.ipv4_network.broadcast_address), 16909311)
280 self.assertEqual(str(self.ipv4_network.broadcast_address), '1.2.3.255')
281
282 self.assertEqual(int(self.ipv6_network.broadcast_address),
283 42540616829182469451850391367731642367)
284 self.assertEqual(str(self.ipv6_network.broadcast_address),
285 '2001:658:22a:cafe:ffff:ffff:ffff:ffff')
286
287 def testGetPrefixlen(self):
288 self.assertEqual(self.ipv4_interface.prefixlen, 24)
289 self.assertEqual(self.ipv6_interface.prefixlen, 64)
290
291 def testGetSupernet(self):
292 self.assertEqual(self.ipv4_network.supernet().prefixlen, 23)
293 self.assertEqual(str(self.ipv4_network.supernet().network_address),
294 '1.2.2.0')
295 self.assertEqual(
296 ipaddress.IPv4Interface('0.0.0.0/0').network.supernet(),
297 ipaddress.IPv4Network('0.0.0.0/0'))
298
299 self.assertEqual(self.ipv6_network.supernet().prefixlen, 63)
300 self.assertEqual(str(self.ipv6_network.supernet().network_address),
301 '2001:658:22a:cafe::')
302 self.assertEqual(ipaddress.IPv6Interface('::0/0').network.supernet(),
303 ipaddress.IPv6Network('::0/0'))
304
305 def testGetSupernet3(self):
306 self.assertEqual(self.ipv4_network.supernet(3).prefixlen, 21)
307 self.assertEqual(str(self.ipv4_network.supernet(3).network_address),
308 '1.2.0.0')
309
310 self.assertEqual(self.ipv6_network.supernet(3).prefixlen, 61)
311 self.assertEqual(str(self.ipv6_network.supernet(3).network_address),
312 '2001:658:22a:caf8::')
313
314 def testGetSupernet4(self):
315 self.assertRaises(ValueError, self.ipv4_network.supernet,
316 prefixlen_diff=2, new_prefix=1)
317 self.assertRaises(ValueError, self.ipv4_network.supernet, new_prefix=25)
318 self.assertEqual(self.ipv4_network.supernet(prefixlen_diff=2),
319 self.ipv4_network.supernet(new_prefix=22))
320
321 self.assertRaises(ValueError, self.ipv6_network.supernet,
322 prefixlen_diff=2, new_prefix=1)
323 self.assertRaises(ValueError, self.ipv6_network.supernet, new_prefix=65)
324 self.assertEqual(self.ipv6_network.supernet(prefixlen_diff=2),
325 self.ipv6_network.supernet(new_prefix=62))
326
327 def testHosts(self):
328 self.assertEqual([ipaddress.IPv4Address('2.0.0.0'),
329 ipaddress.IPv4Address('2.0.0.1')],
330 list(ipaddress.ip_network('2.0.0.0/31').hosts()))
331
332 def testFancySubnetting(self):
333 self.assertEqual(sorted(self.ipv4_network.subnets(prefixlen_diff=3)),
334 sorted(self.ipv4_network.subnets(new_prefix=27)))
335 self.assertRaises(ValueError, list,
336 self.ipv4_network.subnets(new_prefix=23))
337 self.assertRaises(ValueError, list,
338 self.ipv4_network.subnets(prefixlen_diff=3,
339 new_prefix=27))
340 self.assertEqual(sorted(self.ipv6_network.subnets(prefixlen_diff=4)),
341 sorted(self.ipv6_network.subnets(new_prefix=68)))
342 self.assertRaises(ValueError, list,
343 self.ipv6_network.subnets(new_prefix=63))
344 self.assertRaises(ValueError, list,
345 self.ipv6_network.subnets(prefixlen_diff=4,
346 new_prefix=68))
347
348 def testGetSubnets(self):
349 self.assertEqual(list(self.ipv4_network.subnets())[0].prefixlen, 25)
350 self.assertEqual(str(list(
351 self.ipv4_network.subnets())[0].network_address),
352 '1.2.3.0')
353 self.assertEqual(str(list(
354 self.ipv4_network.subnets())[1].network_address),
355 '1.2.3.128')
356
357 self.assertEqual(list(self.ipv6_network.subnets())[0].prefixlen, 65)
358
359 def testGetSubnetForSingle32(self):
360 ip = ipaddress.IPv4Network('1.2.3.4/32')
361 subnets1 = [str(x) for x in ip.subnets()]
362 subnets2 = [str(x) for x in ip.subnets(2)]
363 self.assertEqual(subnets1, ['1.2.3.4/32'])
364 self.assertEqual(subnets1, subnets2)
365
366 def testGetSubnetForSingle128(self):
367 ip = ipaddress.IPv6Network('::1/128')
368 subnets1 = [str(x) for x in ip.subnets()]
369 subnets2 = [str(x) for x in ip.subnets(2)]
370 self.assertEqual(subnets1, ['::1/128'])
371 self.assertEqual(subnets1, subnets2)
372
373 def testSubnet2(self):
374 ips = [str(x) for x in self.ipv4_network.subnets(2)]
375 self.assertEqual(
376 ips,
377 ['1.2.3.0/26', '1.2.3.64/26', '1.2.3.128/26', '1.2.3.192/26'])
378
379 ipsv6 = [str(x) for x in self.ipv6_network.subnets(2)]
380 self.assertEqual(
381 ipsv6,
382 ['2001:658:22a:cafe::/66',
383 '2001:658:22a:cafe:4000::/66',
384 '2001:658:22a:cafe:8000::/66',
385 '2001:658:22a:cafe:c000::/66'])
386
387 def testSubnetFailsForLargeCidrDiff(self):
388 self.assertRaises(ValueError, list,
389 self.ipv4_interface.network.subnets(9))
390 self.assertRaises(ValueError, list,
391 self.ipv4_network.subnets(9))
392 self.assertRaises(ValueError, list,
393 self.ipv6_interface.network.subnets(65))
394 self.assertRaises(ValueError, list,
395 self.ipv6_network.subnets(65))
396
397 def testSupernetFailsForLargeCidrDiff(self):
398 self.assertRaises(ValueError,
399 self.ipv4_interface.network.supernet, 25)
400 self.assertRaises(ValueError,
401 self.ipv6_interface.network.supernet, 65)
402
403 def testSubnetFailsForNegativeCidrDiff(self):
404 self.assertRaises(ValueError, list,
405 self.ipv4_interface.network.subnets(-1))
406 self.assertRaises(ValueError, list,
407 self.ipv4_network.network.subnets(-1))
408 self.assertRaises(ValueError, list,
409 self.ipv6_interface.network.subnets(-1))
410 self.assertRaises(ValueError, list,
411 self.ipv6_network.subnets(-1))
412
413 def testGetNum_Addresses(self):
414 self.assertEqual(self.ipv4_network.num_addresses, 256)
415 self.assertEqual(list(self.ipv4_network.subnets())[0].num_addresses, 128)
416 self.assertEqual(self.ipv4_network.supernet().num_addresses, 512)
417
418 self.assertEqual(self.ipv6_network.num_addresses, 18446744073709551616)
419 self.assertEqual(list(self.ipv6_network.subnets())[0].num_addresses,
420 9223372036854775808)
421 self.assertEqual(self.ipv6_network.supernet().num_addresses,
422 36893488147419103232)
423
424 def testContains(self):
425 self.assertTrue(ipaddress.IPv4Interface('1.2.3.128/25') in
426 self.ipv4_network)
427 self.assertFalse(ipaddress.IPv4Interface('1.2.4.1/24') in
428 self.ipv4_network)
429 # We can test addresses and string as well.
430 addr1 = ipaddress.IPv4Address('1.2.3.37')
431 self.assertTrue(addr1 in self.ipv4_network)
432 # issue 61, bad network comparison on like-ip'd network objects
433 # with identical broadcast addresses.
434 self.assertFalse(ipaddress.IPv4Network('1.1.0.0/16').__contains__(
435 ipaddress.IPv4Network('1.0.0.0/15')))
436
437 def testBadAddress(self):
438 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv4Interface,
439 'poop')
440 self.assertRaises(ipaddress.AddressValueError,
441 ipaddress.IPv4Interface, '1.2.3.256')
442
443 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
444 'poopv6')
445 self.assertRaises(ipaddress.AddressValueError,
446 ipaddress.IPv4Interface, '1.2.3.4/32/24')
447 self.assertRaises(ipaddress.AddressValueError,
448 ipaddress.IPv4Interface, '10/8')
449 self.assertRaises(ipaddress.AddressValueError,
450 ipaddress.IPv6Interface, '10/8')
451
452
453 def testBadNetMask(self):
454 self.assertRaises(ipaddress.NetmaskValueError,
455 ipaddress.IPv4Interface, '1.2.3.4/')
456 self.assertRaises(ipaddress.NetmaskValueError,
457 ipaddress.IPv4Interface, '1.2.3.4/33')
458 self.assertRaises(ipaddress.NetmaskValueError,
459 ipaddress.IPv4Interface, '1.2.3.4/254.254.255.256')
460 self.assertRaises(ipaddress.NetmaskValueError,
461 ipaddress.IPv4Interface, '1.1.1.1/240.255.0.0')
462 self.assertRaises(ipaddress.NetmaskValueError,
463 ipaddress.IPv6Interface, '::1/')
464 self.assertRaises(ipaddress.NetmaskValueError,
465 ipaddress.IPv6Interface, '::1/129')
466
467 def testNth(self):
468 self.assertEqual(str(self.ipv4_network[5]), '1.2.3.5')
469 self.assertRaises(IndexError, self.ipv4_network.__getitem__, 256)
470
471 self.assertEqual(str(self.ipv6_network[5]),
472 '2001:658:22a:cafe::5')
473
474 def testGetitem(self):
475 # http://code.google.com/p/ipaddr-py/issues/detail?id=15
476 addr = ipaddress.IPv4Network('172.31.255.128/255.255.255.240')
477 self.assertEqual(28, addr.prefixlen)
478 addr_list = list(addr)
479 self.assertEqual('172.31.255.128', str(addr_list[0]))
480 self.assertEqual('172.31.255.128', str(addr[0]))
481 self.assertEqual('172.31.255.143', str(addr_list[-1]))
482 self.assertEqual('172.31.255.143', str(addr[-1]))
483 self.assertEqual(addr_list[-1], addr[-1])
484
485 def testEqual(self):
486 self.assertTrue(self.ipv4_interface ==
487 ipaddress.IPv4Interface('1.2.3.4/24'))
488 self.assertFalse(self.ipv4_interface ==
489 ipaddress.IPv4Interface('1.2.3.4/23'))
490 self.assertFalse(self.ipv4_interface ==
491 ipaddress.IPv6Interface('::1.2.3.4/24'))
492 self.assertFalse(self.ipv4_interface == '')
493 self.assertFalse(self.ipv4_interface == [])
494 self.assertFalse(self.ipv4_interface == 2)
495
496 self.assertTrue(self.ipv6_interface ==
497 ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64'))
498 self.assertFalse(self.ipv6_interface ==
499 ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63'))
500 self.assertFalse(self.ipv6_interface ==
501 ipaddress.IPv4Interface('1.2.3.4/23'))
502 self.assertFalse(self.ipv6_interface == '')
503 self.assertFalse(self.ipv6_interface == [])
504 self.assertFalse(self.ipv6_interface == 2)
505
506 def testNotEqual(self):
507 self.assertFalse(self.ipv4_interface !=
508 ipaddress.IPv4Interface('1.2.3.4/24'))
509 self.assertTrue(self.ipv4_interface !=
510 ipaddress.IPv4Interface('1.2.3.4/23'))
511 self.assertTrue(self.ipv4_interface !=
512 ipaddress.IPv6Interface('::1.2.3.4/24'))
513 self.assertTrue(self.ipv4_interface != '')
514 self.assertTrue(self.ipv4_interface != [])
515 self.assertTrue(self.ipv4_interface != 2)
516
517 self.assertTrue(self.ipv4_address !=
518 ipaddress.IPv4Address('1.2.3.5'))
519 self.assertTrue(self.ipv4_address != '')
520 self.assertTrue(self.ipv4_address != [])
521 self.assertTrue(self.ipv4_address != 2)
522
523 self.assertFalse(self.ipv6_interface !=
524 ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64'))
525 self.assertTrue(self.ipv6_interface !=
526 ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63'))
527 self.assertTrue(self.ipv6_interface !=
528 ipaddress.IPv4Interface('1.2.3.4/23'))
529 self.assertTrue(self.ipv6_interface != '')
530 self.assertTrue(self.ipv6_interface != [])
531 self.assertTrue(self.ipv6_interface != 2)
532
533 self.assertTrue(self.ipv6_address !=
534 ipaddress.IPv4Address('1.2.3.4'))
535 self.assertTrue(self.ipv6_address != '')
536 self.assertTrue(self.ipv6_address != [])
537 self.assertTrue(self.ipv6_address != 2)
538
539 def testSlash32Constructor(self):
540 self.assertEqual(str(ipaddress.IPv4Interface(
541 '1.2.3.4/255.255.255.255')), '1.2.3.4/32')
542
543 def testSlash128Constructor(self):
544 self.assertEqual(str(ipaddress.IPv6Interface('::1/128')),
545 '::1/128')
546
547 def testSlash0Constructor(self):
548 self.assertEqual(str(ipaddress.IPv4Interface('1.2.3.4/0.0.0.0')),
549 '1.2.3.4/0')
550
551 def testCollapsing(self):
552 # test only IP addresses including some duplicates
553 ip1 = ipaddress.IPv4Address('1.1.1.0')
554 ip2 = ipaddress.IPv4Address('1.1.1.1')
555 ip3 = ipaddress.IPv4Address('1.1.1.2')
556 ip4 = ipaddress.IPv4Address('1.1.1.3')
557 ip5 = ipaddress.IPv4Address('1.1.1.4')
558 ip6 = ipaddress.IPv4Address('1.1.1.0')
559 # check that addreses are subsumed properly.
560 collapsed = ipaddress.collapse_addresses(
561 [ip1, ip2, ip3, ip4, ip5, ip6])
562 self.assertEqual(list(collapsed), [ipaddress.IPv4Network('1.1.1.0/30'),
563 ipaddress.IPv4Network('1.1.1.4/32')])
564
565 # test a mix of IP addresses and networks including some duplicates
566 ip1 = ipaddress.IPv4Address('1.1.1.0')
567 ip2 = ipaddress.IPv4Address('1.1.1.1')
568 ip3 = ipaddress.IPv4Address('1.1.1.2')
569 ip4 = ipaddress.IPv4Address('1.1.1.3')
570 #ip5 = ipaddress.IPv4Interface('1.1.1.4/30')
571 #ip6 = ipaddress.IPv4Interface('1.1.1.4/30')
572 # check that addreses are subsumed properly.
573 collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4])
574 self.assertEqual(list(collapsed), [ipaddress.IPv4Network('1.1.1.0/30')])
575
576 # test only IP networks
577 ip1 = ipaddress.IPv4Network('1.1.0.0/24')
578 ip2 = ipaddress.IPv4Network('1.1.1.0/24')
579 ip3 = ipaddress.IPv4Network('1.1.2.0/24')
580 ip4 = ipaddress.IPv4Network('1.1.3.0/24')
581 ip5 = ipaddress.IPv4Network('1.1.4.0/24')
582 # stored in no particular order b/c we want CollapseAddr to call [].sort
583 ip6 = ipaddress.IPv4Network('1.1.0.0/22')
584 # check that addreses are subsumed properly.
585 collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4, ip5,
586 ip6])
587 self.assertEqual(list(collapsed), [ipaddress.IPv4Network('1.1.0.0/22'),
588 ipaddress.IPv4Network('1.1.4.0/24')])
589
590 # test that two addresses are supernet'ed properly
591 collapsed = ipaddress.collapse_addresses([ip1, ip2])
592 self.assertEqual(list(collapsed), [ipaddress.IPv4Network('1.1.0.0/23')])
593
594 # test same IP networks
595 ip_same1 = ip_same2 = ipaddress.IPv4Network('1.1.1.1/32')
596 self.assertEqual(list(ipaddress.collapse_addresses(
597 [ip_same1, ip_same2])),
598 [ip_same1])
599
600 # test same IP addresses
601 ip_same1 = ip_same2 = ipaddress.IPv4Address('1.1.1.1')
602 self.assertEqual(list(ipaddress.collapse_addresses(
603 [ip_same1, ip_same2])),
604 [ipaddress.ip_network('1.1.1.1/32')])
605 ip1 = ipaddress.IPv6Network('2001::/100')
606 ip2 = ipaddress.IPv6Network('2001::/120')
607 ip3 = ipaddress.IPv6Network('2001::/96')
608 # test that ipv6 addresses are subsumed properly.
609 collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3])
610 self.assertEqual(list(collapsed), [ip3])
611
612 # the toejam test
613 ip1 = ipaddress.ip_address('1.1.1.1')
614 ip2 = ipaddress.ip_address('::1')
615 self.assertRaises(TypeError, ipaddress.collapse_addresses,
616 [ip1, ip2])
617
618 def testSummarizing(self):
619 #ip = ipaddress.ip_address
620 #ipnet = ipaddress.ip_network
621 summarize = ipaddress.summarize_address_range
622 ip1 = ipaddress.ip_address('1.1.1.0')
623 ip2 = ipaddress.ip_address('1.1.1.255')
624 # test a /24 is sumamrized properly
625 self.assertEqual(list(summarize(ip1, ip2))[0],
626 ipaddress.ip_network('1.1.1.0/24'))
627 # test an IPv4 range that isn't on a network byte boundary
628 ip2 = ipaddress.ip_address('1.1.1.8')
629 self.assertEqual(list(summarize(ip1, ip2)),
630 [ipaddress.ip_network('1.1.1.0/29'),
631 ipaddress.ip_network('1.1.1.8')])
632
633 ip1 = ipaddress.ip_address('1::')
634 ip2 = ipaddress.ip_address('1:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
635 # test a IPv6 is sumamrized properly
636 self.assertEqual(list(summarize(ip1, ip2))[0],
637 ipaddress.ip_network('1::/16'))
638 # test an IPv6 range that isn't on a network byte boundary
639 ip2 = ipaddress.ip_address('2::')
640 self.assertEqual(list(summarize(ip1, ip2)),
641 [ipaddress.ip_network('1::/16'),
642 ipaddress.ip_network('2::/128')])
643
644 # test exception raised when first is greater than last
645 self.assertRaises(ValueError, list,
646 summarize(ipaddress.ip_address('1.1.1.0'),
647 ipaddress.ip_address('1.1.0.0')))
648 # test exception raised when first and last aren't IP addresses
649 self.assertRaises(TypeError, list,
650 summarize(ipaddress.ip_network('1.1.1.0'),
651 ipaddress.ip_network('1.1.0.0')))
652 self.assertRaises(TypeError, list,
653 summarize(ipaddress.ip_network('1.1.1.0'),
654 ipaddress.ip_network('1.1.0.0')))
655 # test exception raised when first and last are not same version
656 self.assertRaises(TypeError, list,
657 summarize(ipaddress.ip_address('::'),
658 ipaddress.ip_network('1.1.0.0')))
659
660 def testAddressComparison(self):
661 self.assertTrue(ipaddress.ip_address('1.1.1.1') <=
662 ipaddress.ip_address('1.1.1.1'))
663 self.assertTrue(ipaddress.ip_address('1.1.1.1') <=
664 ipaddress.ip_address('1.1.1.2'))
665 self.assertTrue(ipaddress.ip_address('::1') <=
666 ipaddress.ip_address('::1'))
667 self.assertTrue(ipaddress.ip_address('::1') <=
668 ipaddress.ip_address('::2'))
669
670 def testNetworkComparison(self):
671 # ip1 and ip2 have the same network address
672 ip1 = ipaddress.IPv4Network('1.1.1.0/24')
673 ip2 = ipaddress.IPv4Network('1.1.1.1/32')
674 ip3 = ipaddress.IPv4Network('1.1.2.0/24')
675
676 self.assertTrue(ip1 < ip3)
677 self.assertTrue(ip3 > ip2)
678
679 #self.assertEqual(ip1.compare_networks(ip2), 0)
680 #self.assertTrue(ip1._get_networks_key() == ip2._get_networks_key())
681 self.assertEqual(ip1.compare_networks(ip3), -1)
682 self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
683
684 ip1 = ipaddress.IPv6Network('2001:2000::/96')
685 ip2 = ipaddress.IPv6Network('2001:2001::/96')
686 ip3 = ipaddress.IPv6Network('2001:ffff:2000::/96')
687
688 self.assertTrue(ip1 < ip3)
689 self.assertTrue(ip3 > ip2)
690 self.assertEqual(ip1.compare_networks(ip3), -1)
691 self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
692
693 # Test comparing different protocols.
694 # Should always raise a TypeError.
695 ipv6 = ipaddress.IPv6Interface('::/0')
696 ipv4 = ipaddress.IPv4Interface('0.0.0.0/0')
697 self.assertRaises(TypeError, ipv4.__lt__, ipv6)
698 self.assertRaises(TypeError, ipv4.__gt__, ipv6)
699 self.assertRaises(TypeError, ipv6.__lt__, ipv4)
700 self.assertRaises(TypeError, ipv6.__gt__, ipv4)
701
702 # Regression test for issue 19.
703 ip1 = ipaddress.ip_network('10.1.2.128/25')
704 self.assertFalse(ip1 < ip1)
705 self.assertFalse(ip1 > ip1)
706 ip2 = ipaddress.ip_network('10.1.3.0/24')
707 self.assertTrue(ip1 < ip2)
708 self.assertFalse(ip2 < ip1)
709 self.assertFalse(ip1 > ip2)
710 self.assertTrue(ip2 > ip1)
711 ip3 = ipaddress.ip_network('10.1.3.0/25')
712 self.assertTrue(ip2 < ip3)
713 self.assertFalse(ip3 < ip2)
714 self.assertFalse(ip2 > ip3)
715 self.assertTrue(ip3 > ip2)
716
717 # Regression test for issue 28.
718 ip1 = ipaddress.ip_network('10.10.10.0/31')
719 ip2 = ipaddress.ip_network('10.10.10.0')
720 ip3 = ipaddress.ip_network('10.10.10.2/31')
721 ip4 = ipaddress.ip_network('10.10.10.2')
722 sorted = [ip1, ip2, ip3, ip4]
723 unsorted = [ip2, ip4, ip1, ip3]
724 unsorted.sort()
725 self.assertEqual(sorted, unsorted)
726 unsorted = [ip4, ip1, ip3, ip2]
727 unsorted.sort()
728 self.assertEqual(sorted, unsorted)
729 self.assertRaises(TypeError, ip1.__lt__,
730 ipaddress.ip_address('10.10.10.0'))
731 self.assertRaises(TypeError, ip2.__lt__,
732 ipaddress.ip_address('10.10.10.0'))
733
734 # <=, >=
735 self.assertTrue(ipaddress.ip_network('1.1.1.1') <=
736 ipaddress.ip_network('1.1.1.1'))
737 self.assertTrue(ipaddress.ip_network('1.1.1.1') <=
738 ipaddress.ip_network('1.1.1.2'))
739 self.assertFalse(ipaddress.ip_network('1.1.1.2') <=
740 ipaddress.ip_network('1.1.1.1'))
741 self.assertTrue(ipaddress.ip_network('::1') <=
742 ipaddress.ip_network('::1'))
743 self.assertTrue(ipaddress.ip_network('::1') <=
744 ipaddress.ip_network('::2'))
745 self.assertFalse(ipaddress.ip_network('::2') <=
746 ipaddress.ip_network('::1'))
747
748 def testStrictNetworks(self):
749 self.assertRaises(ValueError, ipaddress.ip_network, '192.168.1.1/24')
750 self.assertRaises(ValueError, ipaddress.ip_network, '::1/120')
751
752 def testOverlaps(self):
753 other = ipaddress.IPv4Network('1.2.3.0/30')
754 other2 = ipaddress.IPv4Network('1.2.2.0/24')
755 other3 = ipaddress.IPv4Network('1.2.2.64/26')
756 self.assertTrue(self.ipv4_network.overlaps(other))
757 self.assertFalse(self.ipv4_network.overlaps(other2))
758 self.assertTrue(other2.overlaps(other3))
759
760 def testEmbeddedIpv4(self):
761 ipv4_string = '192.168.0.1'
762 ipv4 = ipaddress.IPv4Interface(ipv4_string)
763 v4compat_ipv6 = ipaddress.IPv6Interface('::%s' % ipv4_string)
764 self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
765 v4mapped_ipv6 = ipaddress.IPv6Interface('::ffff:%s' % ipv4_string)
766 self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
767 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
768 '2001:1.1.1.1:1.1.1.1')
769
770 # Issue 67: IPv6 with embedded IPv4 address not recognized.
771 def testIPv6AddressTooLarge(self):
772 # RFC4291 2.5.5.2
773 self.assertEqual(ipaddress.ip_address('::FFFF:192.0.2.1'),
774 ipaddress.ip_address('::FFFF:c000:201'))
775 # RFC4291 2.2 (part 3) x::d.d.d.d
776 self.assertEqual(ipaddress.ip_address('FFFF::192.0.2.1'),
777 ipaddress.ip_address('FFFF::c000:201'))
778
779 def testIPVersion(self):
780 self.assertEqual(self.ipv4_address.version, 4)
781 self.assertEqual(self.ipv6_address.version, 6)
782
783 def testMaxPrefixLength(self):
784 self.assertEqual(self.ipv4_interface.max_prefixlen, 32)
785 self.assertEqual(self.ipv6_interface.max_prefixlen, 128)
786
787 def testPacked(self):
788 self.assertEqual(self.ipv4_address.packed,
789 _cb('\x01\x02\x03\x04'))
790 self.assertEqual(ipaddress.IPv4Interface('255.254.253.252').packed,
791 _cb('\xff\xfe\xfd\xfc'))
792 self.assertEqual(self.ipv6_address.packed,
793 _cb('\x20\x01\x06\x58\x02\x2a\xca\xfe'
794 '\x02\x00\x00\x00\x00\x00\x00\x01'))
795 self.assertEqual(ipaddress.IPv6Interface('ffff:2:3:4:ffff::').packed,
796 _cb('\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff'
797 + '\x00' * 6))
798 self.assertEqual(ipaddress.IPv6Interface('::1:0:0:0:0').packed,
799 _cb('\x00' * 6 + '\x00\x01' + '\x00' * 8))
800
801 def testIpStrFromPrefixlen(self):
802 ipv4 = ipaddress.IPv4Interface('1.2.3.4/24')
803 self.assertEqual(ipv4._ip_string_from_prefix(), '255.255.255.0')
804 self.assertEqual(ipv4._ip_string_from_prefix(28), '255.255.255.240')
805
806 def testIpType(self):
807 ipv4net = ipaddress.ip_network('1.2.3.4')
808 ipv4addr = ipaddress.ip_address('1.2.3.4')
809 ipv6net = ipaddress.ip_network('::1.2.3.4')
810 ipv6addr = ipaddress.ip_address('::1.2.3.4')
811 self.assertEqual(ipaddress.IPv4Network, type(ipv4net))
812 self.assertEqual(ipaddress.IPv4Address, type(ipv4addr))
813 self.assertEqual(ipaddress.IPv6Network, type(ipv6net))
814 self.assertEqual(ipaddress.IPv6Address, type(ipv6addr))
815
816 def testReservedIpv4(self):
817 # test networks
818 self.assertEqual(True, ipaddress.ip_interface(
819 '224.1.1.1/31').is_multicast)
820 self.assertEqual(False, ipaddress.ip_network('240.0.0.0').is_multicast)
821
822 self.assertEqual(True, ipaddress.ip_interface(
823 '192.168.1.1/17').is_private)
824 self.assertEqual(False, ipaddress.ip_network('192.169.0.0').is_private)
825 self.assertEqual(True, ipaddress.ip_network(
826 '10.255.255.255').is_private)
827 self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_private)
828 self.assertEqual(True, ipaddress.ip_network(
829 '172.31.255.255').is_private)
830 self.assertEqual(False, ipaddress.ip_network('172.32.0.0').is_private)
831
832 self.assertEqual(True,
833 ipaddress.ip_interface(
834 '169.254.100.200/24').is_link_local)
835 self.assertEqual(False,
836 ipaddress.ip_interface(
837 '169.255.100.200/24').is_link_local)
838
839 self.assertEqual(True,
840 ipaddress.ip_network(
841 '127.100.200.254/32').is_loopback)
842 self.assertEqual(True, ipaddress.ip_network(
843 '127.42.0.0/16').is_loopback)
844 self.assertEqual(False, ipaddress.ip_network('128.0.0.0').is_loopback)
845
846 # test addresses
847 self.assertEqual(True, ipaddress.ip_address('224.1.1.1').is_multicast)
848 self.assertEqual(False, ipaddress.ip_address('240.0.0.0').is_multicast)
849
850 self.assertEqual(True, ipaddress.ip_address('192.168.1.1').is_private)
851 self.assertEqual(False, ipaddress.ip_address('192.169.0.0').is_private)
852 self.assertEqual(True, ipaddress.ip_address(
853 '10.255.255.255').is_private)
854 self.assertEqual(False, ipaddress.ip_address('11.0.0.0').is_private)
855 self.assertEqual(True, ipaddress.ip_address(
856 '172.31.255.255').is_private)
857 self.assertEqual(False, ipaddress.ip_address('172.32.0.0').is_private)
858
859 self.assertEqual(True,
860 ipaddress.ip_address('169.254.100.200').is_link_local)
861 self.assertEqual(False,
862 ipaddress.ip_address('169.255.100.200').is_link_local)
863
864 self.assertEqual(True,
865 ipaddress.ip_address('127.100.200.254').is_loopback)
866 self.assertEqual(True, ipaddress.ip_address('127.42.0.0').is_loopback)
867 self.assertEqual(False, ipaddress.ip_address('128.0.0.0').is_loopback)
868 self.assertEqual(True, ipaddress.ip_network('0.0.0.0').is_unspecified)
869
870 def testReservedIpv6(self):
871
872 self.assertEqual(True, ipaddress.ip_network('ffff::').is_multicast)
873 self.assertEqual(True, ipaddress.ip_network(2**128-1).is_multicast)
874 self.assertEqual(True, ipaddress.ip_network('ff00::').is_multicast)
875 self.assertEqual(False, ipaddress.ip_network('fdff::').is_multicast)
876
877 self.assertEqual(True, ipaddress.ip_network('fecf::').is_site_local)
878 self.assertEqual(True, ipaddress.ip_network(
879 'feff:ffff:ffff:ffff::').is_site_local)
880 self.assertEqual(False, ipaddress.ip_network(
881 'fbf:ffff::').is_site_local)
882 self.assertEqual(False, ipaddress.ip_network('ff00::').is_site_local)
883
884 self.assertEqual(True, ipaddress.ip_network('fc00::').is_private)
885 self.assertEqual(True, ipaddress.ip_network(
886 'fc00:ffff:ffff:ffff::').is_private)
887 self.assertEqual(False, ipaddress.ip_network('fbff:ffff::').is_private)
888 self.assertEqual(False, ipaddress.ip_network('fe00::').is_private)
889
890 self.assertEqual(True, ipaddress.ip_network('fea0::').is_link_local)
891 self.assertEqual(True, ipaddress.ip_network(
892 'febf:ffff::').is_link_local)
893 self.assertEqual(False, ipaddress.ip_network(
894 'fe7f:ffff::').is_link_local)
895 self.assertEqual(False, ipaddress.ip_network('fec0::').is_link_local)
896
897 self.assertEqual(True, ipaddress.ip_interface('0:0::0:01').is_loopback)
898 self.assertEqual(False, ipaddress.ip_interface('::1/127').is_loopback)
899 self.assertEqual(False, ipaddress.ip_network('::').is_loopback)
900 self.assertEqual(False, ipaddress.ip_network('::2').is_loopback)
901
902 self.assertEqual(True, ipaddress.ip_network('0::0').is_unspecified)
903 self.assertEqual(False, ipaddress.ip_network('::1').is_unspecified)
904 self.assertEqual(False, ipaddress.ip_network('::/127').is_unspecified)
905
906 # test addresses
907 self.assertEqual(True, ipaddress.ip_address('ffff::').is_multicast)
908 self.assertEqual(True, ipaddress.ip_address(2**128-1).is_multicast)
909 self.assertEqual(True, ipaddress.ip_address('ff00::').is_multicast)
910 self.assertEqual(False, ipaddress.ip_address('fdff::').is_multicast)
911
912 self.assertEqual(True, ipaddress.ip_address('fecf::').is_site_local)
913 self.assertEqual(True, ipaddress.ip_address(
914 'feff:ffff:ffff:ffff::').is_site_local)
915 self.assertEqual(False, ipaddress.ip_address(
916 'fbf:ffff::').is_site_local)
917 self.assertEqual(False, ipaddress.ip_address('ff00::').is_site_local)
918
919 self.assertEqual(True, ipaddress.ip_address('fc00::').is_private)
920 self.assertEqual(True, ipaddress.ip_address(
921 'fc00:ffff:ffff:ffff::').is_private)
922 self.assertEqual(False, ipaddress.ip_address('fbff:ffff::').is_private)
923 self.assertEqual(False, ipaddress.ip_address('fe00::').is_private)
924
925 self.assertEqual(True, ipaddress.ip_address('fea0::').is_link_local)
926 self.assertEqual(True, ipaddress.ip_address(
927 'febf:ffff::').is_link_local)
928 self.assertEqual(False, ipaddress.ip_address(
929 'fe7f:ffff::').is_link_local)
930 self.assertEqual(False, ipaddress.ip_address('fec0::').is_link_local)
931
932 self.assertEqual(True, ipaddress.ip_address('0:0::0:01').is_loopback)
933 self.assertEqual(True, ipaddress.ip_address('::1').is_loopback)
934 self.assertEqual(False, ipaddress.ip_address('::2').is_loopback)
935
936 self.assertEqual(True, ipaddress.ip_address('0::0').is_unspecified)
937 self.assertEqual(False, ipaddress.ip_address('::1').is_unspecified)
938
939 # some generic IETF reserved addresses
940 self.assertEqual(True, ipaddress.ip_address('100::').is_reserved)
941 self.assertEqual(True, ipaddress.ip_network('4000::1/128').is_reserved)
942
943 def testIpv4Mapped(self):
944 self.assertEqual(ipaddress.ip_address('::ffff:192.168.1.1').ipv4_mapped,
945 ipaddress.ip_address('192.168.1.1'))
946 self.assertEqual(ipaddress.ip_address('::c0a8:101').ipv4_mapped, None)
947 self.assertEqual(ipaddress.ip_address('::ffff:c0a8:101').ipv4_mapped,
948 ipaddress.ip_address('192.168.1.1'))
949
950 def testAddrExclude(self):
951 addr1 = ipaddress.ip_network('10.1.1.0/24')
952 addr2 = ipaddress.ip_network('10.1.1.0/26')
953 addr3 = ipaddress.ip_network('10.2.1.0/24')
954 addr4 = ipaddress.ip_address('10.1.1.0')
955 self.assertEqual(sorted(list(addr1.address_exclude(addr2))),
956 [ipaddress.ip_network('10.1.1.64/26'),
957 ipaddress.ip_network('10.1.1.128/25')])
958 self.assertRaises(ValueError, list, addr1.address_exclude(addr3))
959 self.assertRaises(TypeError, list, addr1.address_exclude(addr4))
960 self.assertEqual(list(addr1.address_exclude(addr1)), [])
961
962 def testHash(self):
963 self.assertEqual(hash(ipaddress.ip_network('10.1.1.0/24')),
964 hash(ipaddress.ip_network('10.1.1.0/24')))
965 self.assertEqual(hash(ipaddress.ip_address('10.1.1.0')),
966 hash(ipaddress.ip_address('10.1.1.0')))
967 # i70
968 self.assertEqual(hash(ipaddress.ip_address('1.2.3.4')),
969 hash(ipaddress.ip_address(
970 int(ipaddress.ip_address('1.2.3.4')._ip))))
971 ip1 = ipaddress.ip_address('10.1.1.0')
972 ip2 = ipaddress.ip_address('1::')
973 dummy = {}
974 dummy[self.ipv4_address] = None
975 dummy[self.ipv6_address] = None
976 dummy[ip1] = None
977 dummy[ip2] = None
978 self.assertTrue(self.ipv4_address in dummy)
979 self.assertTrue(ip2 in dummy)
980
981 def testCopyConstructor(self):
982 addr1 = ipaddress.ip_network('10.1.1.0/24')
983 addr2 = ipaddress.ip_network(addr1)
984 addr3 = ipaddress.ip_interface('2001:658:22a:cafe:200::1/64')
985 addr4 = ipaddress.ip_interface(addr3)
986 addr5 = ipaddress.IPv4Address('1.1.1.1')
987 addr6 = ipaddress.IPv6Address('2001:658:22a:cafe:200::1')
988
989 self.assertEqual(addr1, addr2)
990 self.assertEqual(addr3, addr4)
991 self.assertEqual(addr5, ipaddress.IPv4Address(addr5))
992 self.assertEqual(addr6, ipaddress.IPv6Address(addr6))
993
994 def testCompressIPv6Address(self):
995 test_addresses = {
996 '1:2:3:4:5:6:7:8': '1:2:3:4:5:6:7:8/128',
997 '2001:0:0:4:0:0:0:8': '2001:0:0:4::8/128',
998 '2001:0:0:4:5:6:7:8': '2001::4:5:6:7:8/128',
999 '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128',
1000 '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128',
1001 '0:0:3:0:0:0:0:ffff': '0:0:3::ffff/128',
1002 '0:0:0:4:0:0:0:ffff': '::4:0:0:0:ffff/128',
1003 '0:0:0:0:5:0:0:ffff': '::5:0:0:ffff/128',
1004 '1:0:0:4:0:0:7:8': '1::4:0:0:7:8/128',
1005 '0:0:0:0:0:0:0:0': '::/128',
1006 '0:0:0:0:0:0:0:0/0': '::/0',
1007 '0:0:0:0:0:0:0:1': '::1/128',
1008 '2001:0658:022a:cafe:0000:0000:0000:0000/66':
1009 '2001:658:22a:cafe::/66',
1010 '::1.2.3.4': '::102:304/128',
1011 '1:2:3:4:5:ffff:1.2.3.4': '1:2:3:4:5:ffff:102:304/128',
1012 '::7:6:5:4:3:2:1': '0:7:6:5:4:3:2:1/128',
1013 '::7:6:5:4:3:2:0': '0:7:6:5:4:3:2:0/128',
1014 '7:6:5:4:3:2:1::': '7:6:5:4:3:2:1:0/128',
1015 '0:6:5:4:3:2:1::': '0:6:5:4:3:2:1:0/128',
1016 }
1017 for uncompressed, compressed in list(test_addresses.items()):
1018 self.assertEqual(compressed, str(ipaddress.IPv6Interface(
1019 uncompressed)))
1020
1021 def testExplodeShortHandIpStr(self):
1022 addr1 = ipaddress.IPv6Interface('2001::1')
1023 addr2 = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
1024 addr3 = ipaddress.IPv6Network('2001::/96')
1025 self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0001/128',
1026 addr1.exploded)
1027 self.assertEqual('0000:0000:0000:0000:0000:0000:0000:0001/128',
1028 ipaddress.IPv6Interface('::1/128').exploded)
1029 # issue 77
1030 self.assertEqual('2001:0000:5ef5:79fd:0000:059d:a0e5:0ba1',
1031 addr2.exploded)
1032 self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0000/96',
1033 addr3.exploded)
1034
1035 def testIntRepresentation(self):
1036 self.assertEqual(16909060, int(self.ipv4_address))
1037 self.assertEqual(42540616829182469433547762482097946625,
1038 int(self.ipv6_address))
1039
1040 def testHexRepresentation(self):
1041 self.assertEqual(hex(0x1020304),
1042 hex(self.ipv4_address))
1043
1044 self.assertEqual(hex(0x20010658022ACAFE0200000000000001),
1045 hex(self.ipv6_address))
1046
1047 def testForceVersion(self):
1048 self.assertEqual(ipaddress.ip_network(1).version, 4)
1049 self.assertEqual(ipaddress.ip_network(1, version=6).version, 6)
1050
1051 def testWithStar(self):
1052 self.assertEqual(str(self.ipv4_interface.with_prefixlen), "1.2.3.4/24")
1053 self.assertEqual(str(self.ipv4_interface.with_netmask),
1054 "1.2.3.4/255.255.255.0")
1055 self.assertEqual(str(self.ipv4_interface.with_hostmask),
1056 "1.2.3.4/0.0.0.255")
1057
1058 self.assertEqual(str(self.ipv6_interface.with_prefixlen),
1059 '2001:658:22a:cafe:200::1/64')
1060 # rfc3513 sec 2.3 says that ipv6 only uses cidr notation for
1061 # subnets
1062 self.assertEqual(str(self.ipv6_interface.with_netmask),
1063 '2001:658:22a:cafe:200::1/64')
1064 # this probably don't make much sense, but it's included for
1065 # compatibility with ipv4
1066 self.assertEqual(str(self.ipv6_interface.with_hostmask),
1067 '2001:658:22a:cafe:200::1/::ffff:ffff:ffff:ffff')
1068
1069 def testNetworkElementCaching(self):
1070 # V4 - make sure we're empty
1071 self.assertFalse('network_address' in self.ipv4_network._cache)
1072 self.assertFalse('broadcast_address' in self.ipv4_network._cache)
1073 self.assertFalse('hostmask' in self.ipv4_network._cache)
1074
1075 # V4 - populate and test
1076 self.assertEqual(self.ipv4_network.network_address,
1077 ipaddress.IPv4Address('1.2.3.0'))
1078 self.assertEqual(self.ipv4_network.broadcast_address,
1079 ipaddress.IPv4Address('1.2.3.255'))
1080 self.assertEqual(self.ipv4_network.hostmask,
1081 ipaddress.IPv4Address('0.0.0.255'))
1082
1083 # V4 - check we're cached
1084 self.assertTrue('broadcast_address' in self.ipv4_network._cache)
1085 self.assertTrue('hostmask' in self.ipv4_network._cache)
1086
1087 # V6 - make sure we're empty
1088 self.assertFalse('broadcast_address' in self.ipv6_network._cache)
1089 self.assertFalse('hostmask' in self.ipv6_network._cache)
1090
1091 # V6 - populate and test
1092 self.assertEqual(self.ipv6_network.network_address,
1093 ipaddress.IPv6Address('2001:658:22a:cafe::'))
1094 self.assertEqual(self.ipv6_interface.network.network_address,
1095 ipaddress.IPv6Address('2001:658:22a:cafe::'))
1096
1097 self.assertEqual(
1098 self.ipv6_network.broadcast_address,
1099 ipaddress.IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff'))
1100 self.assertEqual(self.ipv6_network.hostmask,
1101 ipaddress.IPv6Address('::ffff:ffff:ffff:ffff'))
1102 self.assertEqual(
1103 self.ipv6_interface.network.broadcast_address,
1104 ipaddress.IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff'))
1105 self.assertEqual(self.ipv6_interface.network.hostmask,
1106 ipaddress.IPv6Address('::ffff:ffff:ffff:ffff'))
1107
1108 # V6 - check we're cached
1109 self.assertTrue('broadcast_address' in self.ipv6_network._cache)
1110 self.assertTrue('hostmask' in self.ipv6_network._cache)
1111 self.assertTrue('broadcast_address' in self.ipv6_interface.network._cache)
1112 self.assertTrue('hostmask' in self.ipv6_interface.network._cache)
1113
1114 def testTeredo(self):
1115 # stolen from wikipedia
1116 server = ipaddress.IPv4Address('65.54.227.120')
1117 client = ipaddress.IPv4Address('192.0.2.45')
1118 teredo_addr = '2001:0000:4136:e378:8000:63bf:3fff:fdd2'
1119 self.assertEqual((server, client),
1120 ipaddress.ip_address(teredo_addr).teredo)
1121 bad_addr = '2000::4136:e378:8000:63bf:3fff:fdd2'
1122 self.assertFalse(ipaddress.ip_address(bad_addr).teredo)
1123 bad_addr = '2001:0001:4136:e378:8000:63bf:3fff:fdd2'
1124 self.assertFalse(ipaddress.ip_address(bad_addr).teredo)
1125
1126 # i77
1127 teredo_addr = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
1128 self.assertEqual((ipaddress.IPv4Address('94.245.121.253'),
1129 ipaddress.IPv4Address('95.26.244.94')),
1130 teredo_addr.teredo)
1131
1132
1133 def testsixtofour(self):
1134 sixtofouraddr = ipaddress.ip_address('2002:ac1d:2d64::1')
1135 bad_addr = ipaddress.ip_address('2000:ac1d:2d64::1')
1136 self.assertEqual(ipaddress.IPv4Address('172.29.45.100'),
1137 sixtofouraddr.sixtofour)
1138 self.assertFalse(bad_addr.sixtofour)
1139
1140
1141if __name__ == '__main__':
1142 unittest.main()