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