jdk/test/com/sun/jdi/CompatibleConnectors.java

/*
 * Copyright 2003-2004 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */

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