Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython2 / efce00c537ff611ee6d2521e36de3c92b1c10f5b / . / Lib / test / test_ipaddress.py
blob: 5b7d013442691157aad59c57d72db1f8b7da4696 [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,
Nick Coghlan2c589102012-05-27 01:03:25 +1000[diff] [blame]393 self.ipv4_network.subnets(-1))
Nick Coghlandc9b2552012-05-20 21:01:57 +1000[diff] [blame]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
Hynek Schlawack35db5132012-06-01 20:12:17 +0200[diff] [blame]599 addr_tuples = [
600 (ipaddress.ip_address('1.1.1.1'),
601 ipaddress.ip_address('::1')),
602 (ipaddress.IPv4Network('1.1.0.0/24'),
603 ipaddress.IPv6Network('2001::/120')),
604 (ipaddress.IPv4Network('1.1.0.0/32'),
605 ipaddress.IPv6Network('2001::/128')),
606 ]
607 for ip1, ip2 in addr_tuples:
608 self.assertRaises(TypeError, ipaddress.collapse_addresses,
609 [ip1, ip2])
Nick Coghlandc9b2552012-05-20 21:01:57 +1000[diff] [blame]610
611 def testSummarizing(self):
612 #ip = ipaddress.ip_address
613 #ipnet = ipaddress.ip_network
614 summarize = ipaddress.summarize_address_range
615 ip1 = ipaddress.ip_address('1.1.1.0')
616 ip2 = ipaddress.ip_address('1.1.1.255')
617 # test a /24 is sumamrized properly
618 self.assertEqual(list(summarize(ip1, ip2))[0],
619 ipaddress.ip_network('1.1.1.0/24'))
620 # test an IPv4 range that isn't on a network byte boundary
621 ip2 = ipaddress.ip_address('1.1.1.8')
622 self.assertEqual(list(summarize(ip1, ip2)),
623 [ipaddress.ip_network('1.1.1.0/29'),
624 ipaddress.ip_network('1.1.1.8')])
625
626 ip1 = ipaddress.ip_address('1::')
627 ip2 = ipaddress.ip_address('1:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
628 # test a IPv6 is sumamrized properly
629 self.assertEqual(list(summarize(ip1, ip2))[0],
630 ipaddress.ip_network('1::/16'))
631 # test an IPv6 range that isn't on a network byte boundary
632 ip2 = ipaddress.ip_address('2::')
633 self.assertEqual(list(summarize(ip1, ip2)),
634 [ipaddress.ip_network('1::/16'),
635 ipaddress.ip_network('2::/128')])
636
637 # test exception raised when first is greater than last
638 self.assertRaises(ValueError, list,
639 summarize(ipaddress.ip_address('1.1.1.0'),
640 ipaddress.ip_address('1.1.0.0')))
641 # test exception raised when first and last aren't IP addresses
642 self.assertRaises(TypeError, list,
643 summarize(ipaddress.ip_network('1.1.1.0'),
644 ipaddress.ip_network('1.1.0.0')))
645 self.assertRaises(TypeError, list,
646 summarize(ipaddress.ip_network('1.1.1.0'),
647 ipaddress.ip_network('1.1.0.0')))
648 # test exception raised when first and last are not same version
649 self.assertRaises(TypeError, list,
650 summarize(ipaddress.ip_address('::'),
651 ipaddress.ip_network('1.1.0.0')))
652
653 def testAddressComparison(self):
654 self.assertTrue(ipaddress.ip_address('1.1.1.1') <=
655 ipaddress.ip_address('1.1.1.1'))
656 self.assertTrue(ipaddress.ip_address('1.1.1.1') <=
657 ipaddress.ip_address('1.1.1.2'))
658 self.assertTrue(ipaddress.ip_address('::1') <=
659 ipaddress.ip_address('::1'))
660 self.assertTrue(ipaddress.ip_address('::1') <=
661 ipaddress.ip_address('::2'))
662
663 def testNetworkComparison(self):
664 # ip1 and ip2 have the same network address
665 ip1 = ipaddress.IPv4Network('1.1.1.0/24')
666 ip2 = ipaddress.IPv4Network('1.1.1.1/32')
667 ip3 = ipaddress.IPv4Network('1.1.2.0/24')
668
669 self.assertTrue(ip1 < ip3)
670 self.assertTrue(ip3 > ip2)
671
672 #self.assertEqual(ip1.compare_networks(ip2), 0)
673 #self.assertTrue(ip1._get_networks_key() == ip2._get_networks_key())
674 self.assertEqual(ip1.compare_networks(ip3), -1)
675 self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
676
677 ip1 = ipaddress.IPv6Network('2001:2000::/96')
678 ip2 = ipaddress.IPv6Network('2001:2001::/96')
679 ip3 = ipaddress.IPv6Network('2001:ffff:2000::/96')
680
681 self.assertTrue(ip1 < ip3)
682 self.assertTrue(ip3 > ip2)
683 self.assertEqual(ip1.compare_networks(ip3), -1)
684 self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
685
686 # Test comparing different protocols.
687 # Should always raise a TypeError.
688 ipv6 = ipaddress.IPv6Interface('::/0')
689 ipv4 = ipaddress.IPv4Interface('0.0.0.0/0')
690 self.assertRaises(TypeError, ipv4.__lt__, ipv6)
691 self.assertRaises(TypeError, ipv4.__gt__, ipv6)
692 self.assertRaises(TypeError, ipv6.__lt__, ipv4)
693 self.assertRaises(TypeError, ipv6.__gt__, ipv4)
694
695 # Regression test for issue 19.
696 ip1 = ipaddress.ip_network('10.1.2.128/25')
697 self.assertFalse(ip1 < ip1)
698 self.assertFalse(ip1 > ip1)
699 ip2 = ipaddress.ip_network('10.1.3.0/24')
700 self.assertTrue(ip1 < ip2)
701 self.assertFalse(ip2 < ip1)
702 self.assertFalse(ip1 > ip2)
703 self.assertTrue(ip2 > ip1)
704 ip3 = ipaddress.ip_network('10.1.3.0/25')
705 self.assertTrue(ip2 < ip3)
706 self.assertFalse(ip3 < ip2)
707 self.assertFalse(ip2 > ip3)
708 self.assertTrue(ip3 > ip2)
709
710 # Regression test for issue 28.
711 ip1 = ipaddress.ip_network('10.10.10.0/31')
712 ip2 = ipaddress.ip_network('10.10.10.0')
713 ip3 = ipaddress.ip_network('10.10.10.2/31')
714 ip4 = ipaddress.ip_network('10.10.10.2')
715 sorted = [ip1, ip2, ip3, ip4]
716 unsorted = [ip2, ip4, ip1, ip3]
717 unsorted.sort()
718 self.assertEqual(sorted, unsorted)
719 unsorted = [ip4, ip1, ip3, ip2]
720 unsorted.sort()
721 self.assertEqual(sorted, unsorted)
722 self.assertRaises(TypeError, ip1.__lt__,
723 ipaddress.ip_address('10.10.10.0'))
724 self.assertRaises(TypeError, ip2.__lt__,
725 ipaddress.ip_address('10.10.10.0'))
726
727 # <=, >=
728 self.assertTrue(ipaddress.ip_network('1.1.1.1') <=
729 ipaddress.ip_network('1.1.1.1'))
730 self.assertTrue(ipaddress.ip_network('1.1.1.1') <=
731 ipaddress.ip_network('1.1.1.2'))
732 self.assertFalse(ipaddress.ip_network('1.1.1.2') <=
733 ipaddress.ip_network('1.1.1.1'))
734 self.assertTrue(ipaddress.ip_network('::1') <=
735 ipaddress.ip_network('::1'))
736 self.assertTrue(ipaddress.ip_network('::1') <=
737 ipaddress.ip_network('::2'))
738 self.assertFalse(ipaddress.ip_network('::2') <=
739 ipaddress.ip_network('::1'))
740
741 def testStrictNetworks(self):
742 self.assertRaises(ValueError, ipaddress.ip_network, '192.168.1.1/24')
743 self.assertRaises(ValueError, ipaddress.ip_network, '::1/120')
744
745 def testOverlaps(self):
746 other = ipaddress.IPv4Network('1.2.3.0/30')
747 other2 = ipaddress.IPv4Network('1.2.2.0/24')
748 other3 = ipaddress.IPv4Network('1.2.2.64/26')
749 self.assertTrue(self.ipv4_network.overlaps(other))
750 self.assertFalse(self.ipv4_network.overlaps(other2))
751 self.assertTrue(other2.overlaps(other3))
752
753 def testEmbeddedIpv4(self):
754 ipv4_string = '192.168.0.1'
755 ipv4 = ipaddress.IPv4Interface(ipv4_string)
756 v4compat_ipv6 = ipaddress.IPv6Interface('::%s' % ipv4_string)
757 self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
758 v4mapped_ipv6 = ipaddress.IPv6Interface('::ffff:%s' % ipv4_string)
759 self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
760 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
761 '2001:1.1.1.1:1.1.1.1')
762
763 # Issue 67: IPv6 with embedded IPv4 address not recognized.
764 def testIPv6AddressTooLarge(self):
765 # RFC4291 2.5.5.2
766 self.assertEqual(ipaddress.ip_address('::FFFF:192.0.2.1'),
767 ipaddress.ip_address('::FFFF:c000:201'))
768 # RFC4291 2.2 (part 3) x::d.d.d.d
769 self.assertEqual(ipaddress.ip_address('FFFF::192.0.2.1'),
770 ipaddress.ip_address('FFFF::c000:201'))
771
772 def testIPVersion(self):
773 self.assertEqual(self.ipv4_address.version, 4)
774 self.assertEqual(self.ipv6_address.version, 6)
775
776 def testMaxPrefixLength(self):
777 self.assertEqual(self.ipv4_interface.max_prefixlen, 32)
778 self.assertEqual(self.ipv6_interface.max_prefixlen, 128)
779
780 def testPacked(self):
781 self.assertEqual(self.ipv4_address.packed,
782 _cb('\x01\x02\x03\x04'))
783 self.assertEqual(ipaddress.IPv4Interface('255.254.253.252').packed,
784 _cb('\xff\xfe\xfd\xfc'))
785 self.assertEqual(self.ipv6_address.packed,
786 _cb('\x20\x01\x06\x58\x02\x2a\xca\xfe'
787 '\x02\x00\x00\x00\x00\x00\x00\x01'))
788 self.assertEqual(ipaddress.IPv6Interface('ffff:2:3:4:ffff::').packed,
789 _cb('\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff'
790 + '\x00' * 6))
791 self.assertEqual(ipaddress.IPv6Interface('::1:0:0:0:0').packed,
792 _cb('\x00' * 6 + '\x00\x01' + '\x00' * 8))
793
794 def testIpStrFromPrefixlen(self):
795 ipv4 = ipaddress.IPv4Interface('1.2.3.4/24')
796 self.assertEqual(ipv4._ip_string_from_prefix(), '255.255.255.0')
797 self.assertEqual(ipv4._ip_string_from_prefix(28), '255.255.255.240')
798
799 def testIpType(self):
800 ipv4net = ipaddress.ip_network('1.2.3.4')
801 ipv4addr = ipaddress.ip_address('1.2.3.4')
802 ipv6net = ipaddress.ip_network('::1.2.3.4')
803 ipv6addr = ipaddress.ip_address('::1.2.3.4')
804 self.assertEqual(ipaddress.IPv4Network, type(ipv4net))
805 self.assertEqual(ipaddress.IPv4Address, type(ipv4addr))
806 self.assertEqual(ipaddress.IPv6Network, type(ipv6net))
807 self.assertEqual(ipaddress.IPv6Address, type(ipv6addr))
808
809 def testReservedIpv4(self):
810 # test networks
811 self.assertEqual(True, ipaddress.ip_interface(
812 '224.1.1.1/31').is_multicast)
813 self.assertEqual(False, ipaddress.ip_network('240.0.0.0').is_multicast)
814
815 self.assertEqual(True, ipaddress.ip_interface(
816 '192.168.1.1/17').is_private)
817 self.assertEqual(False, ipaddress.ip_network('192.169.0.0').is_private)
818 self.assertEqual(True, ipaddress.ip_network(
819 '10.255.255.255').is_private)
820 self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_private)
821 self.assertEqual(True, ipaddress.ip_network(
822 '172.31.255.255').is_private)
823 self.assertEqual(False, ipaddress.ip_network('172.32.0.0').is_private)
824
825 self.assertEqual(True,
826 ipaddress.ip_interface(
827 '169.254.100.200/24').is_link_local)
828 self.assertEqual(False,
829 ipaddress.ip_interface(
830 '169.255.100.200/24').is_link_local)
831
832 self.assertEqual(True,
833 ipaddress.ip_network(
834 '127.100.200.254/32').is_loopback)
835 self.assertEqual(True, ipaddress.ip_network(
836 '127.42.0.0/16').is_loopback)
837 self.assertEqual(False, ipaddress.ip_network('128.0.0.0').is_loopback)
838
839 # test addresses
Hynek Schlawackbcd30442012-06-04 14:19:39 +0200[diff] [blame]840 self.assertEqual(True, ipaddress.ip_address('0.0.0.0').is_unspecified)
Nick Coghlandc9b2552012-05-20 21:01:57 +1000[diff] [blame]841 self.assertEqual(True, ipaddress.ip_address('224.1.1.1').is_multicast)
842 self.assertEqual(False, ipaddress.ip_address('240.0.0.0').is_multicast)
843
844 self.assertEqual(True, ipaddress.ip_address('192.168.1.1').is_private)
845 self.assertEqual(False, ipaddress.ip_address('192.169.0.0').is_private)
846 self.assertEqual(True, ipaddress.ip_address(
847 '10.255.255.255').is_private)
848 self.assertEqual(False, ipaddress.ip_address('11.0.0.0').is_private)
849 self.assertEqual(True, ipaddress.ip_address(
850 '172.31.255.255').is_private)
851 self.assertEqual(False, ipaddress.ip_address('172.32.0.0').is_private)
852
853 self.assertEqual(True,
854 ipaddress.ip_address('169.254.100.200').is_link_local)
855 self.assertEqual(False,
856 ipaddress.ip_address('169.255.100.200').is_link_local)
857
858 self.assertEqual(True,
859 ipaddress.ip_address('127.100.200.254').is_loopback)
860 self.assertEqual(True, ipaddress.ip_address('127.42.0.0').is_loopback)
861 self.assertEqual(False, ipaddress.ip_address('128.0.0.0').is_loopback)
862 self.assertEqual(True, ipaddress.ip_network('0.0.0.0').is_unspecified)
863
864 def testReservedIpv6(self):
865
866 self.assertEqual(True, ipaddress.ip_network('ffff::').is_multicast)
867 self.assertEqual(True, ipaddress.ip_network(2**128-1).is_multicast)
868 self.assertEqual(True, ipaddress.ip_network('ff00::').is_multicast)
869 self.assertEqual(False, ipaddress.ip_network('fdff::').is_multicast)
870
871 self.assertEqual(True, ipaddress.ip_network('fecf::').is_site_local)
872 self.assertEqual(True, ipaddress.ip_network(
873 'feff:ffff:ffff:ffff::').is_site_local)
874 self.assertEqual(False, ipaddress.ip_network(
875 'fbf:ffff::').is_site_local)
876 self.assertEqual(False, ipaddress.ip_network('ff00::').is_site_local)
877
878 self.assertEqual(True, ipaddress.ip_network('fc00::').is_private)
879 self.assertEqual(True, ipaddress.ip_network(
880 'fc00:ffff:ffff:ffff::').is_private)
881 self.assertEqual(False, ipaddress.ip_network('fbff:ffff::').is_private)
882 self.assertEqual(False, ipaddress.ip_network('fe00::').is_private)
883
884 self.assertEqual(True, ipaddress.ip_network('fea0::').is_link_local)
885 self.assertEqual(True, ipaddress.ip_network(
886 'febf:ffff::').is_link_local)
887 self.assertEqual(False, ipaddress.ip_network(
888 'fe7f:ffff::').is_link_local)
889 self.assertEqual(False, ipaddress.ip_network('fec0::').is_link_local)
890
891 self.assertEqual(True, ipaddress.ip_interface('0:0::0:01').is_loopback)
892 self.assertEqual(False, ipaddress.ip_interface('::1/127').is_loopback)
893 self.assertEqual(False, ipaddress.ip_network('::').is_loopback)
894 self.assertEqual(False, ipaddress.ip_network('::2').is_loopback)
895
896 self.assertEqual(True, ipaddress.ip_network('0::0').is_unspecified)
897 self.assertEqual(False, ipaddress.ip_network('::1').is_unspecified)
898 self.assertEqual(False, ipaddress.ip_network('::/127').is_unspecified)
899
900 # test addresses
901 self.assertEqual(True, ipaddress.ip_address('ffff::').is_multicast)
902 self.assertEqual(True, ipaddress.ip_address(2**128-1).is_multicast)
903 self.assertEqual(True, ipaddress.ip_address('ff00::').is_multicast)
904 self.assertEqual(False, ipaddress.ip_address('fdff::').is_multicast)
905
906 self.assertEqual(True, ipaddress.ip_address('fecf::').is_site_local)
907 self.assertEqual(True, ipaddress.ip_address(
908 'feff:ffff:ffff:ffff::').is_site_local)
909 self.assertEqual(False, ipaddress.ip_address(
910 'fbf:ffff::').is_site_local)
911 self.assertEqual(False, ipaddress.ip_address('ff00::').is_site_local)
912
913 self.assertEqual(True, ipaddress.ip_address('fc00::').is_private)
914 self.assertEqual(True, ipaddress.ip_address(
915 'fc00:ffff:ffff:ffff::').is_private)
916 self.assertEqual(False, ipaddress.ip_address('fbff:ffff::').is_private)
917 self.assertEqual(False, ipaddress.ip_address('fe00::').is_private)
918
919 self.assertEqual(True, ipaddress.ip_address('fea0::').is_link_local)
920 self.assertEqual(True, ipaddress.ip_address(
921 'febf:ffff::').is_link_local)
922 self.assertEqual(False, ipaddress.ip_address(
923 'fe7f:ffff::').is_link_local)
924 self.assertEqual(False, ipaddress.ip_address('fec0::').is_link_local)
925
926 self.assertEqual(True, ipaddress.ip_address('0:0::0:01').is_loopback)
927 self.assertEqual(True, ipaddress.ip_address('::1').is_loopback)
928 self.assertEqual(False, ipaddress.ip_address('::2').is_loopback)
929
930 self.assertEqual(True, ipaddress.ip_address('0::0').is_unspecified)
931 self.assertEqual(False, ipaddress.ip_address('::1').is_unspecified)
932
933 # some generic IETF reserved addresses
934 self.assertEqual(True, ipaddress.ip_address('100::').is_reserved)
935 self.assertEqual(True, ipaddress.ip_network('4000::1/128').is_reserved)
936
937 def testIpv4Mapped(self):
938 self.assertEqual(ipaddress.ip_address('::ffff:192.168.1.1').ipv4_mapped,
939 ipaddress.ip_address('192.168.1.1'))
940 self.assertEqual(ipaddress.ip_address('::c0a8:101').ipv4_mapped, None)
941 self.assertEqual(ipaddress.ip_address('::ffff:c0a8:101').ipv4_mapped,
942 ipaddress.ip_address('192.168.1.1'))
943
944 def testAddrExclude(self):
945 addr1 = ipaddress.ip_network('10.1.1.0/24')
946 addr2 = ipaddress.ip_network('10.1.1.0/26')
947 addr3 = ipaddress.ip_network('10.2.1.0/24')
948 addr4 = ipaddress.ip_address('10.1.1.0')
949 self.assertEqual(sorted(list(addr1.address_exclude(addr2))),
950 [ipaddress.ip_network('10.1.1.64/26'),
951 ipaddress.ip_network('10.1.1.128/25')])
952 self.assertRaises(ValueError, list, addr1.address_exclude(addr3))
953 self.assertRaises(TypeError, list, addr1.address_exclude(addr4))
954 self.assertEqual(list(addr1.address_exclude(addr1)), [])
955
956 def testHash(self):
957 self.assertEqual(hash(ipaddress.ip_network('10.1.1.0/24')),
958 hash(ipaddress.ip_network('10.1.1.0/24')))
959 self.assertEqual(hash(ipaddress.ip_address('10.1.1.0')),
960 hash(ipaddress.ip_address('10.1.1.0')))
961 # i70
962 self.assertEqual(hash(ipaddress.ip_address('1.2.3.4')),
963 hash(ipaddress.ip_address(
964 int(ipaddress.ip_address('1.2.3.4')._ip))))
965 ip1 = ipaddress.ip_address('10.1.1.0')
966 ip2 = ipaddress.ip_address('1::')
967 dummy = {}
968 dummy[self.ipv4_address] = None
969 dummy[self.ipv6_address] = None
970 dummy[ip1] = None
971 dummy[ip2] = None
972 self.assertTrue(self.ipv4_address in dummy)
973 self.assertTrue(ip2 in dummy)
974
975 def testCopyConstructor(self):
976 addr1 = ipaddress.ip_network('10.1.1.0/24')
977 addr2 = ipaddress.ip_network(addr1)
978 addr3 = ipaddress.ip_interface('2001:658:22a:cafe:200::1/64')
979 addr4 = ipaddress.ip_interface(addr3)
980 addr5 = ipaddress.IPv4Address('1.1.1.1')
981 addr6 = ipaddress.IPv6Address('2001:658:22a:cafe:200::1')
982
983 self.assertEqual(addr1, addr2)
984 self.assertEqual(addr3, addr4)
985 self.assertEqual(addr5, ipaddress.IPv4Address(addr5))
986 self.assertEqual(addr6, ipaddress.IPv6Address(addr6))
987
988 def testCompressIPv6Address(self):
989 test_addresses = {
990 '1:2:3:4:5:6:7:8': '1:2:3:4:5:6:7:8/128',
991 '2001:0:0:4:0:0:0:8': '2001:0:0:4::8/128',
992 '2001:0:0:4:5:6:7:8': '2001::4:5:6:7:8/128',
993 '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128',
994 '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128',
995 '0:0:3:0:0:0:0:ffff': '0:0:3::ffff/128',
996 '0:0:0:4:0:0:0:ffff': '::4:0:0:0:ffff/128',
997 '0:0:0:0:5:0:0:ffff': '::5:0:0:ffff/128',
998 '1:0:0:4:0:0:7:8': '1::4:0:0:7:8/128',
999 '0:0:0:0:0:0:0:0': '::/128',
1000 '0:0:0:0:0:0:0:0/0': '::/0',
1001 '0:0:0:0:0:0:0:1': '::1/128',
1002 '2001:0658:022a:cafe:0000:0000:0000:0000/66':
1003 '2001:658:22a:cafe::/66',
1004 '::1.2.3.4': '::102:304/128',
1005 '1:2:3:4:5:ffff:1.2.3.4': '1:2:3:4:5:ffff:102:304/128',
1006 '::7:6:5:4:3:2:1': '0:7:6:5:4:3:2:1/128',
1007 '::7:6:5:4:3:2:0': '0:7:6:5:4:3:2:0/128',
1008 '7:6:5:4:3:2:1::': '7:6:5:4:3:2:1:0/128',
1009 '0:6:5:4:3:2:1::': '0:6:5:4:3:2:1:0/128',
1010 }
1011 for uncompressed, compressed in list(test_addresses.items()):
1012 self.assertEqual(compressed, str(ipaddress.IPv6Interface(
1013 uncompressed)))
1014
1015 def testExplodeShortHandIpStr(self):
1016 addr1 = ipaddress.IPv6Interface('2001::1')
1017 addr2 = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
1018 addr3 = ipaddress.IPv6Network('2001::/96')
1019 self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0001/128',
1020 addr1.exploded)
1021 self.assertEqual('0000:0000:0000:0000:0000:0000:0000:0001/128',
1022 ipaddress.IPv6Interface('::1/128').exploded)
1023 # issue 77
1024 self.assertEqual('2001:0000:5ef5:79fd:0000:059d:a0e5:0ba1',
1025 addr2.exploded)
1026 self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0000/96',
1027 addr3.exploded)
1028
1029 def testIntRepresentation(self):
1030 self.assertEqual(16909060, int(self.ipv4_address))
1031 self.assertEqual(42540616829182469433547762482097946625,
1032 int(self.ipv6_address))
1033
1034 def testHexRepresentation(self):
1035 self.assertEqual(hex(0x1020304),
1036 hex(self.ipv4_address))
1037
1038 self.assertEqual(hex(0x20010658022ACAFE0200000000000001),
1039 hex(self.ipv6_address))
1040
1041 def testForceVersion(self):
1042 self.assertEqual(ipaddress.ip_network(1).version, 4)
Nick Coghlan51c30672012-05-27 00:25:58 +1000[diff] [blame]1043 self.assertEqual(ipaddress.IPv6Network(1).version, 6)
Sandro Tosi876ecad2012-05-23 22:26:55 +0200[diff] [blame]1044
Nick Coghlandc9b2552012-05-20 21:01:57 +1000[diff] [blame]1045 def testWithStar(self):
1046 self.assertEqual(str(self.ipv4_interface.with_prefixlen), "1.2.3.4/24")
1047 self.assertEqual(str(self.ipv4_interface.with_netmask),
1048 "1.2.3.4/255.255.255.0")
1049 self.assertEqual(str(self.ipv4_interface.with_hostmask),
1050 "1.2.3.4/0.0.0.255")
1051
1052 self.assertEqual(str(self.ipv6_interface.with_prefixlen),
1053 '2001:658:22a:cafe:200::1/64')
1054 # rfc3513 sec 2.3 says that ipv6 only uses cidr notation for
1055 # subnets
1056 self.assertEqual(str(self.ipv6_interface.with_netmask),
1057 '2001:658:22a:cafe:200::1/64')
1058 # this probably don't make much sense, but it's included for
1059 # compatibility with ipv4
1060 self.assertEqual(str(self.ipv6_interface.with_hostmask),
1061 '2001:658:22a:cafe:200::1/::ffff:ffff:ffff:ffff')
1062
1063 def testNetworkElementCaching(self):
1064 # V4 - make sure we're empty
1065 self.assertFalse('network_address' in self.ipv4_network._cache)
1066 self.assertFalse('broadcast_address' in self.ipv4_network._cache)
1067 self.assertFalse('hostmask' in self.ipv4_network._cache)
1068
1069 # V4 - populate and test
1070 self.assertEqual(self.ipv4_network.network_address,
1071 ipaddress.IPv4Address('1.2.3.0'))
1072 self.assertEqual(self.ipv4_network.broadcast_address,
1073 ipaddress.IPv4Address('1.2.3.255'))
1074 self.assertEqual(self.ipv4_network.hostmask,
1075 ipaddress.IPv4Address('0.0.0.255'))
1076
1077 # V4 - check we're cached
1078 self.assertTrue('broadcast_address' in self.ipv4_network._cache)
1079 self.assertTrue('hostmask' in self.ipv4_network._cache)
1080
1081 # V6 - make sure we're empty
1082 self.assertFalse('broadcast_address' in self.ipv6_network._cache)
1083 self.assertFalse('hostmask' in self.ipv6_network._cache)
1084
1085 # V6 - populate and test
1086 self.assertEqual(self.ipv6_network.network_address,
1087 ipaddress.IPv6Address('2001:658:22a:cafe::'))
1088 self.assertEqual(self.ipv6_interface.network.network_address,
1089 ipaddress.IPv6Address('2001:658:22a:cafe::'))
1090
1091 self.assertEqual(
1092 self.ipv6_network.broadcast_address,
1093 ipaddress.IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff'))
1094 self.assertEqual(self.ipv6_network.hostmask,
1095 ipaddress.IPv6Address('::ffff:ffff:ffff:ffff'))
1096 self.assertEqual(
1097 self.ipv6_interface.network.broadcast_address,
1098 ipaddress.IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff'))
1099 self.assertEqual(self.ipv6_interface.network.hostmask,
1100 ipaddress.IPv6Address('::ffff:ffff:ffff:ffff'))
1101
1102 # V6 - check we're cached
1103 self.assertTrue('broadcast_address' in self.ipv6_network._cache)
1104 self.assertTrue('hostmask' in self.ipv6_network._cache)
1105 self.assertTrue('broadcast_address' in self.ipv6_interface.network._cache)
1106 self.assertTrue('hostmask' in self.ipv6_interface.network._cache)
1107
1108 def testTeredo(self):
1109 # stolen from wikipedia
1110 server = ipaddress.IPv4Address('65.54.227.120')
1111 client = ipaddress.IPv4Address('192.0.2.45')
1112 teredo_addr = '2001:0000:4136:e378:8000:63bf:3fff:fdd2'
1113 self.assertEqual((server, client),
1114 ipaddress.ip_address(teredo_addr).teredo)
1115 bad_addr = '2000::4136:e378:8000:63bf:3fff:fdd2'
1116 self.assertFalse(ipaddress.ip_address(bad_addr).teredo)
1117 bad_addr = '2001:0001:4136:e378:8000:63bf:3fff:fdd2'
1118 self.assertFalse(ipaddress.ip_address(bad_addr).teredo)
1119
1120 # i77
1121 teredo_addr = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
1122 self.assertEqual((ipaddress.IPv4Address('94.245.121.253'),
1123 ipaddress.IPv4Address('95.26.244.94')),
1124 teredo_addr.teredo)
1125
1126
1127 def testsixtofour(self):
1128 sixtofouraddr = ipaddress.ip_address('2002:ac1d:2d64::1')
1129 bad_addr = ipaddress.ip_address('2000:ac1d:2d64::1')
1130 self.assertEqual(ipaddress.IPv4Address('172.29.45.100'),
1131 sixtofouraddr.sixtofour)
1132 self.assertFalse(bad_addr.sixtofour)
1133
Nick Coghlandc9b2552012-05-20 21:01:57 +1000[diff] [blame]1134
1135if __name__ == '__main__':
1136 unittest.main()