--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/com/sun/jdi/CompatibleConnectors.java Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,290 @@
+/*
+ * 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");
+ }
+ }
+}