/*

 * 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.

 *

 */

/* @test

 * @bug 4287596

 * @summary Unit test for "Pluggable Connectors and Transports" feature.

 *

 * This test checks that VirtualMachineManager creates Connectors that

 * are "compatible" those created by 1.4 or earilier releases.

 */

import com.sun.jdi.*;

import com.sun.jdi.connect.*;

import java.util.*;

public class CompatibleConnectors {

    // number of tests that fail

    static int failures;

    static void fail(String msg) {

        System.out.println(msg + " - test failed.");

        failures++;

    }

    // the AttachingConnectors that we expect

    static Object[][] attachingConnectors() {

        return new Object[][] {

            { "com.sun.jdi.SocketAttach",

              "dt_socket",

              new String[] { "hostname", "Connector.StringArgument", "false" },

              new String[] { "port",     "Connector.IntegerArgument", "true" }

            },

            { "com.sun.jdi.SharedMemoryAttach",

              "dt_shmem",

              new String[] { "name", "Connector.StringArgument", "true" }

            }

        };

    }

    // the ListeningConnectors that we expect

    static Object[][] listeningConnectors() {

        return new Object[][] {

            { "com.sun.jdi.SocketListen",

              "dt_socket",

              new String[] { "port", "Connector.IntegerArgument", "true" }

            },

            { "com.sun.jdi.SharedMemoryListen",

              "dt_shmem",

              new String[] { "name", "Connector.StringArgument", "false" }

            }

        };

    }

    // the LaunchingConnectors that we expect

    // - note that we don't indicate the transport name (as it varies

    // for these connectors)

    static Object[][] launchingConnectors() {

        return new Object[][] {

            { "com.sun.jdi.CommandLineLaunch",

              null,

              new String[] { "home",    "Connector.StringArgument",     "false" },

              new String[] { "options", "Connector.StringArgument",     "false" },

              new String[] { "main",    "Connector.StringArgument",     "true"  },

              new String[] { "suspend", "Connector.BooleanArgument",    "false" },

              new String[] { "quote",   "Connector.StringArgument",     "true"  },

              new String[] { "vmexec",  "Connector.StringArgument",     "true" }

            },

            { "com.sun.jdi.RawCommandLineLaunch",

              null,

              new String[] { "command",  "Connector.StringArgument",     "true" },

              new String[] { "address",  "Connector.StringArgument",     "true" },

              new String[] { "quote",    "Connector.StringArgument",     "true" }

            }

        };

    }

    // find Connector by name, return null if not found

    static Connector find(String name, List l) {

        Iterator i = l.iterator();

        while (i.hasNext()) {

            Connector c = (Connector)i.next();

            if (c.name().equals(name)) {

                return c;

            }

        }

        return null;

    }

    // check that a connector is of the expected type

    static void type_match(String arg_name, String arg_type, Connector.Argument arg) {

        boolean fail = false;

        if (arg_type.equals("Connector.StringArgument")) {

            if (!(arg instanceof Connector.StringArgument)) {

                fail = true;

            }

        }

        if (arg_type.equals("Connector.IntegerArgument")) {

            if (!(arg instanceof Connector.IntegerArgument)) {

                fail = true;

            }

        }

        if (arg_type.equals("Connector.BooleanArgument")) {

            if (!(arg instanceof Connector.BooleanArgument)) {

                fail = true;

            }

        }

        if (arg_type.equals("Connector.SelectedArgument")) {

            if (!(arg instanceof Connector.IntegerArgument)) {

                fail = true;

            }

        }

        if (fail) {

            fail(arg_name + " is of type: " + arg.getClass() + ", expected: "

                 + arg_type);

        }

    }

    // check that a Connector is compatible

    static void check(Object[] desc, Connector connector) {

        String name = (String)desc[0];

        String transport_name = (String)desc[1];

        // if the transport name is "null" it means its transport may

        // vary (eg: SunCommandLineLauncher will choose shared memory

        // on Windows and dt_socket on Solaris). In that case we can't

        // check the transport name.

        //

        if (transport_name != null) {

            System.out.println("Checking transpot name");

            if (!(transport_name.equals(connector.transport().name()))) {

                fail("transport().name() returns: " +

                    connector.transport().name() + ", expected: " + transport_name);

            }

        }

        // check that all the old arguments still exist

        for (int i=2; i<desc.length; i++) {

            String[] args = (String[])desc[i];

            String arg_name = args[0];

            String arg_type = args[1];

            String arg_mandatory = args[2];

            System.out.println("Checking argument: " + arg_name);

            // check that the arg still exists

            Map defaultArgs = connector.defaultArguments();

            Object value = defaultArgs.get(arg_name);

            if (value == null) {

                fail(name + " is missing Connector.Argument: " + arg_name);

                continue;

            }

            // next check that the type matches

            Connector.Argument connector_arg = (Connector.Argument)value;

            // check that the argument type hasn't changed

            type_match(arg_name, arg_type, connector_arg);

            // check that an optional argument has been made mandatory

            if (arg_mandatory.equals("false")) {

                if (connector_arg.mustSpecify()) {

                    fail(arg_name + " is now mandatory");

                }

            }

        }

        // next we check for new arguments that are mandatory but

        // have no default value

        System.out.println("Checking for new arguments");

        Map dfltArgs = connector.defaultArguments();

        Iterator iter = dfltArgs.keySet().iterator();

        while (iter.hasNext()) {

            String arg_name = (String)iter.next();

            // see if the argument is new

            boolean found = false;

            for (int j=2; j<desc.length; j++) {

                String[] args = (String[])desc[j];

                if (args[0].equals(arg_name)) {

                    found = true;

                    break;

                }

            }

            if (!found) {

                Connector.Argument connector_arg =

                    (Connector.Argument)dfltArgs.get(arg_name);

                if (connector_arg.mustSpecify()) {

                    String value = connector_arg.value();

                    if (value.equals("")) {

                        value = null;

                    }

                    if (value == null) {

                        fail("New Connector.Argument \"" + connector_arg.name() +

                            "\" added - argument is mandatory");

                    }

                }

            }

        }

    }

    // compare the actual list of Connectors against the

    // expected list of Connectors.

    static void compare(Object[][] prev, List list) {

        String os = System.getProperty("os.name");

        for (int i=0; i<prev.length; i++) {

            Object[] desc = prev[i];

            String name = (String)desc[0];

            // ignore Windows specific Connectors are non-Windows machines

            if (!(os.startsWith("Windows"))) {

                if (name.equals("com.sun.jdi.SharedMemoryAttach") ||

                    name.equals("com.sun.jdi.SharedMemoryListen")) {

                    continue;

                }

            }

            System.out.println("");

            System.out.println("Checking Connector " + name);

            // check that the Connector exists

            Connector c = find(name, list);

            if (c == null) {

                fail("Connector is missing");

                continue;

            }

            check(desc, c);

        }

    }

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

        VirtualMachineManager vmm = Bootstrap.virtualMachineManager();

        // in 1.2/1.3/1.4 the defualtConnector was

        // com.sun.jdi.CommandLineLaunch. Many debuggers probably

        // depend on this so check that it's always the default.

        //

        String expected = "com.sun.jdi.CommandLineLaunch";

        System.out.println("Checking that defaultConnector is: " + expected);

        String dflt = vmm.defaultConnector().name();

        if (!(dflt.equals(expected))) {

            System.err.println("defaultConnector() is: " + dflt +

                ", expected:" + expected);

            failures++;

        } else {

            System.out.println("Okay");

        }

        compare(attachingConnectors(), vmm.attachingConnectors());

        compare(listeningConnectors(), vmm.listeningConnectors());

        compare(launchingConnectors(), vmm.launchingConnectors());

        // test results

        if (failures > 0) {

            System.out.println("");

            throw new RuntimeException(failures + " test(s) failed");

        }

    }

}