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