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