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