test/jdk/java/net/BindException/Test.java

/*
 * Copyright (c) 2001, 2019, 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 4417734
 * @key intermittent
 * @summary Test that we get a BindException in all expected combinations
 * @library /test/lib
 * @build jdk.test.lib.NetworkConfiguration
 *        jdk.test.lib.Platform
 * @run main Test -d
 */

import java.net.*;
import java.util.Enumeration;
import jdk.test.lib.NetworkConfiguration;

public class Test {

    static Object[][] getTestCombinations() {
        return new Object[][]  {
            { "ServerSocket",   "Socket" },
            { "Socket",         "Socket" },
            { "DatagramSocket", "DatagramSocket" },
        };
    }

    static InetAddress ia4_this;
    static InetAddress ia6_this;

    static int count;
    static int failures;
    static boolean retried;

    static void doTest(Object test[], InetAddress ia1, InetAddress ia2,
                       boolean silent) throws Exception {
        /*
         * Increment test count
         */
        count++;

        doTest(test, count, ia1, ia2, silent, !retried);
    }

    static void doTest(Object test[], int count, InetAddress ia1, InetAddress ia2,
                       boolean silent, boolean retry) throws Exception {
        String s1_type = (String)test[0];
        String s2_type = (String)test[1];
        int port = 0;

        /*
         * Do the test
         */

        boolean gotBindException = false;
        boolean failed = false;
        Exception failed_exc = null;

        Socket sock1 = null;
        ServerSocket ss = null;
        DatagramSocket dsock1 = null;
        boolean firstBound = false;

        try {
            /* bind the first socket */

            if (s1_type.equals("Socket")) {
                sock1 = new Socket();
                sock1.bind( new InetSocketAddress(ia1, 0));
                port = sock1.getLocalPort();
            }

            if (s1_type.equals("ServerSocket")) {
                ss = new ServerSocket(0, 0, ia1);
                port = ss.getLocalPort();
            }

            if (s1_type.equals("DatagramSocket")) {
                dsock1 = new DatagramSocket( new InetSocketAddress(ia1, 0) );
                port = dsock1.getLocalPort();
            }

            /* bind the second socket */

            // The fact that the port was available for ia1 does not
            // guarantee that it will also be available for ia2 as something
            // else might already be bound to that port.
            // For the sake of test stability we will retry once in
            // case of unexpected bind exception.

            firstBound = true;
            if (s2_type.equals("Socket")) {
                try (Socket sock2 = new Socket()) {
                    sock2.bind( new InetSocketAddress(ia2, port));
                }
            }

            if (s2_type.equals("ServerSocket")) {
                try (ServerSocket ss2 = new ServerSocket(port, 0, ia2)) { }
            }

            if (s2_type.equals("DatagramSocket")) {
                try (DatagramSocket ds =
                        new DatagramSocket(new InetSocketAddress(ia2, port))) { }
            }

        } catch (BindException be) {
            gotBindException = true;
            failed_exc = be;
        } catch (Exception e) {
            failed = true;
            failed_exc = e;
        } finally {
            if (sock1 != null) sock1.close();
            if (ss != null) ss.close();
            if (dsock1 != null) dsock1.close();
        }

        /*
         * Did we expect a BindException?
         */
        boolean expectedBindException = true;
        if (ia1 == ia4_this && ia2 == ia6_this) {
            expectedBindException = false;
        }
        if (ia1 == ia6_this && ia2 == ia4_this) {
            expectedBindException = false;
        }

        /*
         * Did it fail?
         */

        if (!failed && gotBindException != expectedBindException) {
            failed = true;
        }

        /*
         * If test passed and running in silent mode then exit
         */
        if (!failed && silent) {
            return;
        }

        if (failed && retry && firstBound) {
            // retry once at the first failure only
            retried = true;
            if (!silent) {
                System.out.println("");
                System.out.println("**************************");
                System.out.println("Test " + count + ": Retrying...");
            }
            doTest(test, count, ia1, ia2, silent, false);
            return;
        }

        if (failed || !silent) {
            System.out.println("");
            System.out.println("**************************");
            System.out.println("Test " + count);

            System.out.println(s1_type + " binds: " + ia1 + " port: " + port);
            System.out.println(s2_type + " binds: " + ia2);

            if (!failed) {
                if (gotBindException) {
                    System.out.println("Got expected BindException - test passed!");
                    failed_exc.printStackTrace(System.out);
                } else {
                    System.out.println("No BindException as expected - test passed!");
                }
                return;
            }
        }
        if (gotBindException) {
            System.out.println("BindException unexpected - test failed!!!");
            failed_exc.printStackTrace(System.out);
        } else {
            System.out.println("No bind failure as expected - test failed!!!");
        }
        failures++;
    }

    public static void main(String args[]) throws Exception {

        boolean silent = true;
        if (args.length > 0) {
            if (args[0].equals("-d")) {
                silent = false;
            }
        }

        /*
         * Test needs an IPv4 and IPv6 address to run.
         */
        Enumeration nifs = NetworkInterface.getNetworkInterfaces();
        while (nifs.hasMoreElements()) {
            NetworkInterface ni = (NetworkInterface)nifs.nextElement();

            Enumeration addrs = ni.getInetAddresses();
            while (addrs.hasMoreElements()) {
                InetAddress ia = (InetAddress)addrs.nextElement();

                if (ia.isLoopbackAddress() || ia.isAnyLocalAddress()) {
                    continue;
                }

                if ((ia instanceof Inet4Address) && (ia4_this == null)) {
                    ia4_this = ia;
                }

                if ((ia instanceof Inet6Address) && (ia6_this == null)) {
                    ia6_this = ia;
                }
            }
        }

        /*
         * Perform tests on all combinations of IPv4 and IPv6
         * addresses.
         */
        InetAddress addrs[] = { ia4_this, ia6_this };

        if (!silent) {
            System.out.println("Using ia4_this:" + ia4_this);
            System.out.println("Using ia6_this:" + ia6_this);
        }

        Object tests[][] = getTestCombinations();

        for (int i=0; i<tests.length; i++) {
            Object test[] = tests[i];

            for (int j=0; j<addrs.length; j++) {
                for (int k=0; k<addrs.length; k++) {

                    if (addrs[j] == null || addrs[k] == null) {
                        continue;
                    }

                    doTest( test, addrs[j], addrs[k], silent);
                }
            }
        }

        System.out.println("");
        System.out.println(count + " test(s) executed. " + failures + " failure(s).");

        if (failures > 0) {
            System.err.println("********************************");
            NetworkConfiguration.printSystemConfiguration(System.err);
            System.out.println("********************************");
            throw new Exception(failures + " tests(s) failed - see log");
        }
    }
}