diff options
Diffstat (limited to 'test/tools/launcher/Arrrghs.java')
| -rw-r--r-- | test/tools/launcher/Arrrghs.java | 245 |
1 files changed, 182 insertions, 63 deletions
diff --git a/test/tools/launcher/Arrrghs.java b/test/tools/launcher/Arrrghs.java index 34bfcee36..6b14abe50 100644 --- a/test/tools/launcher/Arrrghs.java +++ b/test/tools/launcher/Arrrghs.java @@ -21,57 +21,47 @@ * have any questions. */ +/** + * @test + * @compile -XDignore.symbol.file Arrrghs.java TestHelper.java + * @bug 5030233 6214916 6356475 6571029 6684582 + * @run main Arrrghs + * @summary Argument parsing validation. + */ + import java.io.BufferedReader; import java.io.File; +import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; import java.util.Map; -import java.util.StringTokenizer; public class Arrrghs { - + private Arrrghs(){} /** + * This class provides various tests for arguments processing. * A group of tests to ensure that arguments are passed correctly to * a child java process upon a re-exec, this typically happens when * a version other than the one being executed is requested by the user. * * History: these set of tests were part of Arrrghs.sh. The MKS shell - * implementations are notoriously buggy. Implementing these tests purely + * implementations were notoriously buggy. Implementing these tests purely * in Java is not only portable but also robust. * */ - /* Do not instantiate */ - private Arrrghs() {} - - static String javaCmd; - // The version string to force a re-exec final static String VersionStr = "-version:1.1+"; // The Cookie or the pattern we match in the debug output. final static String Cookie = "ReExec Args: "; - private static boolean _debug = Boolean.getBoolean("Arrrghs.Debug"); - private static boolean isWindows = System.getProperty("os.name", "unknown").startsWith("Windows"); - private static int exitValue = 0; - - private static void doUsage(String message) { - if (message != null) System.out.println("Error: " + message); - System.out.println("Usage: Arrrghs path_to_java"); - System.exit(1); - } - /* * SIGH, On Windows all strings are quoted, we need to unwrap it */ private static String removeExtraQuotes(String in) { - if (isWindows) { + if (TestHelper.isWindows) { // Trim the string and remove the enclosed quotes if any. in = in.trim(); if (in.startsWith("\"") && in.endsWith("\"")) { @@ -81,27 +71,29 @@ public class Arrrghs { return in; } - /* * This method detects the cookie in the output stream of the process. */ - private static boolean detectCookie(InputStream istream, String expectedArguments) throws IOException { + private static boolean detectCookie(InputStream istream, + String expectedArguments) throws IOException { BufferedReader rd = new BufferedReader(new InputStreamReader(istream)); boolean retval = false; String in = rd.readLine(); while (in != null) { - if (_debug) System.out.println(in); + if (TestHelper.debug) System.out.println(in); if (in.startsWith(Cookie)) { String detectedArgument = removeExtraQuotes(in.substring(Cookie.length())); if (expectedArguments.equals(detectedArgument)) { retval = true; } else { - System.out.println("Error: Expected Arguments\t:'" + expectedArguments + "'"); - System.out.println(" Detected Arguments\t:'" + detectedArgument + "'"); + System.out.println("Error: Expected Arguments\t:'" + + expectedArguments + "'"); + System.out.println(" Detected Arguments\t:'" + + detectedArgument + "'"); } // Return the value asap if not in debug mode. - if (!_debug) { + if (!TestHelper.debug) { rd.close(); istream.close(); return retval; @@ -112,7 +104,7 @@ public class Arrrghs { return retval; } - private static boolean doExec0(ProcessBuilder pb, String expectedArguments) { + private static boolean doTest0(ProcessBuilder pb, String expectedArguments) { boolean retval = false; try { pb.redirectErrorStream(true); @@ -131,72 +123,199 @@ public class Arrrghs { * This method return true if the expected and detected arguments are the same. * Quoting could cause dissimilar testArguments and expected arguments. */ - static boolean doExec(String testArguments, String expectedPattern) { - ProcessBuilder pb = new ProcessBuilder(javaCmd, VersionStr, testArguments); + static int doTest(String testArguments, String expectedPattern) { + ProcessBuilder pb = new ProcessBuilder(TestHelper.javaCmd, + VersionStr, testArguments); Map<String, String> env = pb.environment(); env.put("_JAVA_LAUNCHER_DEBUG", "true"); - return doExec0(pb, testArguments); + return doTest0(pb, testArguments) ? 0 : 1; } /** * A convenience method for identical test pattern and expected arguments */ - static boolean doExec(String testPattern) { - return doExec(testPattern, testPattern); + static int doTest(String testPattern) { + return doTest(testPattern, testPattern); } - /** - * @param args the command line arguments - */ - public static void main(String[] args) { - if (args.length < 1 && args[0] == null) { - doUsage("Invalid number of arguments"); - } - - javaCmd = args[0]; - - if (!new File(javaCmd).canExecute()) { - if (isWindows && new File(javaCmd + ".exe").canExecute()) { - javaCmd = javaCmd + ".exe"; - } else { - doUsage("The java executable must exist"); - } + static void quoteParsingTests() { + /* + * Tests for 6214916 + * These tests require that a JVM (any JVM) be installed in the system registry. + * If none is installed, skip this test. + */ + TestHelper.TestResult tr = + TestHelper.doExec(TestHelper.javaCmd, VersionStr, "-version"); + if (!tr.isOK()) { + System.err.println("Warning:Argument Passing Tests were skipped, " + + "no java found in system registry."); + return; } - if (_debug) System.out.println("Starting Arrrghs tests"); // Basic test - if (!doExec("-a -b -c -d")) exitValue++; + TestHelper.testExitValue += doTest("-a -b -c -d"); // Basic test with many spaces - if (!doExec("-a -b -c -d")) exitValue++; + TestHelper.testExitValue += doTest("-a -b -c -d"); // Quoted whitespace does matter ? - if (!doExec("-a \"\"-b -c\"\" -d")) exitValue++; + TestHelper.testExitValue += doTest("-a \"\"-b -c\"\" -d"); + // Escaped quotes outside of quotes as literals - if (!doExec("-a \\\"-b -c\\\" -d")) exitValue++; + TestHelper.testExitValue += doTest("-a \\\"-b -c\\\" -d"); // Check for escaped quotes inside of quotes as literal - if (!doExec("-a \"-b \\\"stuff\\\"\" -c -d")) exitValue++; + TestHelper.testExitValue += doTest("-a \"-b \\\"stuff\\\"\" -c -d"); // A quote preceeded by an odd number of slashes is a literal quote - if (!doExec("-a -b\\\\\\\" -c -d")) exitValue++; + TestHelper.testExitValue += doTest("-a -b\\\\\\\" -c -d"); // A quote preceeded by an even number of slashes is a literal quote // see 6214916. - if (!doExec("-a -b\\\\\\\\\" -c -d")) exitValue++; + TestHelper.testExitValue += doTest("-a -b\\\\\\\\\" -c -d"); // Make sure that whitespace doesn't interfere with the removal of the // appropriate tokens. (space-tab-space preceeds -jre-restict-search). - if (!doExec("-a -b \t -jre-restrict-search -c -d","-a -b -c -d")) exitValue++; + TestHelper.testExitValue += doTest("-a -b \t -jre-restrict-search -c -d","-a -b -c -d"); // Make sure that the mJRE tokens being stripped, aren't stripped if // they happen to appear as arguments to the main class. - if (!doExec("foo -version:1.1+")) exitValue++; + TestHelper.testExitValue += doTest("foo -version:1.1+"); - System.out.println("Completed Arrrghs arguments quoting/matching tests with " + exitValue + " errors"); - System.exit(exitValue); + System.out.println("Completed arguments quoting tests with " + + TestHelper.testExitValue + " errors"); } + /* + * These tests are usually run on non-existent targets to check error results + */ + static void runBasicErrorMessageTests() { + // Tests for 5030233 + TestHelper.TestResult tr = TestHelper.doExec(TestHelper.javaCmd, "-cp"); + tr.checkNegative(); + tr.isNotZeroOutput(); + System.out.println(tr); + + tr = TestHelper.doExec(TestHelper.javaCmd, "-classpath"); + tr.checkNegative(); + tr.isNotZeroOutput(); + System.out.println(tr); + + tr = TestHelper.doExec(TestHelper.javaCmd, "-jar"); + tr.checkNegative(); + tr.isNotZeroOutput(); + System.out.println(tr); + + tr = TestHelper.doExec(TestHelper.javacCmd, "-cp"); + tr.checkNegative(); + tr.isNotZeroOutput(); + System.out.println(tr); + + // Test for 6356475 "REGRESSION:"java -X" from cmdline fails" + tr = TestHelper.doExec(TestHelper.javaCmd, "-X"); + tr.checkPositive(); + tr.isNotZeroOutput(); + System.out.println(tr); + + tr = TestHelper.doExec(TestHelper.javaCmd, "-help"); + tr.checkPositive(); + tr.isNotZeroOutput(); + System.out.println(tr); + } + + /* + * A set of tests which tests various dispositions of the main method. + */ + static void runMainMethodTests() throws FileNotFoundException { + TestHelper.TestResult tr = null; + + // a missing class + TestHelper.createJar(new File("some.jar"), new File("Foo"), (String[])null); + tr = TestHelper.doExec(TestHelper.javaCmd, "-jar", "some.jar"); + tr.contains("MIA"); + System.out.println(tr); + // use classpath to check + tr = TestHelper.doExec(TestHelper.javaCmd, "-cp", "some.jar", "MIA"); + tr.contains("Error: Could not find main class MIA"); + System.out.println(tr); + + // incorrect method access + TestHelper.createJar(new File("some.jar"), new File("Foo"), + "private static void main(String[] args){}"); + tr = TestHelper.doExec(TestHelper.javaCmd, "-jar", "some.jar"); + tr.contains("Error: Main method not found in class Foo"); + System.out.println(tr); + // use classpath to check + tr = TestHelper.doExec(TestHelper.javaCmd, "-cp", "some.jar", "Foo"); + tr.contains("Error: Main method not found in class Foo"); + System.out.println(tr); + + // incorrect return type + TestHelper.createJar(new File("some.jar"), new File("Foo"), + "public static int main(String[] args){return 1;}"); + tr = TestHelper.doExec(TestHelper.javaCmd, "-jar", "some.jar"); + tr.contains("Error: Main method must return a value of type void in class Foo"); + System.out.println(tr); + // use classpath to check + tr = TestHelper.doExec(TestHelper.javaCmd, "-cp", "some.jar", "Foo"); + tr.contains("Error: Main method must return a value of type void in class Foo"); + System.out.println(tr); + + // incorrect parameter type + TestHelper.createJar(new File("some.jar"), new File("Foo"), + "public static void main(Object[] args){}"); + tr = TestHelper.doExec(TestHelper.javaCmd, "-jar", "some.jar"); + tr.contains("Error: Main method not found in class Foo"); + System.out.println(tr); + // use classpath to check + tr = TestHelper.doExec(TestHelper.javaCmd, "-cp", "some.jar", "Foo"); + tr.contains("Error: Main method not found in class Foo"); + System.out.println(tr); + + // incorrect method type - non-static + TestHelper.createJar(new File("some.jar"), new File("Foo"), + "public void main(Object[] args){}"); + tr = TestHelper.doExec(TestHelper.javaCmd, "-jar", "some.jar"); + tr.contains("Error: Main method not found in class Foo"); + System.out.println(tr); + // use classpath to check + tr = TestHelper.doExec(TestHelper.javaCmd, "-cp", "some.jar", "Foo"); + tr.contains("Error: Main method not found in class Foo"); + System.out.println(tr); + + // amongst a potpourri of kindred main methods, is the right one chosen ? + TestHelper.createJar(new File("some.jar"), new File("Foo"), + "void main(Object[] args){}", + "int main(Float[] args){return 1;}", + "private void main() {}", + "private static void main(int x) {}", + "public int main(int argc, String[] argv) {return 1;}", + "public static void main(String[] args) {System.out.println(\"THE_CHOSEN_ONE\");}"); + tr = TestHelper.doExec(TestHelper.javaCmd, "-jar", "some.jar"); + tr.contains("THE_CHOSEN_ONE"); + System.out.println(tr); + // use classpath to check + tr = TestHelper.doExec(TestHelper.javaCmd, "-cp", "some.jar", "Foo"); + tr.contains("THE_CHOSEN_ONE"); + System.out.println(tr); + } + + /** + * @param args the command line arguments + * @throws java.io.FileNotFoundException + */ + public static void main(String[] args) throws FileNotFoundException { + if (TestHelper.debug) System.out.println("Starting Arrrghs tests"); + quoteParsingTests(); + runBasicErrorMessageTests(); + runMainMethodTests(); + if (TestHelper.testExitValue > 0) { + System.out.println("Total of " + TestHelper.testExitValue + " failed"); + System.exit(1); + } else { + System.out.println("All tests pass"); + } + } } |