597 lines
23 KiB
Java
597 lines
23 KiB
Java
/*
|
|
* Copyright (c) 2003, 2018, 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.
|
|
*/
|
|
|
|
/*
|
|
* A Super class for pluggable connectors used by
|
|
* nsk/jdi/PlugConnectors tests
|
|
*/
|
|
|
|
package nsk.share.jdi;
|
|
|
|
import com.sun.jdi.*;
|
|
import com.sun.jdi.connect.*;
|
|
import java.io.*;
|
|
import java.util.*;
|
|
|
|
public class PlugConnectors implements Connector {
|
|
|
|
String plugConnectorName = "Undefined_PlugConnector_Name";
|
|
String plugConnectorDescription = "Undefined_PlugConnector_Description";
|
|
Transport plugConnectorTransport = new PlugConnectorsTransport();
|
|
Map<java.lang.String,com.sun.jdi.connect.Connector.Argument> plugConnectorDefaultArguments = new HashMap<java.lang.String,com.sun.jdi.connect.Connector.Argument>();
|
|
|
|
/*
|
|
* Simple implementation of Connector.Argument
|
|
*/
|
|
public static class TestArgument implements Connector.Argument {
|
|
String argName;
|
|
String argLabel;
|
|
String argDescription;
|
|
String argStringValue;
|
|
boolean argMustSpecify;
|
|
|
|
public TestArgument(
|
|
String argName,
|
|
String argLabel,
|
|
String argDescription,
|
|
String argValue,
|
|
boolean argMustSpecify) {
|
|
|
|
this.argName = argName;
|
|
this.argLabel = argLabel;
|
|
this.argDescription = argDescription;
|
|
this.argStringValue = argValue;
|
|
this.argMustSpecify = argMustSpecify;
|
|
}
|
|
|
|
public String name() {
|
|
return argName;
|
|
}
|
|
|
|
public String label() {
|
|
return argLabel;
|
|
}
|
|
|
|
public String description() {
|
|
return argDescription;
|
|
}
|
|
|
|
public String value() {
|
|
return argStringValue;
|
|
}
|
|
|
|
public void setValue(String argValue) {
|
|
this.argStringValue = argValue;
|
|
}
|
|
|
|
public boolean isValid(String argValue) {
|
|
if ( argValue != null ) {
|
|
if (argValue.length() > 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean mustSpecify() {
|
|
return argMustSpecify;
|
|
}
|
|
} // end of TestArgument static class
|
|
|
|
/*
|
|
* Simple implementation of Connector.StringArgument
|
|
*/
|
|
public static class TestStringArgument extends TestArgument implements Connector.StringArgument {
|
|
|
|
public TestStringArgument( String argName,
|
|
String argLabel,
|
|
String argDescription,
|
|
String argValue,
|
|
boolean argMustSpecify) {
|
|
|
|
super(argName, argLabel, argDescription, argValue, argMustSpecify);
|
|
}
|
|
|
|
} // end of TestStringArgument static class
|
|
|
|
/*
|
|
* Simple implementation of Connector.IntegerArgument
|
|
*/
|
|
public static class TestIntegerArgument extends TestArgument implements Connector.IntegerArgument {
|
|
|
|
int argIntValue;
|
|
int minArgIntValue;
|
|
int maxArgIntValue;
|
|
|
|
public TestIntegerArgument(String argName,
|
|
String argLabel,
|
|
String argDescription,
|
|
int argValue,
|
|
int minArgIntValue,
|
|
int maxArgIntValue,
|
|
boolean argMustSpecify) {
|
|
|
|
super(argName, argLabel, argDescription, "" + argValue, argMustSpecify);
|
|
this.argIntValue = argValue;
|
|
this.minArgIntValue = minArgIntValue;
|
|
this.maxArgIntValue = maxArgIntValue;
|
|
|
|
}
|
|
|
|
public int intValue() {
|
|
return argIntValue;
|
|
}
|
|
|
|
public boolean isValid(int value) {
|
|
if ( value >= minArgIntValue && value <= maxArgIntValue ) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isValid(String stringValue) {
|
|
int intValue;
|
|
try {
|
|
intValue = Integer.parseInt(stringValue);
|
|
} catch (NumberFormatException exception) {
|
|
return false;
|
|
}
|
|
return isValid(intValue);
|
|
}
|
|
|
|
public int max() {
|
|
return maxArgIntValue;
|
|
}
|
|
|
|
public int min() {
|
|
return minArgIntValue;
|
|
}
|
|
|
|
public void setValue(int value) {
|
|
argIntValue = value;
|
|
}
|
|
|
|
public String stringValueOf(int value) {
|
|
return "" + value;
|
|
}
|
|
|
|
} // end of TestIntegerArgument static class
|
|
|
|
/*
|
|
* Simple implementation of Connector.BooleanArgument
|
|
*/
|
|
public static class TestBooleanArgument extends TestArgument implements Connector.BooleanArgument {
|
|
|
|
static final String argStringValueTrue = "true";
|
|
static final String argStringValueFalse = "false";
|
|
boolean argBooleanValue;
|
|
|
|
public TestBooleanArgument(String argName,
|
|
String argLabel,
|
|
String argDescription,
|
|
boolean argValue,
|
|
boolean argMustSpecify) {
|
|
|
|
super(argName, argLabel, argDescription,
|
|
argValue ? argStringValueTrue : argStringValueFalse,
|
|
argMustSpecify);
|
|
this.argBooleanValue = argValue;
|
|
|
|
}
|
|
|
|
public boolean booleanValue() {
|
|
return argBooleanValue;
|
|
}
|
|
|
|
public boolean isValid(String stringValue) {
|
|
if ( argStringValueTrue.equals(stringValue) || argStringValueFalse.equals(stringValue) ) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void setValue(boolean value) {
|
|
argBooleanValue = value;
|
|
}
|
|
|
|
public String stringValueOf(boolean value) {
|
|
if ( value ) {
|
|
return argStringValueTrue;
|
|
}
|
|
return argStringValueFalse;
|
|
}
|
|
|
|
} // end of TestBooleanArgument static class
|
|
|
|
/*
|
|
* Simple implementation of Connector.SelectedArgument
|
|
*/
|
|
public static class TestSelectedArgument extends TestArgument implements Connector.SelectedArgument {
|
|
|
|
List<String> acceptableArgsList;
|
|
|
|
public TestSelectedArgument( String argName,
|
|
String argLabel,
|
|
String argDescription,
|
|
String argValue,
|
|
List<String> acceptableArgsList,
|
|
boolean argMustSpecify) {
|
|
|
|
super(argName, argLabel, argDescription, argValue, argMustSpecify);
|
|
this.acceptableArgsList = acceptableArgsList;
|
|
}
|
|
|
|
public List<String> choices() {
|
|
return acceptableArgsList;
|
|
}
|
|
|
|
public boolean isValid(String stringValue) {
|
|
|
|
return acceptableArgsList.contains(stringValue);
|
|
}
|
|
|
|
} // end of TestSelectedArgument static class
|
|
|
|
public PlugConnectors(
|
|
String plugConnectorName,
|
|
String plugConnectorDescription,
|
|
Transport plugConnectorTransport,
|
|
Map<java.lang.String,com.sun.jdi.connect.Connector.Argument> plugConnectorDefaultArguments
|
|
) {
|
|
|
|
this.plugConnectorName = plugConnectorName;
|
|
this.plugConnectorDescription = plugConnectorDescription;
|
|
this.plugConnectorTransport = plugConnectorTransport;
|
|
this.plugConnectorDefaultArguments = plugConnectorDefaultArguments;
|
|
}
|
|
|
|
public String name() {
|
|
return plugConnectorName;
|
|
}
|
|
|
|
public String description() {
|
|
return plugConnectorDescription;
|
|
}
|
|
|
|
public Transport transport() {
|
|
return plugConnectorTransport;
|
|
}
|
|
|
|
public Map<java.lang.String,com.sun.jdi.connect.Connector.Argument> defaultArguments() {
|
|
return plugConnectorDefaultArguments;
|
|
}
|
|
|
|
public VirtualMachine launch(Map<String,? extends Connector.Argument> arguments) throws
|
|
IOException,
|
|
IllegalConnectorArgumentsException,
|
|
VMStartException {
|
|
|
|
String exceptionMessage = "## PlugConnectors: Connector name = '" +
|
|
plugConnectorName + "';\nNon-authorized call of launch(...) method!";
|
|
|
|
if ( true ) {
|
|
throw new RuntimeException(exceptionMessage);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public VirtualMachine attach(Map<String,? extends Connector.Argument> arguments) throws
|
|
java.io.IOException,
|
|
IllegalConnectorArgumentsException {
|
|
|
|
String exceptionMessage = "## PlugConnectors: Connector name = '" +
|
|
plugConnectorName + "';\nNon-authorized call of attach(...) method!";
|
|
|
|
if ( true ) {
|
|
throw new RuntimeException(exceptionMessage);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public String startListening(Map<String,? extends Connector.Argument> arguments) throws
|
|
java.io.IOException,
|
|
IllegalConnectorArgumentsException {
|
|
|
|
String exceptionMessage = "## PlugConnectors: Connector name = '" +
|
|
plugConnectorName + "';\nNon-authorized call of startListening(...) method!";
|
|
|
|
if ( true ) {
|
|
throw new RuntimeException(exceptionMessage);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public void stopListening(Map<String,? extends Connector.Argument> arguments) throws
|
|
java.io.IOException,
|
|
IllegalConnectorArgumentsException {
|
|
|
|
String exceptionMessage = "## PlugConnectors: Connector name = '" +
|
|
plugConnectorName + "';\nNon-authorized call of stopListening(...) method!";
|
|
|
|
if ( true ) {
|
|
throw new RuntimeException(exceptionMessage);
|
|
}
|
|
}
|
|
|
|
public VirtualMachine accept(Map<String,? extends Connector.Argument> arguments) throws
|
|
java.io.IOException,
|
|
IllegalConnectorArgumentsException {
|
|
|
|
String exceptionMessage = "## PlugConnectors: Connector name = '" +
|
|
plugConnectorName + "';\nNon-authorized call of accept(...) method!";
|
|
|
|
if ( true ) {
|
|
throw new RuntimeException(exceptionMessage);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public boolean supportsMultipleConnections() {
|
|
|
|
String exceptionMessage = "## PlugConnectors: Connector name = '" +
|
|
plugConnectorName + "';\nNon-authorized call of supportsMultipleConnections() method!";
|
|
|
|
if ( true ) {
|
|
throw new RuntimeException(exceptionMessage);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static class PlugConnectorsTransport implements Transport {
|
|
|
|
String transportName = "Undefined_Transport_Name";
|
|
|
|
public PlugConnectorsTransport() {
|
|
}
|
|
|
|
public PlugConnectorsTransport(String transportName) {
|
|
this.transportName = transportName;
|
|
}
|
|
|
|
public String name() {
|
|
return transportName;
|
|
}
|
|
|
|
} // end of PlugConnectorsTransport class
|
|
|
|
// Auxiliary general purpose methods for pluggable connectors' tests.
|
|
|
|
public static String compareConnectors(
|
|
String errorLogPrefixHead,
|
|
String errorLogPrefix,
|
|
Connector referenceConnector,
|
|
Connector checkedConnector) {
|
|
|
|
String emptyString = "";
|
|
String errorMessage = emptyString;
|
|
|
|
// check that connectors have the same name
|
|
String referenceConnectorName = referenceConnector.name();
|
|
String checkedConnectorName = checkedConnector.name();
|
|
if ( ! referenceConnectorName.equals(checkedConnectorName) ) {
|
|
errorMessage = errorMessage +
|
|
errorLogPrefixHead + "Checked pluggable Connector has unexpected name:\n"
|
|
+ errorLogPrefix + "Expected Connector's name = '" + referenceConnectorName + "'\n"
|
|
+ errorLogPrefix + "Actual Connector's name = '" + checkedConnectorName + "'\n";
|
|
}
|
|
|
|
// check that connectors have the same description
|
|
String referenceConnectorDescription = referenceConnector.description();
|
|
String checkedConnectorDescription = checkedConnector.description();
|
|
if ( ! referenceConnectorDescription.equals(checkedConnectorDescription) ) {
|
|
errorMessage = errorMessage +
|
|
errorLogPrefixHead + "Checked pluggable Connector has unexpected description:\n"
|
|
+ errorLogPrefix + "Expected Connector's description = '" + referenceConnectorDescription + "'\n"
|
|
+ errorLogPrefix + "Actual Connector's description = '" + checkedConnectorDescription + "'\n";
|
|
}
|
|
|
|
// check that connectors have the same transport name
|
|
String referenceConnectorTransportName = referenceConnector.transport().name();
|
|
String checkedConnectorTransportName = checkedConnector.transport().name();
|
|
if ( ! referenceConnectorTransportName.equals(checkedConnectorTransportName) ) {
|
|
errorMessage = errorMessage +
|
|
errorLogPrefixHead + "Checked pluggable Connector has unexpected transport name:\n"
|
|
+ errorLogPrefix + "Expected Connector's transport name = '" + referenceConnectorTransportName + "'\n"
|
|
+ errorLogPrefix + "Actual Connector's transport name = '" + checkedConnectorTransportName + "'\n";
|
|
}
|
|
|
|
// check that connectors have the same number of default arguments
|
|
int referenceConnectorArgumentsNumber = referenceConnector.defaultArguments().size();
|
|
int checkedConnectorArgumentsNumber = checkedConnector.defaultArguments().size();
|
|
if ( referenceConnectorArgumentsNumber != checkedConnectorArgumentsNumber ) {
|
|
errorMessage = errorMessage +
|
|
errorLogPrefixHead + "Checked pluggable Connector has unexpected number of default arguments:\n"
|
|
+ errorLogPrefix + "Expected number of default arguments = '" + referenceConnectorArgumentsNumber + "'\n"
|
|
+ errorLogPrefix + "Actual number of default arguments = '" + checkedConnectorArgumentsNumber + "'\n";
|
|
}
|
|
|
|
|
|
return errorMessage;
|
|
} // end of compareConnectors(...) method
|
|
|
|
public static String compareConnectorArguments(
|
|
String errorLogPrefixHead,
|
|
String errorLogPrefix,
|
|
Connector.Argument referenceArgument,
|
|
Connector.Argument checkedArgument) {
|
|
|
|
String emptyString = "";
|
|
String errorMessage = emptyString;
|
|
|
|
if ( referenceArgument == null ) {
|
|
errorMessage =
|
|
errorLogPrefixHead + "Reference connector's argument is null!\n";
|
|
}
|
|
|
|
if ( checkedArgument == null ) {
|
|
errorMessage = errorMessage +
|
|
errorLogPrefixHead + "Checked connector's argument is null!\n";
|
|
}
|
|
|
|
if ( ! errorMessage.equals(emptyString) ) {
|
|
return errorMessage;
|
|
}
|
|
|
|
String referenceArgumentName = referenceArgument.name();
|
|
String checkedArgumentName = checkedArgument.name();
|
|
if ( ! referenceArgumentName.equals(checkedArgumentName) ) {
|
|
errorMessage =
|
|
errorLogPrefixHead + "Checked connector's argument has unexpected name:\n"
|
|
+ errorLogPrefix + "Expected connector's argument name = '" + referenceArgumentName + "'\n"
|
|
+ errorLogPrefix + "Actual connector's argument name = '" + checkedArgumentName + "'";
|
|
return errorMessage;
|
|
}
|
|
|
|
String referenceArgumentLabel = referenceArgument.label();
|
|
String checkedArgumentLabel = checkedArgument.label();
|
|
if ( ! referenceArgumentLabel.equals(checkedArgumentLabel) ) {
|
|
errorMessage =
|
|
errorLogPrefixHead + "Checked connector's argument has unexpected label:\n"
|
|
+ errorLogPrefix + "Expected connector's argument label = '" + referenceArgumentLabel + "'\n"
|
|
+ errorLogPrefix + "Actual connector's argument label = '" + checkedArgumentLabel + "'";
|
|
return errorMessage;
|
|
}
|
|
|
|
String referenceArgumentDescription = referenceArgument.description();
|
|
String checkedArgumentDescription = checkedArgument.description();
|
|
if ( ! referenceArgumentDescription.equals(checkedArgumentDescription) ) {
|
|
errorMessage =
|
|
errorLogPrefixHead + "Checked connector's argument has unexpected description:\n"
|
|
+ errorLogPrefix + "Expected connector's argument description = '" + referenceArgumentDescription + "'\n"
|
|
+ errorLogPrefix + "Actual connector's argument description = '" + checkedArgumentDescription + "'";
|
|
return errorMessage;
|
|
}
|
|
|
|
String referenceArgumentValue = referenceArgument.value();
|
|
String checkedArgumentValue = checkedArgument.value();
|
|
if ( ! referenceArgumentValue.equals(checkedArgumentValue) ) {
|
|
errorMessage =
|
|
errorLogPrefixHead + "Checked connector's argument has unexpected value:\n"
|
|
+ errorLogPrefix + "Expected connector's argument value = '" + referenceArgumentValue + "'\n"
|
|
+ errorLogPrefix + "Actual connector's argument value = '" + checkedArgumentValue + "'";
|
|
return errorMessage;
|
|
}
|
|
|
|
boolean referenceArgumentMustSpecify = referenceArgument.mustSpecify();
|
|
boolean checkedArgumentMustSpecify = checkedArgument.mustSpecify();
|
|
if ( referenceArgumentMustSpecify != checkedArgumentMustSpecify ) {
|
|
errorMessage =
|
|
errorLogPrefixHead + "Checked connector's argument has unexpected 'mustSpecify' property:\n"
|
|
+ errorLogPrefix + "Expected connector's argument 'mustSpecify' property = '"
|
|
+ referenceArgumentMustSpecify + "'\n"
|
|
+ errorLogPrefix + "Actual connector's argument 'mustSpecify' property = '"
|
|
+ checkedArgumentMustSpecify + "'";
|
|
return errorMessage;
|
|
}
|
|
|
|
if ( referenceArgument instanceof Connector.IntegerArgument ) {
|
|
|
|
int referenceArgumentMin = ((Connector.IntegerArgument)referenceArgument).min();
|
|
int checkedArgumentMin = ((Connector.IntegerArgument)checkedArgument).min();
|
|
if ( referenceArgumentMin != checkedArgumentMin ) {
|
|
errorMessage =
|
|
errorLogPrefixHead + "Checked connector's integer argument has unexpected min value:\n"
|
|
+ errorLogPrefix + "Expected connector's argument min value = "
|
|
+ referenceArgumentMin + "\n"
|
|
+ errorLogPrefix + "Actual connector's argument min value = "
|
|
+ checkedArgumentMin + "\n";
|
|
}
|
|
|
|
int referenceArgumentMax = ((Connector.IntegerArgument)referenceArgument).max();
|
|
int checkedArgumentMax = ((Connector.IntegerArgument)checkedArgument).max();
|
|
if ( referenceArgumentMax != checkedArgumentMax ) {
|
|
errorMessage = errorMessage +
|
|
errorLogPrefixHead + "Checked connector's integer argument has unexpected max value:\n"
|
|
+ errorLogPrefix + "Expected connector's argument max value = "
|
|
+ referenceArgumentMax + "\n"
|
|
+ errorLogPrefix + "Actual connector's argument max value = "
|
|
+ checkedArgumentMax + "\n";
|
|
}
|
|
|
|
}
|
|
|
|
if ( referenceArgument instanceof Connector.SelectedArgument ) {
|
|
|
|
List referenceArgumentChoices = ((Connector.SelectedArgument)referenceArgument).choices();
|
|
List checkedArgumentChoices = ((Connector.SelectedArgument)checkedArgument).choices();
|
|
|
|
int referenceArgumentChoicesSize = referenceArgumentChoices.size();
|
|
int checkedArgumentChoicesSize = checkedArgumentChoices.size();
|
|
|
|
if ( referenceArgumentChoicesSize != checkedArgumentChoicesSize) {
|
|
errorMessage = errorMessage +
|
|
errorLogPrefixHead + "Checked connector's Selected argument has unexpected choices' size:\n"
|
|
+ errorLogPrefix + "Expected size = '"
|
|
+ referenceArgumentChoicesSize + "'\n"
|
|
+ errorLogPrefix + "Actual size = "
|
|
+ checkedArgumentChoicesSize;
|
|
return errorMessage;
|
|
}
|
|
|
|
for (int i=0; i < referenceArgumentChoicesSize; i++) {
|
|
String referenceArgumentChoice = (String)(referenceArgumentChoices.get(i));
|
|
if ( ! checkedArgumentChoices.contains(referenceArgumentChoice) ) {
|
|
errorMessage = errorMessage +
|
|
errorLogPrefixHead + "Checked connector's Selected argument has NOT expected choices' element:\n"
|
|
+ errorLogPrefix + "Expected choices' element = '"
|
|
+ referenceArgumentChoice + "'\n";
|
|
}
|
|
|
|
String checkedArgumentChoice = (String)(checkedArgumentChoices.get(i));
|
|
if ( ! referenceArgumentChoices.contains(checkedArgumentChoice) ) {
|
|
errorMessage = errorMessage +
|
|
errorLogPrefixHead + "Checked connector's Selected argument has unexpected choices' element:\n"
|
|
+ errorLogPrefix + "Unexpected choices' element = '"
|
|
+ checkedArgumentChoice + "'\n";
|
|
}
|
|
}
|
|
}
|
|
return errorMessage;
|
|
} // end of compareConnectorArguments(...) method
|
|
|
|
public static Connector.Argument getConnectorDefaultArgument(
|
|
Connector connector,
|
|
String argumentName) {
|
|
|
|
Connector.Argument foundArgument = null;
|
|
|
|
Map connectorDefaultArguments = connector.defaultArguments();
|
|
Object[] defaultArgumentsArray = connectorDefaultArguments.values().toArray();
|
|
|
|
for (int i=0; i < defaultArgumentsArray.length; i++) {
|
|
Connector.Argument connectorArgument = (Connector.Argument)defaultArgumentsArray[i];
|
|
if ( argumentName.equals(connectorArgument.name()) ) {
|
|
foundArgument = connectorArgument;
|
|
break;
|
|
}
|
|
}
|
|
return foundArgument;
|
|
}
|
|
|
|
} // end of PlugConnectors class
|