# HG changeset patch # User ksrini # Date 1333068574 25200 # Node ID 201cef0a3f12801b7ed793b1f32710ab33f7ea76 # Parent c795ca19522767a96623949039f2f179ec0bc6ef 7156976: improve java tools testing Reviewed-by: darcy Contributed-by: steve.sides@oracle.com diff -r c795ca195227 -r 201cef0a3f12 jdk/test/tools/launcher/TestHelper.java --- a/jdk/test/tools/launcher/TestHelper.java Thu Mar 29 18:02:36 2012 +0900 +++ b/jdk/test/tools/launcher/TestHelper.java Thu Mar 29 17:49:34 2012 -0700 @@ -54,6 +54,7 @@ static final File TEST_SOURCES_DIR; static final String JAVAHOME = System.getProperty("java.home"); + static final String JAVA_BIN; static final boolean isSDK = JAVAHOME.endsWith("jre"); static final String javaCmd; static final String javawCmd; @@ -83,6 +84,7 @@ static final String JAVA_FILE_EXT = ".java"; static final String CLASS_FILE_EXT = ".class"; static final String JAR_FILE_EXT = ".jar"; + static final String EXE_FILE_EXT = ".exe"; static final String JLDEBUG_KEY = "_JAVA_LAUNCHER_DEBUG"; static final String EXPECTED_MARKER = "TRACER_MARKER:About to EXEC"; @@ -110,6 +112,7 @@ compiler = ToolProvider.getSystemJavaCompiler(); File binDir = (isSDK) ? new File((new File(JAVAHOME)).getParentFile(), "bin") : new File(JAVAHOME, "bin"); + JAVA_BIN = binDir.getAbsolutePath(); File javaCmdFile = (isWindows) ? new File(binDir, "java.exe") : new File(binDir, "java"); diff -r c795ca195227 -r 201cef0a3f12 jdk/test/tools/launcher/ToolsOpts.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/tools/launcher/ToolsOpts.java Thu Mar 29 17:49:34 2012 -0700 @@ -0,0 +1,216 @@ +/* + * Copyright (c) 2012, 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 + * @summary Test options patterns for javac,javah,javap and javadoc using + * javac as a test launcher. Create a dummy javac and intercept options to check + * reception of options as passed through the launcher without having to launch + * javac. Only -J and -cp ./* options should be consumed by the launcher. + * @run main ToolsOpts + * @author ssides + */ + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +public class ToolsOpts extends TestHelper { + static final String JBCP_PREPEND = "-J-Xbootclasspath/p:"; + private static File testJar = null; + static String[][] optionPatterns = { + {"-J-Xmx128m"}, + {"-J-version"}, + {"-J-XshowSettings:vm"}, + {"-J-Xdiag"}, + {"-J-showversion"}, + {"-J-version", "-option"}, + {"-option"}, + {"-option:sub"}, + {"-option:sub-"}, + {"-option:sub1,sub2"}, // -option:list + {"-option:{sub1,sub2,sub3}"}, // -option:{list} + {"-option:{{sub1,sub2,sub3}}"},// -option:{{list}} + {"-option/c:/export/date/tmp"}, + {"-option=value"}, + {"-Dpk1.pk2.pk3"}, // dot in option + {"-Dpk1.pk2=value"}, // dot in option followed by =value + {"@"}, + {"-option", "http://site.com", "http://site.org"}, + {"-option", "name", "p1:p2.."}, + {"-All these non-options show launchers pass options as is to tool."}, + {"-option"}, + {"-option:sub"}, + {"-option:sub-"}, + {"-option", ""}, + {"-option", ""}, + {"-option", ""}, + {"-option", "http://a/b/c/g;x?y#s"}, + {"-option", ""}, + {"-option", "name1:name2"}, + {"-option", "3"}, + {"option1", "-J-version", "option2"}, + {"option1", "-J-version", "-J-XshowSettings:vm", "option2"},}; + + static void init() throws IOException { + if (testJar != null) { + return; + } + + // A tool which simulates com.sun.tools.javac.Main argument processing, + // intercepts options passed via the javac launcher. + final String mainJava = "Main" + JAVA_FILE_EXT; + testJar = new File("test" + JAR_FILE_EXT); + List contents = new ArrayList<>(); + contents.add("package com.sun.tools.javac;"); + contents.add("public class Main {"); + contents.add(" public static void main(String... args) {\n"); + contents.add(" for (String x : args) {\n"); + contents.add(" if(x.compareTo(\" \")!=0)\n"); + contents.add(" System.out.println(x);\n"); + contents.add(" }\n"); + contents.add(" }\n"); + contents.add("}\n"); + createFile(new File(mainJava), contents); + + // compile and jar Main.java into test.jar + compile("-d", ".", mainJava); + createJar("cvf", testJar.getAbsolutePath(), "com"); + } + + static void pass(String msg) { + System.out.println("pass: " + msg); + } + + static void errout(String msg) { + System.err.println(msg); + } + + // Return position of -J option or -1 is does not contain a -J option. + static int indexOfJoption(String[] opts) { + for (int i = 0; i < opts.length; i++) { + if (opts[i].startsWith("-J")) { + return i; + } + } + return -1; + } + + /* + * Check that J options a) are not passed to tool, and b) do the right thing, + * that is, they should be passed to java launcher and work as expected. + */ + static void checkJoptionOutput(TestResult tr, String[] opts) throws IOException { + // Check -J-version options are not passed but do what they should. + String jopts = ""; + for (String pat : opts) { + jopts = jopts.concat(pat + " "); + if (tr.contains("-J")) { + throw new RuntimeException( + "failed: output should not contain option " + pat); + } + if (pat.compareTo("-J-version") == 0 || + pat.compareTo("-J-showversion") == 0) { + if (!tr.contains("java version")) { + throw new RuntimeException("failed: " + pat + + " should have display java version."); + } + } else if (pat.compareTo("-J-XshowSettings:VM") == 0) { + if (!tr.contains("VM settings")) { + throw new RuntimeException("failed: " + pat + + " should have display VM settings."); + } + } + } + pass("Joption check: " + jopts); + } + + /* + * Feed each option pattern in optionPatterns array to javac launcher with + * checking program preempting javac. Check that option received by 'dummy' + * javac is the one passed on the command line. + */ + static void runTestOptions() throws IOException { + init(); + TestResult tr = null; + String sTestJar = testJar.getAbsolutePath(); + int jpos = -1; + for (String arg[] : optionPatterns) { + jpos = indexOfJoption(arg); + //Build a cmd string for output in results reporting. + String cmdString = javacCmd + JBCP_PREPEND + sTestJar; + for (String opt : arg) { + cmdString = cmdString.concat(" " + opt); + } + switch (arg.length) { + case 1: + tr = doExec(javacCmd, JBCP_PREPEND + sTestJar, + arg[0]); + break; + case 2: + tr = doExec(javacCmd, JBCP_PREPEND + sTestJar, + arg[0], arg[1]); + break; + case 3: + tr = doExec(javacCmd, JBCP_PREPEND + sTestJar, + arg[0], arg[1], arg[2]); + break; + case 4: + tr = doExec(javacCmd, JBCP_PREPEND + sTestJar, + arg[0], arg[1], arg[2], arg[3]); + break; + default: + tr = null; + break; + } + + String[] output = tr.testOutput.toArray(new String[tr.testOutput.size()]); + //-Joptions should not be passed to tool + if (jpos > -1) { + checkJoptionOutput(tr, arg); + if (tr.contains(arg[jpos])) { + throw new RuntimeException( + "failed! Should not have passed -J option to tool.\n" + + "CMD: " + cmdString); + } + } else { + //check that each non -J option was passed to tool. + for (int i = 0; i < arg.length; i++) { + if (output[i].compareTo(arg[i]) != 0) { + throw new RuntimeException( + "failed! CMD: " + cmdString + "\n case:" + + output[i] + " != " + arg[i]); + } else { + pass("check " + output[i] + " == " + arg[i]); + } + } + } + pass(cmdString); + } + } + + public static void main(String... args) throws IOException { + runTestOptions(); + } +} diff -r c795ca195227 -r 201cef0a3f12 jdk/test/tools/launcher/VersionCheck.java --- a/jdk/test/tools/launcher/VersionCheck.java Thu Mar 29 18:02:36 2012 +0900 +++ b/jdk/test/tools/launcher/VersionCheck.java Thu Mar 29 17:49:34 2012 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2012, 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 @@ -24,58 +24,76 @@ /** * @test * @bug 6545058 6611182 - * @summary validate and test -version, -fullversion, and internal + * @summary validate and test -version, -fullversion, and internal, as well as + * sanity checks if a tool can be launched. * @compile VersionCheck.java * @run main VersionCheck */ -import java.lang.*; import java.io.File; -import java.io.BufferedReader; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.io.Reader; +import java.io.FileFilter; import java.util.Map; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; -import java.util.StringTokenizer; -public class VersionCheck { +public class VersionCheck extends TestHelper { - private static String javaBin; + // tools that do not accept -J-option + static final String[] BLACKLIST_JOPTION = { + "controlpanel", + "java-rmi", + "java-rmi.cgi", + "java", + "javaw", + "javaws", + "jcontrol", + "jvisualvm", + "packager", + "unpack200", + "wsimport" + }; - // A known set of programs we know for sure will behave correctly. - private static String[] programs = new String[]{ + // tools that do not accept -version + static final String[] BLACKLIST_VERSION = { "appletviewer", + "controlpanel", "extcheck", - "idlj", "jar", "jarsigner", - "javac", + "java-rmi", + "java-rmi.cgi", "javadoc", - "javah", - "javap", + "javaws", + "jcmd", "jconsole", - "jdb", - "jhat", + "jcontrol", "jinfo", "jmap", "jps", + "jrunscript", + "jsadebugd", "jstack", "jstat", "jstatd", + "jvisualvm", "keytool", + "kinit", + "klist", + "ktab", "native2ascii", "orbd", "pack200", + "packager", "policytool", "rmic", "rmid", "rmiregistry", - "schemagen", + "schemagen", // returns error code 127 "serialver", "servertool", "tnameserv", + "unpack200", "wsgen", "wsimport", "xjc" @@ -85,53 +103,11 @@ static String refVersion; static String refFullVersion; - private static List getProcessStreamAsList(boolean javaDebug, - String... argv) { - List out = new ArrayList(); - List javaCmds = new ArrayList(); - - String prog = javaBin + File.separator + argv[0]; - if (System.getProperty("os.name").startsWith("Windows")) { - prog = prog.concat(".exe"); - } - javaCmds.add(prog); - for (int i = 1; i < argv.length; i++) { - javaCmds.add(argv[i]); - } - - ProcessBuilder pb = new ProcessBuilder(javaCmds); - Map env = pb.environment(); - if (javaDebug) { - env.put("_JAVA_LAUNCHER_DEBUG", "true"); - } - try { - Process p = pb.start(); - BufferedReader r = (javaDebug) ? - new BufferedReader(new InputStreamReader(p.getInputStream())) : - new BufferedReader(new InputStreamReader(p.getErrorStream())) ; - - String s = r.readLine(); - while (s != null) { - out.add(s.trim()); - s = r.readLine(); - } - p.waitFor(); - p.destroy(); - } catch (Exception ex) { - ex.printStackTrace(); - throw new RuntimeException(ex.getMessage()); - } - return out; - } - static String getVersion(String... argv) { - List alist = getProcessStreamAsList(false, argv); - if (alist.size() == 0) { - throw new AssertionError("unexpected process returned null"); - } + TestHelper.TestResult tr = doExec(argv); StringBuilder out = new StringBuilder(); // remove the HotSpot line - for (String x : alist) { + for (String x : tr.testOutput) { if (!x.matches(".*Client.*VM.*|.*Server.*VM.*")) { out = out.append(x + "\n"); } @@ -139,9 +115,28 @@ return out.toString(); } - static boolean compareVersionStrings() { + /* + * this tests if the tool can take a version string and returns + * a 0 exit code, it is not possible to validate the contents + * of the -version output as they are inconsistent. + */ + static boolean testToolVersion() { + TestResult tr = null; + TestHelper.testExitValue = 0; + for (File f : new File(JAVA_BIN).listFiles(new ToolFilter(BLACKLIST_VERSION))) { + String x = f.getAbsolutePath(); + System.out.println("Testing (-version): " + x); + tr = doExec(x, "-version"); + tr.checkPositive(); + } + return TestHelper.testExitValue == 0; + } + + static boolean compareJVersionStrings() { int failcount = 0; - for (String x : programs) { + for (File f : new File(JAVA_BIN).listFiles(new ToolFilter(BLACKLIST_JOPTION))) { + String x = f.getAbsolutePath(); + System.out.println("Testing (-J-version): " + x); String testStr; testStr = getVersion(x, "-J-version"); @@ -185,8 +180,14 @@ String expectedDotVersion = "dotversion:" + jdkMajor + "." + jdkMinor; String expectedFullVersion = "fullversion:" + bStr; - List alist = getProcessStreamAsList(true, "java", "-version"); - + Map envMap = new HashMap<>(); + envMap.put(TestHelper.JLDEBUG_KEY, "true"); + TestHelper.TestResult tr = doExec(envMap, javaCmd, "-version"); + List alist = new ArrayList<>(); + alist.addAll(tr.testOutput); + for (String x : tr.testOutput) { + alist.add(x.trim()); + } if (!alist.contains(expectedDotVersion)) { System.out.println("Error: could not find " + expectedDotVersion); failcount++; @@ -202,21 +203,46 @@ // Initialize static void init() { - String javaHome = System.getProperty("java.home"); - if (javaHome.endsWith("jre")) { - javaHome = new File(javaHome).getParent(); - } - javaBin = javaHome + File.separator + "bin"; - refVersion = getVersion("java", "-version"); - refFullVersion = getVersion("java", "-fullversion"); + refVersion = getVersion(javaCmd, "-version"); + refFullVersion = getVersion(javaCmd, "-fullversion"); } public static void main(String[] args) { init(); - if (compareVersionStrings() && compareInternalStrings()) { + if (compareJVersionStrings() && + compareInternalStrings() && + testToolVersion()) { System.out.println("All Version string comparisons: PASS"); } else { throw new AssertionError("Some tests failed"); } } + + static class ToolFilter implements FileFilter { + final Iterable exclude ; + protected ToolFilter(String... exclude) { + List tlist = new ArrayList<>(); + this.exclude = tlist; + for (String x : exclude) { + String str = x + ((isWindows) ? EXE_FILE_EXT : ""); + tlist.add(str.toLowerCase()); + } + } + @Override + public boolean accept(File pathname) { + if (!pathname.isFile() || !pathname.canExecute()) { + return false; + } + String name = pathname.getName().toLowerCase(); + if (isWindows && !name.endsWith(EXE_FILE_EXT)) { + return false; + } + for (String x : exclude) { + if (name.endsWith(x)) { + return false; + } + } + return true; + } + } }