/* * Copyright (C) 2008 The Guava Authors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.google.common.net; import com.google.common.testing.NullPointerTester; import junit.framework.TestCase; import java.net.Inet4Address; import java.net.Inet6Address; import java.net.InetAddress; import java.net.UnknownHostException; /** * Tests for {@link InetAddresses}. * * @author Erik Kline */ public class InetAddressesTest extends TestCase { public void testNulls() throws Exception { NullPointerTester tester = new NullPointerTester(); tester.testAllPublicStaticMethods(InetAddresses.class); } public void testForStringBogusInput() { String[] bogusInputs = { "", "016.016.016.016", "016.016.016", "016.016", "016", "000.000.000.000", "000", "0x0a.0x0a.0x0a.0x0a", "0x0a.0x0a.0x0a", "0x0a.0x0a", "0x0a", "42.42.42.42.42", "42.42.42", "42.42", "42", "42..42.42", "42..42.42.42", "42.42.42.42.", "42.42.42.42...", ".42.42.42.42", "...42.42.42.42", "42.42.42.-0", "42.42.42.+0", ".", "...", "bogus", "bogus.com", "192.168.0.1.com", "12345.67899.-54321.-98765", "257.0.0.0", "42.42.42.-42", "3ffe::1.net", "3ffe::1::1", "1::2::3::4:5", "::7:6:5:4:3:2:", // should end with ":0" ":6:5:4:3:2:1::", // should begin with "0:" "2001::db:::1", "FEDC:9878", "+1.+2.+3.4", "1.2.3.4e0", "::7:6:5:4:3:2:1:0", // too many parts "7:6:5:4:3:2:1:0::", // too many parts "9:8:7:6:5:4:3::2:1", // too many parts "0:1:2:3::4:5:6:7", // :: must remove at least one 0. "3ffe:0:0:0:0:0:0:0:1", // too many parts (9 instead of 8) "3ffe::10000", // hextet exceeds 16 bits "3ffe::goog", "3ffe::-0", "3ffe::+0", "3ffe::-1", ":", ":::", "::1.2.3", "::1.2.3.4.5", "::1.2.3.4:", "1.2.3.4::", "2001:db8::1:", ":2001:db8::1", ":1:2:3:4:5:6:7", "1:2:3:4:5:6:7:", ":1:2:3:4:5:6:" }; for (int i = 0; i < bogusInputs.length; i++) { try { InetAddresses.forString(bogusInputs[i]); fail("IllegalArgumentException expected for '" + bogusInputs[i] + "'"); } catch (IllegalArgumentException expected) { // expected behavior } assertFalse(InetAddresses.isInetAddress(bogusInputs[i])); } } public void test3ff31() { try { InetAddresses.forString("3ffe:::1"); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException expected) { // expected behavior } assertFalse(InetAddresses.isInetAddress("016.016.016.016")); } public void testForStringIPv4Input() throws UnknownHostException { String ipStr = "192.168.0.1"; InetAddress ipv4Addr = null; // Shouldn't hit DNS, because it's an IP string literal. ipv4Addr = InetAddress.getByName(ipStr); assertEquals(ipv4Addr, InetAddresses.forString(ipStr)); assertTrue(InetAddresses.isInetAddress(ipStr)); } public void testForStringIPv6Input() throws UnknownHostException { String ipStr = "3ffe::1"; InetAddress ipv6Addr = null; // Shouldn't hit DNS, because it's an IP string literal. ipv6Addr = InetAddress.getByName(ipStr); assertEquals(ipv6Addr, InetAddresses.forString(ipStr)); assertTrue(InetAddresses.isInetAddress(ipStr)); } public void testForStringIPv6EightColons() throws UnknownHostException { String[] eightColons = { "::7:6:5:4:3:2:1", "::7:6:5:4:3:2:0", "7:6:5:4:3:2:1::", "0:6:5:4:3:2:1::", }; for (int i = 0; i < eightColons.length; i++) { InetAddress ipv6Addr = null; // Shouldn't hit DNS, because it's an IP string literal. ipv6Addr = InetAddress.getByName(eightColons[i]); assertEquals(ipv6Addr, InetAddresses.forString(eightColons[i])); assertTrue(InetAddresses.isInetAddress(eightColons[i])); } } public void testConvertDottedQuadToHex() throws UnknownHostException { String[] ipStrings = {"7::0.128.0.127", "7::0.128.0.128", "7::128.128.0.127", "7::0.128.128.127"}; for (String ipString : ipStrings) { // Shouldn't hit DNS, because it's an IP string literal. InetAddress ipv6Addr = InetAddress.getByName(ipString); assertEquals(ipv6Addr, InetAddresses.forString(ipString)); assertTrue(InetAddresses.isInetAddress(ipString)); } } public void testToAddrStringIPv4() { // Don't need to test IPv4 much; it just calls getHostAddress(). assertEquals("1.2.3.4", InetAddresses.toAddrString( InetAddresses.forString("1.2.3.4"))); } public void testToAddrStringIPv6() { assertEquals("1:2:3:4:5:6:7:8", InetAddresses.toAddrString( InetAddresses.forString("1:2:3:4:5:6:7:8"))); assertEquals("2001:0:0:4::8", InetAddresses.toAddrString( InetAddresses.forString("2001:0:0:4:0:0:0:8"))); assertEquals("2001::4:5:6:7:8", InetAddresses.toAddrString( InetAddresses.forString("2001:0:0:4:5:6:7:8"))); assertEquals("2001:0:3:4:5:6:7:8", InetAddresses.toAddrString( InetAddresses.forString("2001:0:3:4:5:6:7:8"))); assertEquals("0:0:3::ffff", InetAddresses.toAddrString( InetAddresses.forString("0:0:3:0:0:0:0:ffff"))); assertEquals("::4:0:0:0:ffff", InetAddresses.toAddrString( InetAddresses.forString("0:0:0:4:0:0:0:ffff"))); assertEquals("::5:0:0:ffff", InetAddresses.toAddrString( InetAddresses.forString("0:0:0:0:5:0:0:ffff"))); assertEquals("1::4:0:0:7:8", InetAddresses.toAddrString( InetAddresses.forString("1:0:0:4:0:0:7:8"))); assertEquals("::", InetAddresses.toAddrString( InetAddresses.forString("0:0:0:0:0:0:0:0"))); assertEquals("::1", InetAddresses.toAddrString( InetAddresses.forString("0:0:0:0:0:0:0:1"))); assertEquals("2001:658:22a:cafe::", InetAddresses.toAddrString( InetAddresses.forString("2001:0658:022a:cafe::"))); assertEquals("::102:304", InetAddresses.toAddrString( InetAddresses.forString("::1.2.3.4"))); } public void testToUriStringIPv4() { String ipStr = "1.2.3.4"; InetAddress ip = InetAddresses.forString(ipStr); assertEquals("1.2.3.4", InetAddresses.toUriString(ip)); } public void testToUriStringIPv6() { // Unfortunately the InetAddress.toString() method for IPv6 addresses // does not collapse contiguous shorts of zeroes with the :: abbreviation. String ipStr = "3ffe::1"; InetAddress ip = InetAddresses.forString(ipStr); assertEquals("[3ffe::1]", InetAddresses.toUriString(ip)); } public void testForUriStringIPv4() { Inet4Address expected = (Inet4Address) InetAddresses.forString("192.168.1.1"); assertEquals(expected, InetAddresses.forUriString("192.168.1.1")); } public void testForUriStringIPv6() { Inet6Address expected = (Inet6Address) InetAddresses.forString("3ffe:0:0:0:0:0:0:1"); assertEquals(expected, InetAddresses.forUriString("[3ffe:0:0:0:0:0:0:1]")); } public void testIsUriInetAddress() { assertTrue(InetAddresses.isUriInetAddress("192.168.1.1")); assertTrue(InetAddresses.isUriInetAddress("[3ffe:0:0:0:0:0:0:1]")); assertFalse(InetAddresses.isUriInetAddress("[192.168.1.1")); assertFalse(InetAddresses.isUriInetAddress("192.168.1.1]")); assertFalse(InetAddresses.isUriInetAddress("")); assertFalse(InetAddresses.isUriInetAddress("192.168.999.888")); assertFalse(InetAddresses.isUriInetAddress("www.google.com")); assertFalse(InetAddresses.isUriInetAddress("1:2e")); assertFalse(InetAddresses.isUriInetAddress("[3ffe:0:0:0:0:0:0:1")); assertFalse(InetAddresses.isUriInetAddress("3ffe:0:0:0:0:0:0:1]")); } public void testForUriStringBad() { try { InetAddresses.forUriString(""); fail("expected IllegalArgumentException"); // COV_NF_LINE } catch (IllegalArgumentException e) { // expected } try { InetAddresses.forUriString("192.168.999.888"); fail("expected IllegalArgumentException"); // COV_NF_LINE } catch (IllegalArgumentException e) { // expected } try { InetAddresses.forUriString("www.google.com"); fail("expected IllegalArgumentException"); // COV_NF_LINE } catch (IllegalArgumentException e) { // expected } try { InetAddresses.forUriString("[1:2e]"); fail("expected IllegalArgumentException"); // COV_NF_LINE } catch (IllegalArgumentException e) { // expected } try { InetAddresses.forUriString("[192.168.1.1]"); fail("expected IllegalArgumentException"); // COV_NF_LINE } catch (IllegalArgumentException e) { // expected } try { InetAddresses.forUriString("192.168.1.1]"); fail("expected IllegalArgumentException"); // COV_NF_LINE } catch (IllegalArgumentException e) { // expected } try { InetAddresses.forUriString("[192.168.1.1"); fail("expected IllegalArgumentException"); // COV_NF_LINE } catch (IllegalArgumentException e) { // expected } try { InetAddresses.forUriString("[3ffe:0:0:0:0:0:0:1"); fail("expected IllegalArgumentException"); // COV_NF_LINE } catch (IllegalArgumentException e) { // expected } try { InetAddresses.forUriString("3ffe:0:0:0:0:0:0:1]"); fail("expected IllegalArgumentException"); // COV_NF_LINE } catch (IllegalArgumentException e) { // expected } } public void testCompatIPv4Addresses() { String[] nonCompatAddresses = { "3ffe::1", "::", "::1", }; for (int i = 0; i < nonCompatAddresses.length; i++) { InetAddress ip = InetAddresses.forString(nonCompatAddresses[i]); assertFalse(InetAddresses.isCompatIPv4Address((Inet6Address) ip)); try { InetAddresses.getCompatIPv4Address((Inet6Address) ip); fail("IllegalArgumentException expected for '" + nonCompatAddresses[i] + "'"); } catch (IllegalArgumentException expected) { // expected behavior } } String[] validCompatAddresses = { "::1.2.3.4", "::102:304", }; String compatStr = "1.2.3.4"; InetAddress compat = InetAddresses.forString(compatStr); for (int i = 0; i < validCompatAddresses.length; i++) { InetAddress ip = InetAddresses.forString(validCompatAddresses[i]); assertTrue("checking '" + validCompatAddresses[i] + "'", ip instanceof Inet6Address); assertTrue("checking '" + validCompatAddresses[i] + "'", InetAddresses.isCompatIPv4Address((Inet6Address) ip)); assertEquals("checking '" + validCompatAddresses[i] + "'", compat, InetAddresses.getCompatIPv4Address((Inet6Address) ip)); } } public void testMappedIPv4Addresses() throws UnknownHostException { /* * Verify that it is not possible to instantiate an Inet6Address * from an "IPv4 mapped" IPv6 address. Our String-based method can * at least identify them, however. */ String mappedStr = "::ffff:192.168.0.1"; assertTrue(InetAddresses.isMappedIPv4Address(mappedStr)); InetAddress mapped = InetAddresses.forString(mappedStr); assertFalse(mapped instanceof Inet6Address); assertEquals(InetAddress.getByName("192.168.0.1"), mapped); // check upper case mappedStr = "::FFFF:192.168.0.1"; assertTrue(InetAddresses.isMappedIPv4Address(mappedStr)); mapped = InetAddresses.forString(mappedStr); assertFalse(mapped instanceof Inet6Address); assertEquals(InetAddress.getByName("192.168.0.1"), mapped); mappedStr = "0:00:000:0000:0:ffff:1.2.3.4"; assertTrue(InetAddresses.isMappedIPv4Address(mappedStr)); mapped = InetAddresses.forString(mappedStr); assertFalse(mapped instanceof Inet6Address); assertEquals(InetAddress.getByName("1.2.3.4"), mapped); mappedStr = "::ffff:0102:0304"; assertTrue(InetAddresses.isMappedIPv4Address(mappedStr)); mapped = InetAddresses.forString(mappedStr); assertFalse(mapped instanceof Inet6Address); assertEquals(InetAddress.getByName("1.2.3.4"), mapped); assertFalse(InetAddresses.isMappedIPv4Address("::")); assertFalse(InetAddresses.isMappedIPv4Address("::ffff")); assertFalse(InetAddresses.isMappedIPv4Address("::ffff:0")); assertFalse(InetAddresses.isMappedIPv4Address("::fffe:0:0")); assertFalse(InetAddresses.isMappedIPv4Address("::1:ffff:0:0")); assertFalse(InetAddresses.isMappedIPv4Address("foo")); assertFalse(InetAddresses.isMappedIPv4Address("192.0.2.1")); } public void test6to4Addresses() { String[] non6to4Addresses = { "::1.2.3.4", "3ffe::1", "::", "::1", }; for (int i = 0; i < non6to4Addresses.length; i++) { InetAddress ip = InetAddresses.forString(non6to4Addresses[i]); assertFalse(InetAddresses.is6to4Address((Inet6Address) ip)); try { InetAddresses.get6to4IPv4Address( (Inet6Address) ip); fail("IllegalArgumentException expected for '" + non6to4Addresses[i] + "'"); } catch (IllegalArgumentException expected) { // expected behavior } } String valid6to4Address = "2002:0102:0304::1"; String ipv4Str = "1.2.3.4"; InetAddress ipv4 = InetAddresses.forString(ipv4Str); InetAddress ip = InetAddresses.forString(valid6to4Address); assertTrue(InetAddresses.is6to4Address((Inet6Address) ip)); assertEquals(ipv4, InetAddresses.get6to4IPv4Address((Inet6Address) ip)); } public void testTeredoAddresses() { String[] nonTeredoAddresses = { "::1.2.3.4", "3ffe::1", "::", "::1", }; for (int i = 0; i < nonTeredoAddresses.length; i++) { InetAddress ip = InetAddresses.forString(nonTeredoAddresses[i]); assertFalse(InetAddresses.isTeredoAddress((Inet6Address) ip)); try { InetAddresses.getTeredoInfo((Inet6Address) ip); fail("IllegalArgumentException expected for '" + nonTeredoAddresses[i] + "'"); } catch (IllegalArgumentException expected) { // expected behavior } } String validTeredoAddress = "2001:0000:4136:e378:8000:63bf:3fff:fdd2"; String serverStr = "65.54.227.120"; String clientStr = "192.0.2.45"; int port = 40000; int flags = 0x8000; InetAddress ip = InetAddresses.forString(validTeredoAddress); assertTrue(InetAddresses.isTeredoAddress((Inet6Address) ip)); InetAddresses.TeredoInfo teredo = InetAddresses.getTeredoInfo((Inet6Address) ip); InetAddress server = InetAddresses.forString(serverStr); assertEquals(server, teredo.getServer()); InetAddress client = InetAddresses.forString(clientStr); assertEquals(client, teredo.getClient()); assertEquals(port, teredo.getPort()); assertEquals(flags, teredo.getFlags()); } public void testIsatapAddresses() { InetAddress ipv4 = InetAddresses.forString("1.2.3.4"); String[] validIsatapAddresses = { "2001:db8::5efe:102:304", "2001:db8::100:5efe:102:304", // Private Multicast? Not likely. "2001:db8::200:5efe:102:304", "2001:db8::300:5efe:102:304" // Public Multicast? Also unlikely. }; String[] nonIsatapAddresses = { "::1.2.3.4", "3ffe::1", "::", "::1", "2001:db8::0040:5efe:102:304", "2001:db8::5ffe:102:304", "2001:db8::5eff:102:304", "2001:0:102:203:200:5efe:506:708", // Teredo address; not ISATAP }; for (int i = 0; i < validIsatapAddresses.length; i++) { InetAddress ip = InetAddresses.forString(validIsatapAddresses[i]); assertTrue(InetAddresses.isIsatapAddress((Inet6Address) ip)); assertEquals("checking '" + validIsatapAddresses[i] + "'", ipv4, InetAddresses.getIsatapIPv4Address((Inet6Address) ip)); } for (int i = 0; i < nonIsatapAddresses.length; i++) { InetAddress ip = InetAddresses.forString(nonIsatapAddresses[i]); assertFalse(InetAddresses.isIsatapAddress((Inet6Address) ip)); try { InetAddresses.getIsatapIPv4Address((Inet6Address) ip); fail("IllegalArgumentException expected for '" + nonIsatapAddresses[i] + "'"); } catch (IllegalArgumentException expected) { // expected behavior } } } public void testGetEmbeddedIPv4ClientAddress() { Inet6Address testIp; // Test regular global unicast address. testIp = (Inet6Address) InetAddresses.forString("2001:db8::1"); assertFalse(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp)); // Test ISATAP address. testIp = (Inet6Address) InetAddresses.forString("2001:db8::5efe:102:304"); assertFalse(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp)); // Test compat address. testIp = (Inet6Address) InetAddresses.forString("::1.2.3.4"); assertTrue(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp)); InetAddress ipv4 = InetAddresses.forString("1.2.3.4"); assertEquals(ipv4, InetAddresses.getEmbeddedIPv4ClientAddress(testIp)); // Test 6to4 address. testIp = (Inet6Address) InetAddresses.forString("2002:0102:0304::1"); assertTrue(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp)); ipv4 = InetAddresses.forString("1.2.3.4"); assertEquals(ipv4, InetAddresses.getEmbeddedIPv4ClientAddress(testIp)); // Test Teredo address. testIp = (Inet6Address) InetAddresses.forString( "2001:0000:4136:e378:8000:63bf:3fff:fdd2"); assertTrue(InetAddresses.hasEmbeddedIPv4ClientAddress(testIp)); ipv4 = InetAddresses.forString("192.0.2.45"); assertEquals(ipv4, InetAddresses.getEmbeddedIPv4ClientAddress(testIp)); } public void testGetCoercedIPv4Address() { // Check that a coerced IPv4 address is unaltered. InetAddress localHost4 = InetAddresses.forString("127.0.0.1"); assertEquals(localHost4, InetAddresses.getCoercedIPv4Address(localHost4)); // ::1 special case assertEquals(localHost4, InetAddresses.getCoercedIPv4Address( InetAddresses.forString("::1"))); // :: special case assertEquals(InetAddresses.forString("0.0.0.0"), InetAddresses.getCoercedIPv4Address( InetAddresses.forString("::"))); // test compat address (should be hashed) assertTrue(InetAddresses.forString("1.2.3.4") != InetAddresses.getCoercedIPv4Address( InetAddresses.forString("::1.2.3.4"))); // test 6to4 address (should be hashed) assertTrue(InetAddresses.forString("1.2.3.4") != InetAddresses.getCoercedIPv4Address( InetAddresses.forString("2002:0102:0304::1"))); // 2 6to4 addresses differing in the embedded IPv4 address should // hash to the different values. assertTrue(InetAddresses.getCoercedIPv4Address( InetAddresses.forString("2002:0102:0304::1")) != InetAddresses.getCoercedIPv4Address( InetAddresses.forString("2002:0506:0708::1"))); // 2 6to4 addresses NOT differing in the embedded IPv4 address should // hash to the same value. assertTrue(InetAddresses.getCoercedIPv4Address( InetAddresses.forString("2002:0102:0304::1")) != InetAddresses.getCoercedIPv4Address( InetAddresses.forString("2002:0102:0304::2"))); // test Teredo address (should be hashed) assertTrue(InetAddresses.forString("192.0.2.45") != InetAddresses.getCoercedIPv4Address( InetAddresses.forString( "2001:0000:4136:e378:8000:63bf:3fff:fdd2"))); // 2 Teredo addresses differing in the embedded IPv4 address should // hash to the different values. assertTrue(InetAddresses.getCoercedIPv4Address( InetAddresses.forString( "2001:0000:4136:e378:8000:63bf:3fff:fdd2")) != InetAddresses.getCoercedIPv4Address( InetAddresses.forString( "2001:0000:4136:e379:8000:63bf:3fff:fdd2"))); // 2 Teredo addresses NOT differing in the embedded IPv4 address should // hash to the same value. assertEquals(InetAddresses.getCoercedIPv4Address( InetAddresses.forString( "2001:0000:4136:e378:8000:63bf:3fff:fdd2")), InetAddresses.getCoercedIPv4Address( InetAddresses.forString( "2001:0000:4136:e378:9000:63bf:3fff:fdd2"))); // Test that an address hashes in to the 224.0.0.0/3 number-space. InetAddress coerced = InetAddresses.getCoercedIPv4Address( InetAddresses.forString("2001:4860::1")); assertTrue(0xe0000000 <= InetAddresses.coerceToInteger(coerced)); assertTrue(InetAddresses.coerceToInteger(coerced) <= 0xfffffffe); } public void testHash64To32() { // Make sure the output looks reasonably sane. assertEquals(532412650, InetAddresses.hash64To32(-1)); assertEquals(720020139, InetAddresses.hash64To32(0)); assertEquals(357654460, InetAddresses.hash64To32(1)); assertEquals(-1977349188, InetAddresses.hash64To32(0x7fffffffffffffffL)); } public void testToInteger() { InetAddress ipv4Addr = InetAddresses.forString("127.0.0.1"); assertEquals(0x7f000001, InetAddresses.coerceToInteger(ipv4Addr)); } public void testFromInteger() { assertEquals(InetAddresses.fromInteger(0x7f000001), InetAddresses.forString("127.0.0.1")); } public void testFromLittleEndianByteArray() throws UnknownHostException { assertEquals( InetAddresses.fromLittleEndianByteArray(new byte[] {1, 2, 3, 4}), InetAddress.getByAddress(new byte[] {4, 3, 2, 1})); assertEquals( InetAddresses.fromLittleEndianByteArray( new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}), InetAddress.getByAddress( new byte[] {16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1})); try { InetAddresses.fromLittleEndianByteArray(new byte[3]); fail("expected exception"); } catch (UnknownHostException expected) { // success } } public void testIsMaximum() throws UnknownHostException { InetAddress address = InetAddress.getByName("255.255.255.254"); assertFalse(InetAddresses.isMaximum(address)); address = InetAddress.getByName("255.255.255.255"); assertTrue(InetAddresses.isMaximum(address)); address = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe"); assertFalse(InetAddresses.isMaximum(address)); address = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); assertTrue(InetAddresses.isMaximum(address)); } public void testIncrementIPv4() throws UnknownHostException { InetAddress address_66_0 = InetAddress.getByName("172.24.66.0"); InetAddress address_66_255 = InetAddress.getByName("172.24.66.255"); InetAddress address_67_0 = InetAddress.getByName("172.24.67.0"); InetAddress address = address_66_0; for (int i = 0; i < 255; i++) { address = InetAddresses.increment(address); } assertEquals(address_66_255, address); address = InetAddresses.increment(address); assertEquals(address_67_0, address); InetAddress address_ffffff = InetAddress.getByName("255.255.255.255"); address = address_ffffff; try { address = InetAddresses.increment(address); fail(); } catch (IllegalArgumentException expected) { } } public void testIncrementIPv6() throws UnknownHostException { InetAddress addressV6_66_0 = InetAddress.getByName("2001:db8::6600"); InetAddress addressV6_66_ff = InetAddress.getByName("2001:db8::66ff"); InetAddress addressV6_67_0 = InetAddress.getByName("2001:db8::6700"); InetAddress address = addressV6_66_0; for (int i = 0; i < 255; i++) { address = InetAddresses.increment(address); } assertEquals(addressV6_66_ff, address); address = InetAddresses.increment(address); assertEquals(addressV6_67_0, address); InetAddress addressV6_ffffff = InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); address = addressV6_ffffff; try { address = InetAddresses.increment(address); fail(); } catch (IllegalArgumentException expected) { } } }