291 lines
10 KiB
Java
291 lines
10 KiB
Java
/*
|
|
* 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");
|
|
}
|
|
}
|
|
}
|