| /* | |
| * Copyright (c) 2003, 2015, 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 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"); | |
| } | |
| } | |
| } |