| /* |
| * 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 |
