1 /* 2 * Copyright (C) 2008 The Guava Authors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.google.common.net; 18 19 import com.google.common.testing.NullPointerTester; 20 21 import junit.framework.TestCase; 22 23 import java.net.Inet4Address; 24 import java.net.Inet6Address; 25 import java.net.InetAddress; 26 import java.net.UnknownHostException; 27 28 /** 29 * Tests for {@link InetAddresses}. 30 * 31 * @author Erik Kline 32 */ 33 public class InetAddressesTest extends TestCase { 34 35 public void testNulls() { 36 NullPointerTester tester = new NullPointerTester(); 37 38 tester.testAllPublicStaticMethods(InetAddresses.class); 39 } 40 41 public void testForStringBogusInput() { 42 String[] bogusInputs = { 43 "", 44 "016.016.016.016", 45 "016.016.016", 46 "016.016", 47 "016", 48 "000.000.000.000", 49 "000", 50 "0x0a.0x0a.0x0a.0x0a", 51 "0x0a.0x0a.0x0a", 52 "0x0a.0x0a", 53 "0x0a", 54 "42.42.42.42.42", 55 "42.42.42", 56 "42.42", 57 "42", 58 "42..42.42", 59 "42..42.42.42", 60 "42.42.42.42.", 61 "42.42.42.42...", 62 ".42.42.42.42", 63 "...42.42.42.42", 64 "42.42.42.-0", 65 "42.42.42.+0", 66 ".", 67 "...", 68 "bogus", 69 "bogus.com", 70 "192.168.0.1.com", 71 "12345.67899.-54321.-98765", 72 "257.0.0.0", 73 "42.42.42.-42", 74 "3ffe::1.net", 75 "3ffe::1::1", 76 "1::2::3::4:5", 77 "::7:6:5:4:3:2:", // should end with ":0" 78 ":6:5:4:3:2:1::", // should begin with "0:" 79 "2001::db:::1", 80 "FEDC:9878", 81 "+1.+2.+3.4", 82 "1.2.3.4e0", 83 "::7:6:5:4:3:2:1:0", // too many parts 84 "7:6:5:4:3:2:1:0::", // too many parts 85 "9:8:7:6:5:4:3::2:1", // too many parts 86 "0:1:2:3::4:5:6:7", // :: must remove at least one 0. 87 "3ffe:0:0:0:0:0:0:0:1", // too many parts (9 instead of 8) 88 "3ffe::10000", // hextet exceeds 16 bits 89 "3ffe::goog", 90 "3ffe::-0", 91 "3ffe::+0", 92 "3ffe::-1", 93 ":", 94 ":::", 95 "::1.2.3", 96 "::1.2.3.4.5", 97 "::1.2.3.4:", 98 "1.2.3.4::", 99 "2001:db8::1:", 100 ":2001:db8::1", 101 ":1:2:3:4:5:6:7", 102 "1:2:3:4:5:6:7:", 103 ":1:2:3:4:5:6:" 104 }; 105 106 for (int i = 0; i < bogusInputs.length; i++) { 107 try { 108 InetAddresses.forString(bogusInputs[i]); 109 fail("IllegalArgumentException expected for '" + bogusInputs[i] + "'"); 110 } catch (IllegalArgumentException expected) { 111 // expected behavior 112 } 113 assertFalse(InetAddresses.isInetAddress(bogusInputs[i])); 114 } 115 } 116 117 public void test3ff31() { 118 try { 119 InetAddresses.forString("3ffe:::1"); 120 fail("IllegalArgumentException expected"); 121 } catch (IllegalArgumentException expected) { 122 // expected behavior 123 } 124 assertFalse(InetAddresses.isInetAddress("016.016.016.016")); 125 } 126 127 public void testForStringIPv4Input() throws UnknownHostException { 128 String ipStr = "192.168.0.1"; 129 InetAddress ipv4Addr = null; 130 // Shouldn't hit DNS, because it's an IP string literal. 131 ipv4Addr = InetAddress.getByName(ipStr); 132 assertEquals(ipv4Addr, InetAddresses.forString(ipStr)); 133 assertTrue(InetAddresses.isInetAddress(ipStr)); 134 } 135 136 public void testForStringIPv6Input() throws UnknownHostException { 137 String ipStr = "3ffe::1"; 138 InetAddress ipv6Addr = null; 139 // Shouldn't hit DNS, because it's an IP string literal. 140 ipv6Addr = InetAddress.getByName(ipStr); 141 assertEquals(ipv6Addr, InetAddresses.forString(ipStr)); 142 assertTrue(InetAddresses.isInetAddress(ipStr)); 143 } 144 145 public void testForStringIPv6EightColons() throws UnknownHostException { 146 String[] eightColons = { 147 "::7:6:5:4:3:2:1", 148 "::7:6:5:4:3:2:0", 149 "7:6:5:4:3:2:1::", 150 "0:6:5:4:3:2:1::", 151 }; 152 153 for (int i = 0; i < eightColons.length; i++) { 154 InetAddress ipv6Addr = null; 155 // Shouldn't hit DNS, because it's an IP string literal. 156 ipv6Addr = InetAddress.getByName(eightColons[i]); 157 assertEquals(ipv6Addr, InetAddresses.forString(eightColons[i])); 158 assertTrue(InetAddresses.isInetAddress(eightColons[i])); 159 } 160 } 161 162 public void testConvertDottedQuadToHex() throws UnknownHostException { 163 String[] ipStrings = {"7::0.128.0.127", "7::0.128.0.128", 164 "7::128.128.0.127", "7::0.128.128.127"}; 165 166 for (String ipString : ipStrings) { 167 // Shouldn't hit DNS, because it's an IP string literal. 168 InetAddress ipv6Addr = InetAddress.getByName(ipString); 169 assertEquals(ipv6Addr, InetAddresses.forString(ipString)); 170 assertTrue(InetAddresses.isInetAddress(ipString)); 171 } 172 } 173 174 public void testToAddrStringIPv4() { 175 // Don't need to test IPv4 much; it just calls getHostAddress(). 176 assertEquals("1.2.3.4", 177 InetAddresses.toAddrString( 178 InetAddresses.forString("1.2.3.4"))); 179 } 180 181 public void testToAddrStringIPv6() { 182 assertEquals("1:2:3:4:5:6:7:8", 183 InetAddresses.toAddrString( 184 InetAddresses.forString("1:2:3:4:5:6:7:8"))); 185 assertEquals("2001:0:0:4::8", 186 InetAddresses.toAddrString( 187 InetAddresses.forString("2001:0:0:4:0:0:0:8"))); 188 assertEquals("2001::4:5:6:7:8", 189 InetAddresses.toAddrString( 190 InetAddresses.forString("2001:0:0:4:5:6:7:8"))); 191 assertEquals("2001:0:3:4:5:6:7:8", 192 InetAddresses.toAddrString( 193 InetAddresses.forString("2001:0:3:4:5:6:7:8"))); 194 assertEquals("0:0:3::ffff", 195 InetAddresses.toAddrString( 196 InetAddresses.forString("0:0:3:0:0:0:0:ffff"))); 197 assertEquals("::4:0:0:0:ffff", 198 InetAddresses.toAddrString( 199 InetAddresses.forString("0:0:0:4:0:0:0:ffff"))); 200 assertEquals("::5:0:0:ffff", 201 InetAddresses.toAddrString( 202 InetAddresses.forString("0:0:0:0:5:0:0:ffff"))); 203 assertEquals("1::4:0:0:7:8", 204 InetAddresses.toAddrString( 205 InetAddresses.forString("1:0:0:4:0:0:7:8"))); 206 assertEquals("::", 207 InetAddresses.toAddrString( 208 InetAddresses.forString("0:0:0:0:0:0:0:0"))); 209 assertEquals("::1", 210 InetAddresses.toAddrString( 211 InetAddresses.forString("0:0:0:0:0:0:0:1"))); 212 assertEquals("2001:658:22a:cafe::", 213 InetAddresses.toAddrString( 214 InetAddresses.forString("2001:0658:022a:cafe::"))); 215 assertEquals("::102:304", 216 InetAddresses.toAddrString( 217 InetAddresses.forString("::1.2.3.4"))); 218 } 219 220 public void testToUriStringIPv4() { 221 String ipStr = "1.2.3.4"; 222 InetAddress ip = InetAddresses.forString(ipStr); 223 assertEquals("1.2.3.4", InetAddresses.toUriString(ip)); 224 } 225 226 public void testToUriStringIPv6() { 227 // Unfortunately the InetAddress.toString() method for IPv6 addresses 228 // does not collapse contiguous shorts of zeroes with the :: abbreviation. 229 String ipStr = "3ffe::1"; 230 InetAddress ip = InetAddresses.forString(ipStr); 231 assertEquals("[3ffe::1]", InetAddresses.toUriString(ip)); 232 } 233 234 public void testForUriStringIPv4() { 235 Inet4Address expected = (Inet4Address) InetAddresses.forString("192.168.1.1"); 236 assertEquals(expected, InetAddresses.forUriString("192.168.1.1")); 237 } 238 239 public void testForUriStringIPv6() { 240 Inet6Address expected = (Inet6Address) InetAddresses.forString("3ffe:0:0:0:0:0:0:1"); 241 assertEquals(expected, InetAddresses.forUriString("[3ffe:0:0:0:0:0:0:1]")); 242 } 243 244 public void testForUriStringIPv4Mapped() { 245 Inet4Address expected = (Inet4Address) InetAddresses.forString("192.0.2.1"); 246 assertEquals(expected, InetAddresses.forUriString("[::ffff:192.0.2.1]")); 247 } 248 249 public void testIsUriInetAddress() { 250 assertTrue(InetAddresses.isUriInetAddress("192.168.1.1")); 251 assertTrue(InetAddresses.isUriInetAddress("[3ffe:0:0:0:0:0:0:1]")); 252 assertTrue(InetAddresses.isUriInetAddress("[::ffff:192.0.2.1]")); 253 254 assertFalse(InetAddresses.isUriInetAddress("[192.168.1.1")); 255 assertFalse(InetAddresses.isUriInetAddress("192.168.1.1]")); 256 assertFalse(InetAddresses.isUriInetAddress("")); 257 assertFalse(InetAddresses.isUriInetAddress("192.168.999.888")); 258 assertFalse(InetAddresses.isUriInetAddress("www.google.com")); 259 assertFalse(InetAddresses.isUriInetAddress("1:2e")); 260 assertFalse(InetAddresses.isUriInetAddress("[3ffe:0:0:0:0:0:0:1")); 261 assertFalse(InetAddresses.isUriInetAddress("3ffe:0:0:0:0:0:0:1]")); 262 assertFalse(InetAddresses.isUriInetAddress("3ffe:0:0:0:0:0:0:1")); 263 assertFalse(InetAddresses.isUriInetAddress("::ffff:192.0.2.1")); 264 } 265 266 public void testForUriStringBad() { 267 try { 268 InetAddresses.forUriString(""); 269 fail("expected IllegalArgumentException"); // COV_NF_LINE 270 } catch (IllegalArgumentException e) { 271 // expected 272 } 273 274 try { 275 InetAddresses.forUriString("192.168.999.888"); 276 fail("expected IllegalArgumentException"); // COV_NF_LINE 277 } catch (IllegalArgumentException e) { 278 // expected 279 } 280 281 try { 282 InetAddresses.forUriString("www.google.com"); 283 fail("expected IllegalArgumentException"); // COV_NF_LINE 284 } catch (IllegalArgumentException e) { 285 // expected 286 } 287 288 try { 289 InetAddresses.forUriString("[1:2e]"); 290 fail("expected IllegalArgumentException"); // COV_NF_LINE 291 } catch (IllegalArgumentException e) { 292 // expected 293 } 294 295 try { 296 InetAddresses.forUriString("[192.168.1.1]"); 297 fail("expected IllegalArgumentException"); // COV_NF_LINE 298 } catch (IllegalArgumentException e) { 299 // expected 300 } 301 302 try { 303 InetAddresses.forUriString("192.168.1.1]"); 304 fail("expected IllegalArgumentException"); // COV_NF_LINE 305 } catch (IllegalArgumentException e) { 306 // expected 307 } 308 309 try { 310 InetAddresses.forUriString("[192.168.1.1"); 311 fail("expected IllegalArgumentException"); // COV_NF_LINE 312 } catch (IllegalArgumentException e) { 313 // expected 314 } 315 316 try { 317 InetAddresses.forUriString("[3ffe:0:0:0:0:0:0:1"); 318 fail("expected IllegalArgumentException"); // COV_NF_LINE 319 } catch (IllegalArgumentException e) { 320 // expected 321 } 322 323 try { 324 InetAddresses.forUriString("3ffe:0:0:0:0:0:0:1]"); 325 fail("expected IllegalArgumentException"); // COV_NF_LINE 326 } catch (IllegalArgumentException e) { 327 // expected 328 } 329 330 try { 331 InetAddresses.forUriString("3ffe:0:0:0:0:0:0:1"); 332 fail("expected IllegalArgumentException"); // COV_NF_LINE 333 } catch (IllegalArgumentException e) { 334 // expected 335 } 336 337 try { 338 InetAddresses.forUriString("::ffff:192.0.2.1"); 339 fail("expected IllegalArgumentException"); // COV_NF_LINE 340 } catch (IllegalArgumentException e) { 341 // expected 342 } 343 } 344 345 public void testCompatIPv4Addresses() { 346 String[] nonCompatAddresses = { 347 "3ffe::1", 348 "::", 349 "::1", 350 }; 351 352 for (int i = 0; i < nonCompatAddresses.length; i++) { 353 InetAddress ip = InetAddresses.forString(nonCompatAddresses[i]); 354 assertFalse(InetAddresses.isCompatIPv4Address((Inet6Address) ip)); 355 try { 356 InetAddresses.getCompatIPv4Address((Inet6Address) ip); 357 fail("IllegalArgumentException expected for '" + 358 nonCompatAddresses[i] + "'"); 359 } catch (IllegalArgumentException expected) { 360 // expected behavior 361 } 362 } 363 364 String[] validCompatAddresses = { 365 "::1.2.3.4", 366 "::102:304", 367 }; 368 String compatStr = "1.2.3.4"; 369 InetAddress compat = InetAddresses.forString(compatStr); 370 371 for (int i = 0; i < validCompatAddresses.length; i++) { 372 InetAddress ip = InetAddresses.forString(validCompatAddresses[i]); 373 assertTrue("checking '" + validCompatAddresses[i] + "'", ip instanceof Inet6Address); 374 assertTrue("checking '" + validCompatAddresses[i] + "'", 375 InetAddresses.isCompatIPv4Address((Inet6Address) ip)); 376 assertEquals("checking '" + validCompatAddresses[i] + "'", compat, 377 InetAddresses.getCompatIPv4Address((Inet6Address) ip)); 378 } 379 } 380 381 public void testMappedIPv4Addresses() throws UnknownHostException { 382 /* 383 * Verify that it is not possible to instantiate an Inet6Address 384 * from an "IPv4 mapped" IPv6 address. Our String-based method can 385 * at least identify them, however. 386 */ 387 String mappedStr = "::ffff:192.168.0.1"; 388 assertTrue(InetAddresses.isMappedIPv4Address(mappedStr)); 389 InetAddress mapped = InetAddresses.forString(mappedStr); 390 assertFalse(mapped instanceof Inet6Address); 391 assertEquals(InetAddress.getByName("192.168.0.1"), mapped); 392 393 // check upper case 394 mappedStr = "::FFFF:192.168.0.1"; 395 assertTrue(InetAddresses.isMappedIPv4Address(mappedStr)); 396 mapped = InetAddresses.forString(mappedStr); 397 assertFalse(mapped instanceof Inet6Address); 398 assertEquals(InetAddress.getByName("192.168.0.1"), mapped); 399 400 mappedStr = "0:00:000:0000:0:ffff:1.2.3.4"; 401 assertTrue(InetAddresses.isMappedIPv4Address(mappedStr)); 402 mapped = InetAddresses.forString(mappedStr); 403 assertFalse(mapped instanceof Inet6Address); 404 assertEquals(InetAddress.getByName("1.2.3.4"), mapped); 405 406 mappedStr = "::ffff:0102:0304"; 407 assertTrue(InetAddresses.isMappedIPv4Address(mappedStr)); 408 mapped = InetAddresses.forString(mappedStr); 409 assertFalse(mapped instanceof Inet6Address); 410 assertEquals(InetAddress.getByName("1.2.3.4"), mapped); 411 412 assertFalse(InetAddresses.isMappedIPv4Address("::")); 413 assertFalse(InetAddresses.isMappedIPv4Address("::ffff")); 414 assertFalse(InetAddresses.isMappedIPv4Address("::ffff:0")); 415 assertFalse(InetAddresses.isMappedIPv4Address("::fffe:0:0")); 416 assertFalse(InetAddresses.isMappedIPv4Address("::1:ffff:0:0")); 417 assertFalse(InetAddresses.isMappedIPv4Address("foo")); 418 assertFalse(InetAddresses.isMappedIPv4Address("192.0.2.1")); 419 } 420 421 public void test6to4Addresses() { 422 String[] non6to4Addresses = { 423 "::1.2.3.4", 424 "3ffe::1", 425 "::", 426 "::1", 427 }; 428 429 for (int i = 0; i < non6to4Addresses.length; i++) { 430 InetAddress ip = InetAddresses.forString(non6to4Addresses[i]); 431 assertFalse(InetAddresses.is6to4Address((Inet6Address) ip)); 432 try { 433 InetAddresses.get6to4IPv4Address( 434 (Inet6Address) ip); 435 fail("IllegalArgumentException expected for '" + 436 non6to4Addresses[i] + "'"); 437 } catch (IllegalArgumentException expected) { 438 // expected behavior 439 } 440 } 441 442 String valid6to4Address = "2002:0102:0304::1"; 443 String ipv4Str = "1.2.3.4"; 444 445 InetAddress ipv4 = InetAddresses.forString(ipv4Str); 446 InetAddress ip = InetAddresses.forString(valid6to4Address); 447 assertTrue(InetAddresses.is6to4Address((Inet6Address) ip)); 448 assertEquals(ipv4, InetAddresses.get6to4IPv4Address((Inet6Address) ip)); 449 } 450 451 public void testTeredoAddresses() { 452 String[] nonTeredoAddresses = { 453 "::1.2.3.4", 454 "3ffe::1", 455 "::", 456 "::1", 457 }; 458 459 for (int i = 0; i < nonTeredoAddresses.length; i++) { 460 InetAddress ip = InetAddresses.forString(nonTeredoAddresses[i]); 461 assertFalse(InetAddresses.isTeredoAddress((Inet6Address) ip)); 462 try { 463 InetAddresses.getTeredoInfo((Inet6Address) ip); 464 fail("IllegalArgumentException expected for '" + 465 nonTeredoAddresses[i] + "'"); 466 } catch (IllegalArgumentException expected) { 467 // expected behavior 468 } 469 } 470 471 String validTeredoAddress = "2001:0000:4136:e378:8000:63bf:3fff:fdd2"; 472 String serverStr = "65.54.227.120"; 473 String clientStr = "192.0.2.45"; 474 int port = 40000; 475 int flags = 0x8000; 476 477 InetAddress ip = InetAddresses.forString(validTeredoAddress); 478 assertTrue(InetAddresses.isTeredoAddress((Inet6Address) ip)); 479 InetAddresses.TeredoInfo teredo = 480 InetAddresses.getTeredoInfo((Inet6Address) ip); 481 482 InetAddress server = InetAddresses.forString(serverStr); 483 assertEquals(server, teredo.getServer()); 484 485 InetAddress client = InetAddresses.forString(clientStr); 486 assertEquals(client, teredo.getClient()); 487 488 assertEquals(port, teredo.getPort()); 489 assertEquals(flags, teredo.getFlags()); 490 } 491 492 public void testTeredoAddress_nullServer() { 493 InetAddresses.TeredoInfo info = new InetAddresses.TeredoInfo(null, null, 80, 1000); 494 assertEquals(InetAddresses.forString("0.0.0.0"), info.getServer()); 495 assertEquals(InetAddresses.forString("0.0.0.0"), info.getClient()); 496 assertEquals(80, info.getPort()); 497 assertEquals(1000, info.getFlags()); 498 } 499 500 public void testIsatapAddresses() { 501 InetAddress ipv4 = InetAddresses.forString("1.2.3.4"); 502 String[] validIsatapAddresses = { 503 "2001:db8::5efe:102:304", 504 "2001:db8::100:5efe:102:304", // Private Multicast? Not likely. 505 "2001:db8::200:5efe:102:304", 506 "2001:db8::300:5efe:102:304" // Public Multicast? Also unlikely. 507 }; 508 String[] nonIsatapAddresses = { 509 "::1.2.3.4", 510 "3ffe::1", 511 "::", 512 "::1", 513 "2001:db8::0040:5efe:102:304", 514 "2001:db8::5ffe:102:304", 515 "2001:db8::5eff:102:304", 516 "2001:0:102:203:200:5efe:506:708", // Teredo address; not ISATAP 517 }; 518 519 for (int i = 0; i < validIsatapAddresses.length; i++) { 520 InetAddress ip = InetAddresses.forString(validIsatapAddresses[i]); 521 assertTrue(InetAddresses.isIsatapAddress((Inet6Address) ip)); 522 assertEquals("checking '" + validIsatapAddresses[i] + "'", ipv4, 523 InetAddresses.getIsatapIPv4Address((Inet6Address) ip)); 524 } 525 for (int i = 0; i < nonIsatapAddresses.length; i++) { 526 InetAddress ip = InetAddresses.forString(nonIsatapAddresses[i]); 527 assertFalse(InetAddresses.isIsatapAddress((Inet6Address) ip)); 528 try { 529 InetAddresses.getIsatapIPv4Address((Inet6Address) ip); 530 fail("IllegalArgumentException expected for '" + 531 nonIsatapAddresses[i] + "'"); 532 } catch (IllegalArgumentException expected) { 533 // expected behavior 534 } 535 } 536 } 537 538 public void testGetEmbeddedIPv4ClientAddress() { 539 Inet6Address testIp; 540 541 // Test regular global unicast address. 542 testIp = (Inet6Address) InetAddresses.forString("2001:db8::1"); 543 assertFalse(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp)); 544 545 // Test ISATAP address. 546 testIp = (Inet6Address) InetAddresses.forString("2001:db8::5efe:102:304"); 547 assertFalse(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp)); 548 549 // Test compat address. 550 testIp = (Inet6Address) InetAddresses.forString("::1.2.3.4"); 551 assertTrue(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp)); 552 InetAddress ipv4 = InetAddresses.forString("1.2.3.4"); 553 assertEquals(ipv4, InetAddresses.getEmbeddedIPv4ClientAddress(testIp)); 554 555 // Test 6to4 address. 556 testIp = (Inet6Address) InetAddresses.forString("2002:0102:0304::1"); 557 assertTrue(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp)); 558 ipv4 = InetAddresses.forString("1.2.3.4"); 559 assertEquals(ipv4, InetAddresses.getEmbeddedIPv4ClientAddress(testIp)); 560 561 // Test Teredo address. 562 testIp = (Inet6Address) InetAddresses.forString( 563 "2001:0000:4136:e378:8000:63bf:3fff:fdd2"); 564 assertTrue(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp)); 565 ipv4 = InetAddresses.forString("192.0.2.45"); 566 assertEquals(ipv4, InetAddresses.getEmbeddedIPv4ClientAddress(testIp)); 567 } 568 569 public void testGetCoercedIPv4Address() { 570 // Check that a coerced IPv4 address is unaltered. 571 InetAddress localHost4 = InetAddresses.forString("127.0.0.1"); 572 assertEquals(localHost4, 573 InetAddresses.getCoercedIPv4Address(localHost4)); 574 575 // ::1 special case 576 assertEquals(localHost4, 577 InetAddresses.getCoercedIPv4Address( 578 InetAddresses.forString("::1"))); 579 580 // :: special case 581 assertEquals(InetAddresses.forString("0.0.0.0"), 582 InetAddresses.getCoercedIPv4Address( 583 InetAddresses.forString("::"))); 584 585 // test compat address (should be hashed) 586 assertTrue(InetAddresses.forString("1.2.3.4") != 587 InetAddresses.getCoercedIPv4Address( 588 InetAddresses.forString("::1.2.3.4"))); 589 590 // test 6to4 address (should be hashed) 591 assertTrue(InetAddresses.forString("1.2.3.4") != 592 InetAddresses.getCoercedIPv4Address( 593 InetAddresses.forString("2002:0102:0304::1"))); 594 595 // 2 6to4 addresses differing in the embedded IPv4 address should 596 // hash to the different values. 597 assertTrue(InetAddresses.getCoercedIPv4Address( 598 InetAddresses.forString("2002:0102:0304::1")) != 599 InetAddresses.getCoercedIPv4Address( 600 InetAddresses.forString("2002:0506:0708::1"))); 601 602 // 2 6to4 addresses NOT differing in the embedded IPv4 address should 603 // hash to the same value. 604 assertTrue(InetAddresses.getCoercedIPv4Address( 605 InetAddresses.forString("2002:0102:0304::1")) != 606 InetAddresses.getCoercedIPv4Address( 607 InetAddresses.forString("2002:0102:0304::2"))); 608 609 // test Teredo address (should be hashed) 610 assertTrue(InetAddresses.forString("192.0.2.45") != 611 InetAddresses.getCoercedIPv4Address( 612 InetAddresses.forString( 613 "2001:0000:4136:e378:8000:63bf:3fff:fdd2"))); 614 615 // 2 Teredo addresses differing in the embedded IPv4 address should 616 // hash to the different values. 617 assertTrue(InetAddresses.getCoercedIPv4Address( 618 InetAddresses.forString( 619 "2001:0000:4136:e378:8000:63bf:3fff:fdd2")) != 620 InetAddresses.getCoercedIPv4Address( 621 InetAddresses.forString( 622 "2001:0000:4136:e379:8000:63bf:3fff:fdd2"))); 623 624 // 2 Teredo addresses NOT differing in the embedded IPv4 address should 625 // hash to the same value. 626 assertEquals(InetAddresses.getCoercedIPv4Address( 627 InetAddresses.forString( 628 "2001:0000:4136:e378:8000:63bf:3fff:fdd2")), 629 InetAddresses.getCoercedIPv4Address( 630 InetAddresses.forString( 631 "2001:0000:4136:e378:9000:63bf:3fff:fdd2"))); 632 633 // Test that an address hashes in to the 224.0.0.0/3 number-space. 634 InetAddress coerced = InetAddresses.getCoercedIPv4Address( 635 InetAddresses.forString("2001:4860::1")); 636 assertTrue(0xe0000000 <= InetAddresses.coerceToInteger(coerced)); 637 assertTrue(InetAddresses.coerceToInteger(coerced) <= 0xfffffffe); 638 } 639 640 public void testToInteger() { 641 InetAddress ipv4Addr = InetAddresses.forString("127.0.0.1"); 642 assertEquals(0x7f000001, InetAddresses.coerceToInteger(ipv4Addr)); 643 } 644 645 public void testFromInteger() { 646 assertEquals(InetAddresses.fromInteger(0x7f000001), 647 InetAddresses.forString("127.0.0.1")); 648 } 649 650 public void testFromLittleEndianByteArray() throws UnknownHostException { 651 assertEquals( 652 InetAddresses.fromLittleEndianByteArray(new byte[] {1, 2, 3, 4}), 653 InetAddress.getByAddress(new byte[] {4, 3, 2, 1})); 654 655 assertEquals( 656 InetAddresses.fromLittleEndianByteArray( 657 new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}), 658 InetAddress.getByAddress( 659 new byte[] {16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1})); 660 661 try { 662 InetAddresses.fromLittleEndianByteArray(new byte[3]); 663 fail("expected exception"); 664 } catch (UnknownHostException expected) { 665 // success 666 } 667 } 668 669 public void testIsMaximum() throws UnknownHostException { 670 InetAddress address = InetAddress.getByName("255.255.255.254"); 671 assertFalse(InetAddresses.isMaximum(address)); 672 673 address = InetAddress.getByName("255.255.255.255"); 674 assertTrue(InetAddresses.isMaximum(address)); 675 676 address = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe"); 677 assertFalse(InetAddresses.isMaximum(address)); 678 679 address = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); 680 assertTrue(InetAddresses.isMaximum(address)); 681 } 682 683 public void testIncrementIPv4() throws UnknownHostException { 684 InetAddress address_66_0 = InetAddress.getByName("172.24.66.0"); 685 InetAddress address_66_255 = InetAddress.getByName("172.24.66.255"); 686 InetAddress address_67_0 = InetAddress.getByName("172.24.67.0"); 687 688 InetAddress address = address_66_0; 689 for (int i = 0; i < 255; i++) { 690 address = InetAddresses.increment(address); 691 } 692 assertEquals(address_66_255, address); 693 694 address = InetAddresses.increment(address); 695 assertEquals(address_67_0, address); 696 697 InetAddress address_ffffff = InetAddress.getByName("255.255.255.255"); 698 address = address_ffffff; 699 try { 700 address = InetAddresses.increment(address); 701 fail(); 702 } catch (IllegalArgumentException expected) {} 703 } 704 705 public void testIncrementIPv6() throws UnknownHostException { 706 InetAddress addressV6_66_0 = InetAddress.getByName("2001:db8::6600"); 707 InetAddress addressV6_66_ff = InetAddress.getByName("2001:db8::66ff"); 708 InetAddress addressV6_67_0 = InetAddress.getByName("2001:db8::6700"); 709 710 InetAddress address = addressV6_66_0; 711 for (int i = 0; i < 255; i++) { 712 address = InetAddresses.increment(address); 713 } 714 assertEquals(addressV6_66_ff, address); 715 716 address = InetAddresses.increment(address); 717 assertEquals(addressV6_67_0, address); 718 719 InetAddress addressV6_ffffff = 720 InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); 721 address = addressV6_ffffff; 722 try { 723 address = InetAddresses.increment(address); 724 fail(); 725 } catch (IllegalArgumentException expected) {} 726 } 727 728 public void testDecrementIPv4() throws UnknownHostException { 729 InetAddress address660 = InetAddress.getByName("172.24.66.0"); 730 InetAddress address66255 = InetAddress.getByName("172.24.66.255"); 731 InetAddress address670 = InetAddress.getByName("172.24.67.0"); 732 733 InetAddress address = address670; 734 address = InetAddresses.decrement(address); 735 736 assertEquals(address66255, address); 737 738 for (int i = 0; i < 255; i++) { 739 address = InetAddresses.decrement(address); 740 } 741 assertEquals(address660, address); 742 743 InetAddress address0000 = InetAddress.getByName("0.0.0.0"); 744 address = address0000; 745 try { 746 address = InetAddresses.decrement(address); 747 fail(); 748 } catch (IllegalArgumentException expected) {} 749 } 750 751 public void testDecrementIPv6() throws UnknownHostException { 752 InetAddress addressV6660 = InetAddress.getByName("2001:db8::6600"); 753 InetAddress addressV666ff = InetAddress.getByName("2001:db8::66ff"); 754 InetAddress addressV6670 = InetAddress.getByName("2001:db8::6700"); 755 756 InetAddress address = addressV6670; 757 address = InetAddresses.decrement(address); 758 759 assertEquals(addressV666ff, address); 760 761 for (int i = 0; i < 255; i++) { 762 address = InetAddresses.decrement(address); 763 } 764 assertEquals(addressV6660, address); 765 766 InetAddress addressV6000000 = 767 InetAddress.getByName("0:0:0:0:0:0:0:0"); 768 address = addressV6000000; 769 try { 770 address = InetAddresses.decrement(address); 771 fail(); 772 } catch (IllegalArgumentException expected) {} 773 } 774 } 775
