/*
* 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) { }
}
}