/*
 * 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
 * @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")
        );
        // 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
    }
}