/*
* Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/* @test
* @bug 8272215 8315767 8332686
* @summary Test for ofLiteral, ofPosixLiteral APIs in InetAddress classes
* @run junit/othervm -Djdk.net.hosts.file=nonExistingHostsFile.txt
* OfLiteralTest
* @run junit/othervm -Djdk.net.hosts.file=nonExistingHostsFile.txt
* -Djava.net.preferIPv4Stack=true
* OfLiteralTest
* @run junit/othervm -Djdk.net.hosts.file=nonExistingHostsFile.txt
* -Djava.net.preferIPv6Addresses=true
* OfLiteralTest
* @run junit/othervm -Djdk.net.hosts.file=nonExistingHostsFile.txt
* -Djava.net.preferIPv6Addresses=false
* OfLiteralTest
*/
import org.junit.Assert;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.function.Executable;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.EnumSource;
import org.junit.jupiter.params.provider.MethodSource;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertThrows;
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class OfLiteralTest {
@ParameterizedTest
@MethodSource("validLiteralArguments")
public void validLiteral(InetAddressClass inetAddressClass,
String addressLiteral,
byte[] expectedAddressBytes) throws Exception {
InetAddress ofLiteralResult = switch (inetAddressClass) {
case INET_ADDRESS -> InetAddress.ofLiteral(addressLiteral);
case INET4_ADDRESS -> Inet4Address.ofLiteral(addressLiteral);
case INET4_ADDRESS_POSIX -> Inet4Address.ofPosixLiteral(addressLiteral);
case INET6_ADDRESS -> Inet6Address.ofLiteral(addressLiteral);
};
Assert.assertArrayEquals(expectedAddressBytes, ofLiteralResult.getAddress());
// POSIX literals are not compatible with InetAddress.getByName()
if (inetAddressClass != InetAddressClass.INET4_ADDRESS_POSIX) {
InetAddress getByNameResult = InetAddress.getByName(addressLiteral);
Assert.assertEquals(getByNameResult, ofLiteralResult);
}
}
private static Stream<Arguments> validLiteralArguments() throws Exception {
// 1080:0:0:0:8:800:200C:417A address bytes
byte[] ipv6AddressExpBytes = new byte[]{16, -128, 0, 0, 0, 0, 0, 0, 0,
8, 8, 0, 32, 12, 65, 122};
// ::129.144.52.38 address bytes
byte[] ipv4CompIpv6ExpBytes = new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, -127, -112, 52, 38};
// 222.173.190.239 address bytes
byte[] ipv4ExpBytes = new byte[]{(byte) 222, (byte) 173,
(byte) 190, (byte) 239};
// 222.173.190.39 address bytes
byte[] ipv4ExpBytes2 = new byte[]{(byte) 222, (byte) 173,
(byte) 190, 39};
// 1.2.3.4 address bytes
byte[] oneToFourAddressExpBytes = new byte[]{1, 2, 3, 4};
// 6.7.8.9 address bytes
byte[] sixtoNineAddressExpBytes = new byte[]{6, 7, 8, 9};
// ::FFFF:129.144.52.38 address bytes
byte[] ipv6Ipv4MappedAddressExpBytes = new byte[]{
(byte) 129, (byte) 144, 52, 38};
// 87.0.0.1 address bytes
byte[] ipv4_87_0_0_1 = new byte[]{87, 0, 0, 1};
// 127.0.0.1 address bytes
byte[] ipv4_127_0_0_1 = new byte[]{127, 0, 0, 1};
// 17.99.141.27 address bytes
byte[] ipv4_17_99_141_27 = new byte[]{17, 99, (byte)141, 27};
// 127.8.0.1 address bytes
byte[] ipv4_127_8_0_1 = new byte[]{127, 8, 0, 1};
// 0.0.0.42 address bytes
byte[] ipv4_0_0_0_42 = new byte[]{0, 0, 0, 42};
// 0.0.0.34 address bytes
byte[] ipv4_0_0_0_34 = new byte[]{0, 0, 0, 34};
// 127.0.1.2 address bytes
byte[] ipv4_127_0_1_2 = new byte[]{127, 0, 1, 2};
// 127.1.2.3 address bytes
byte[] ipv4_127_1_2_3 = new byte[]{127, 1, 2, 3};
// 255.255.255.255 address bytes
byte[] ipv4_255_255_255_255 = new byte[]{(byte)255, (byte)255, (byte)255, (byte)255};
Stream<Arguments> validLiterals = Stream.of(
// IPv6 address literals are parsable by Inet6Address.ofLiteral
// and InetAddress.ofLiteral methods
Arguments.of(InetAddressClass.INET6_ADDRESS,
"1080:0:0:0:8:800:200C:417A", ipv6AddressExpBytes),
Arguments.of(InetAddressClass.INET_ADDRESS,
"[1080:0:0:0:8:800:200C:417A]", ipv6AddressExpBytes),
// Compressed series of zeros with square brackets
Arguments.of(InetAddressClass.INET6_ADDRESS,
"[1080::8:800:200C:417A]", ipv6AddressExpBytes),
// Compressed series of zeros without square brackets
Arguments.of(InetAddressClass.INET_ADDRESS,
"1080::8:800:200C:417A", ipv6AddressExpBytes),
// IPv4-mapped IPv6 address literals are parsable by
// InetAddress.ofLiteral and Inet6Address.ofLiteral methods
Arguments.of(InetAddressClass.INET_ADDRESS,
"::FFFF:129.144.52.38", ipv6Ipv4MappedAddressExpBytes),
Arguments.of(InetAddressClass.INET_ADDRESS,
"[::ffff:1.2.3.4]", oneToFourAddressExpBytes),
Arguments.of(InetAddressClass.INET6_ADDRESS,
"::FFFF:129.144.52.38", ipv6Ipv4MappedAddressExpBytes),
Arguments.of(InetAddressClass.INET6_ADDRESS,
"[::ffff:1.2.3.4]", oneToFourAddressExpBytes),
// IPv4-compatible IPv6 address literals are parsable by
// Inet6Address.ofLiteral and InetAddress.ofLiteral methods
Arguments.of(InetAddressClass.INET6_ADDRESS,
"::129.144.52.38", ipv4CompIpv6ExpBytes),
Arguments.of(InetAddressClass.INET6_ADDRESS,
"[::129.144.52.38]", ipv4CompIpv6ExpBytes),
Arguments.of(InetAddressClass.INET_ADDRESS,
"::129.144.52.38", ipv4CompIpv6ExpBytes),
Arguments.of(InetAddressClass.INET_ADDRESS,
"[::129.144.52.38]", ipv4CompIpv6ExpBytes),
// Tests for IPv4 address literal forms
// form:'d.d.d.d' method:Inet4Address.ofLiteral
Arguments.of(InetAddressClass.INET4_ADDRESS,
"222.173.190.239", ipv4ExpBytes),
// form:'d.d.d.d' with decimal octet with leading zero
Arguments.of(InetAddressClass.INET4_ADDRESS,
"222.173.190.039", ipv4ExpBytes2),
Arguments.of(InetAddressClass.INET4_ADDRESS,
"06.07.08.09", sixtoNineAddressExpBytes),
// form:'d.d.d.d' method:InetAddress.ofLiteral
Arguments.of(InetAddressClass.INET_ADDRESS,
"222.173.190.239", ipv4ExpBytes),
// form:'d.d.d' method:Inet4Address.ofLiteral
Arguments.of(InetAddressClass.INET4_ADDRESS,
"222.173.48879", ipv4ExpBytes),
// form:'d.d.d' method:InetAddress.ofLiteral
Arguments.of(InetAddressClass.INET_ADDRESS,
"222.173.48879", ipv4ExpBytes),
// form:'d.d' method:Inet4Address.ofLiteral
Arguments.of(InetAddressClass.INET4_ADDRESS,
"222.11386607", ipv4ExpBytes),
// form:'d.d' method:InetAddress.ofLiteral
Arguments.of(InetAddressClass.INET_ADDRESS,
"222.11386607", ipv4ExpBytes),
// form:'d' method:Inet4Address.ofLiteral
Arguments.of(InetAddressClass.INET4_ADDRESS,
"3735928559", ipv4ExpBytes),
// form:'d' method:InetAddress.ofLiteral
Arguments.of(InetAddressClass.INET_ADDRESS,
"3735928559", ipv4ExpBytes),
// form:'d' method:InetAddress.ofLiteral -
// with leading 0 that is discarded and address
// parsed as decimal
Arguments.of(InetAddressClass.INET_ADDRESS,
"03735928559", ipv4ExpBytes),
// form:'x.x.x.x' method:InetAddress.ofPosixLiteral -
// with leading 0 treated as octal segment prefix
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"0127.0.0.1", ipv4_87_0_0_1),
// form:'x.x.x.x' method:InetAddress.ofPosixLiteral -
// with leading 0 treated as octal segment prefix
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"0177.0.0.1", ipv4_127_0_0_1),
// form:'x.x.x.x' method:InetAddress.ofPosixLiteral -
// with leading 0s treated as octal segment prefixes
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"0177.0000.0000.0001", ipv4_127_0_0_1),
// form:'x.x.x.x' method:InetAddress.ofPosixLiteral -
// with leading 0 treated as octal segment prefix
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"127.010.0.1", ipv4_127_8_0_1),
// form:'x.x.x.x' method:InetAddress.ofPosixLiteral -
// with leading 0 treated as octal segment prefix
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"0377.0377.0377.0377", ipv4_255_255_255_255),
// form:'x.x.x' method:InetAddress.ofPosixLiteral -
// with leading 0s treated as octal segment prefixes
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"0177.0.0402", ipv4_127_0_1_2),
// form:'x.x.x' method:InetAddress.ofPosixLiteral -
// with leading 0x treated as hexadecimal segment prefixes
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"0x7F.0.0x102", ipv4_127_0_1_2),
// form:'x.x' method:InetAddress.ofPosixLiteral -
// with leading 0s treated as octal segment prefixes
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"0177.0201003", ipv4_127_1_2_3),
// form:'x.x' method:InetAddress.ofPosixLiteral -
// with leading 0x treated as hexadecimal prefixes
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"0x7F.0x10203", ipv4_127_1_2_3),
// form:'x.x' method:InetAddress.ofPosixLiteral -
// without prefixes treated as decimal
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"127.66051", ipv4_127_1_2_3),
// form:'x' method:InetAddress.ofPosixLiteral -
// with leading 0 treated as octal segment prefix
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"017700000001", ipv4_127_0_0_1),
// form:'x' method:InetAddress.ofPosixLiteral -
// with leading 0 treated as octal segment prefix
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"02130706433", ipv4_17_99_141_27),
// form:'x' method:InetAddress.ofPosixLiteral -
// with leading 0 treated as octal segment prefix
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"037777777777", ipv4_255_255_255_255),
// form:'x' method:InetAddress.ofPosixLiteral -
// with leading 0x treated as hex prefix
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"0x1020304", oneToFourAddressExpBytes),
// form:'x' method:InetAddress.ofPosixLiteral -
// with leading 0x treated as hex prefix
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"0xFFFFFFFF", ipv4_255_255_255_255),
// form:'x' method:InetAddress.ofPosixLiteral -
// without leading 0 treated as decimal
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"2130706433", ipv4_127_0_0_1),
// form:'x' method:InetAddress.ofPosixLiteral -
// without leading 0 treated as decimal
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"42", ipv4_0_0_0_42),
// form:'x' method:InetAddress.ofPosixLiteral -
// with leading 0 treated as octal segment prefix
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"0100401404", oneToFourAddressExpBytes),
// form:'x' method:InetAddress.ofPosixLiteral -
// without prefixes treated as decimal
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"16909060", oneToFourAddressExpBytes),
// form:'x' method:InetAddress.ofPosixLiteral -
// with leading 0 treated as octal segment prefix
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX,
"042", ipv4_0_0_0_34)
);
// Generate addresses for loopback and wildcard address test cases
var loopbackAndWildcardAddresses = List.of(
// Loopback address
InetAddress.getLoopbackAddress(),
// IPv6 wildcard address
InetAddress.getByName("::"),
// IPv4 wildcard address
InetAddress.getByName("0.0.0.0"));
// Get addresses for all network interfaces available,
// and construct a test case for each. And then combine
// them with loopback/wildcard test cases.
Stream<Arguments> hostAddressArguments = Stream.concat(
NetworkInterface.networkInterfaces()
.flatMap(NetworkInterface::inetAddresses),
loopbackAndWildcardAddresses.stream())
.flatMap(OfLiteralTest::addressToValidTestCases);
return Stream.concat(validLiterals, hostAddressArguments);
}
@ParameterizedTest
@MethodSource("invalidLiteralArguments")
public void invalidLiteral(InetAddressClass inetAddressClass,
String addressLiteral) {
var executable = constructExecutable(inetAddressClass, addressLiteral);
var exception = assertThrows(IllegalArgumentException.class, executable);
System.err.println("Expected exception observed: " + exception);
}
@ParameterizedTest
@EnumSource(InetAddressClass.class)
public void nullLiteral(InetAddressClass inetAddressClass) {
var executable = constructExecutable(inetAddressClass, null);
assertThrows(NullPointerException.class, executable);
}
private static Stream<Arguments> invalidLiteralArguments() {
Stream<Arguments> argumentsStream = Stream.of(
// IPv4 address wrapped in square brackets
Arguments.of(InetAddressClass.INET_ADDRESS, "[1.2.3.4]"),
Arguments.of(InetAddressClass.INET4_ADDRESS, "[1.2.3.4]"),
Arguments.of(InetAddressClass.INET6_ADDRESS, "[1.2.3.4]"),
// IPv4 address literal with BSD-formatting
Arguments.of(InetAddressClass.INET_ADDRESS, "1.2.3.0256"),
Arguments.of(InetAddressClass.INET4_ADDRESS, "1.2.3.0256"),
// Invalid IPv4-mapped IPv6 address forms
// ::FFFF:d.d.d
Arguments.of(InetAddressClass.INET_ADDRESS, "::FFFF:1.2.3"),
Arguments.of(InetAddressClass.INET6_ADDRESS, "::FFFF:1.2.3"),
// ::FFFF:d.d
Arguments.of(InetAddressClass.INET_ADDRESS, "::FFFF:1.2"),
Arguments.of(InetAddressClass.INET6_ADDRESS, "::FFFF:1.2"),
// ::d.d.d
Arguments.of(InetAddressClass.INET_ADDRESS, "::1.2.3"),
Arguments.of(InetAddressClass.INET6_ADDRESS, "::1.2.3"),
// ::d.d
Arguments.of(InetAddressClass.INET_ADDRESS, "::1.2"),
Arguments.of(InetAddressClass.INET6_ADDRESS, "::1.2"),
// IPv4-mapped IPv6 address with scope-id
Arguments.of(InetAddressClass.INET6_ADDRESS,
"::FFFF:129.144.52.38%1"),
// IPv4-mapped IPv6 addresses cannot be parsed by Inet4Address.ofLiteral
Arguments.of(InetAddressClass.INET4_ADDRESS,
"::FFFF:129.144.52.38"),
Arguments.of(InetAddressClass.INET4_ADDRESS,
"[::ffff:1.2.3.4]"),
// IPv4 literals in BSD form
Arguments.of(InetAddressClass.INET_ADDRESS, "0256.1.2.3"),
Arguments.of(InetAddressClass.INET4_ADDRESS, "1.2.0256.3"),
Arguments.of(InetAddressClass.INET_ADDRESS, "0x1.2.3.4"),
Arguments.of(InetAddressClass.INET4_ADDRESS, "1.2.0x3.4"),
Arguments.of(InetAddressClass.INET_ADDRESS, "0xFFFFFFFF"),
Arguments.of(InetAddressClass.INET4_ADDRESS, "0xFFFFFFFF"),
// invalid IPv4 literals in POSIX/BSD form
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX, "0x100.1.2.3"), // 0x100 is too large
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX, "1.2.3.0x100"),
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX, "127.08.9.1"), // 8, 9 are invalid octals
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX, "127.8.09.1"),
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX, "048"),
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX, ""), // empty
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX, "0x1FFFFFFFF"), // 2^33 - 1 is too large
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX, "0x100000000"), // 2^32 is too large
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX, "040000000000"),
// Empty literals
Arguments.of(InetAddressClass.INET_ADDRESS, ""),
Arguments.of(InetAddressClass.INET4_ADDRESS, ""),
Arguments.of(InetAddressClass.INET6_ADDRESS, ""),
// Blank literals
Arguments.of(InetAddressClass.INET_ADDRESS, " "),
Arguments.of(InetAddressClass.INET4_ADDRESS, " "),
Arguments.of(InetAddressClass.INET6_ADDRESS, " "),
Arguments.of(InetAddressClass.INET4_ADDRESS_POSIX, " ")
);
// Construct arguments for a test case with IPv6-scoped address with scope-id
// specified as a string with non-existing network interface name
String ifName = generateNonExistingIfName();
Stream<Arguments> nonExistingIFinScope = ifName.isBlank() ? Stream.empty() :
Stream.of(Arguments.of(InetAddressClass.INET6_ADDRESS,
"2001:db8:a0b:12f0::1%" + ifName));
return Stream.concat(argumentsStream, nonExistingIFinScope);
}
private static Stream<Arguments> addressToValidTestCases(InetAddress inetAddress) {
String addressLiteral = inetAddress.getHostAddress();
byte[] expectedAddressBytes = inetAddress.getAddress();
InetAddressClass addressClass = switch (inetAddress) {
case Inet4Address i4 -> InetAddressClass.INET4_ADDRESS;
case Inet6Address i6 -> InetAddressClass.INET6_ADDRESS;
case InetAddress ia -> InetAddressClass.INET_ADDRESS;
};
return Stream.of(
Arguments.of(InetAddressClass.INET_ADDRESS, addressLiteral, expectedAddressBytes),
Arguments.of(addressClass, addressLiteral, expectedAddressBytes));
}
private static String generateNonExistingIfName() {
try {
// At least two network interfaces are required to generate
// a non-existing interface name
if (NetworkInterface.networkInterfaces().count() < 2) {
return "";
}
return NetworkInterface
.networkInterfaces()
.map(NetworkInterface::getName)
.collect(Collectors.joining())
.strip();
} catch (SocketException e) {
return "";
}
}
private static Executable constructExecutable(InetAddressClass inetAddressClass, String input) {
return switch (inetAddressClass) {
case INET_ADDRESS -> () -> InetAddress.ofLiteral(input);
case INET4_ADDRESS -> () -> Inet4Address.ofLiteral(input);
case INET4_ADDRESS_POSIX -> () -> Inet4Address.ofPosixLiteral(input);
case INET6_ADDRESS -> () -> Inet6Address.ofLiteral(input);
};
}
enum InetAddressClass {
INET_ADDRESS,
INET4_ADDRESS,
INET4_ADDRESS_POSIX,
INET6_ADDRESS
}
}