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