# HG changeset patch # User ksrini # Date 1421266178 28800 # Node ID 3e9d7d7dd3624082e6dc976e666c82f60171f033 # Parent 0bf78b38bc0bc3b72b11be30e930a24d8c86cb1e 8067437: New tests for mJRE feature removal. Reviewed-by: darcy, ksrini Contributed-by: andrey.x.nazarov@oracle.com diff -r 0bf78b38bc0b -r 3e9d7d7dd362 jdk/test/tools/launcher/Arrrghs.java --- a/jdk/test/tools/launcher/Arrrghs.java Wed Jan 14 21:35:52 2015 +0300 +++ b/jdk/test/tools/launcher/Arrrghs.java Wed Jan 14 12:09:38 2015 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2015, 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 @@ -30,12 +30,10 @@ * @run main/othervm Arrrghs */ -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.Arrays; import java.util.HashMap; @@ -48,9 +46,6 @@ 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 were notoriously buggy. Implementing these tests purely @@ -58,12 +53,6 @@ * */ - // 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: "; - /* * SIGH, On Windows all strings are quoted, we need to unwrap it */ @@ -78,122 +67,6 @@ return in; } - /* - * This method detects the cookie in the output stream of the process. - */ - private 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 (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 + "'"); - } - // Return the value asap if not in debug mode. - if (!debug) { - rd.close(); - istream.close(); - return retval; - } - } - in = rd.readLine(); - } - return retval; - } - - private boolean doReExecTest0(ProcessBuilder pb, String expectedArguments) { - boolean retval = false; - try { - pb.redirectErrorStream(true); - Process p = pb.start(); - retval = detectCookie(p.getInputStream(), expectedArguments); - p.waitFor(); - p.destroy(); - } catch (Exception ex) { - ex.printStackTrace(); - throw new RuntimeException(ex.getMessage()); - } - return retval; - } - - /** - * This method returns true if the expected and detected arguments are the same. - * Quoting could cause dissimilar testArguments and expected arguments. - */ - int doReExecTest(String testArguments, String expectedPattern) { - ProcessBuilder pb = new ProcessBuilder(javaCmd, - VersionStr, testArguments); - - Map env = pb.environment(); - env.put(JLDEBUG_KEY, "true"); - return doReExecTest0(pb, testArguments) ? 0 : 1; - } - - /** - * A convenience method for identical test pattern and expected arguments - */ - int doReExecTest(String testPattern) { - return doReExecTest(testPattern, testPattern); - } - - @Test - void testQuoteParsingThroughReExec() { - /* - * Tests for 6214916 - * These tests require that a JVM (any JVM) be installed in the system registry. - * If none is installed, skip this test. - */ - TestResult tr = doExec(javaCmd, VersionStr, "-version"); - if (!tr.isOK()) { - System.err.println("Warning:Argument Passing Tests were skipped, " + - "no java found in system registry."); - return; - } - - // Basic test - testExitValue += doReExecTest("-a -b -c -d"); - - // Basic test with many spaces - testExitValue += doReExecTest("-a -b -c -d"); - - // Quoted whitespace does matter ? - testExitValue += doReExecTest("-a \"\"-b -c\"\" -d"); - - - // Escaped quotes outside of quotes as literals - testExitValue += doReExecTest("-a \\\"-b -c\\\" -d"); - - // Check for escaped quotes inside of quotes as literal - testExitValue += doReExecTest("-a \"-b \\\"stuff\\\"\" -c -d"); - - // A quote preceeded by an odd number of slashes is a literal quote - testExitValue += doReExecTest("-a -b\\\\\\\" -c -d"); - - // A quote preceeded by an even number of slashes is a literal quote - // see 6214916. - testExitValue += doReExecTest("-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). - testExitValue += doReExecTest("-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. - testExitValue += doReExecTest("foo -version:1.1+"); - - System.out.println("Completed arguments quoting tests with " - + testExitValue + " errors"); - } // the pattern we hope to see in the output static final Pattern ArgPattern = Pattern.compile("\\s*argv\\[[0-9]*\\].*=.*"); diff -r 0bf78b38bc0b -r 3e9d7d7dd362 jdk/test/tools/launcher/MultipleJRE.sh --- a/jdk/test/tools/launcher/MultipleJRE.sh Wed Jan 14 21:35:52 2015 +0300 +++ b/jdk/test/tools/launcher/MultipleJRE.sh Wed Jan 14 12:09:38 2015 -0800 @@ -90,36 +90,6 @@ } # -# Shell routine to ensure help page does not include mjre options -# -TestHelp() { - mess="`$JAVA -help 2>&1`" - # make sure it worked - if [ $? -ne 0 ]; then - echo "java -help failed ????" - exit 1 - fi - - echo $mess | grep '\-version:' > /dev/null 2>&1 - if [ $? -eq 0 ]; then - echo "help message contains obsolete option version:" - exit 1 - fi - - echo $mess | grep '\-jre-restrict-search' > /dev/null 2>&1 - if [ $? -eq 0 ]; then - echo "help message contains obsolete option jre-restrict-search" - exit 1 - fi - - echo $mess | grep '\-no-jre-restrict-search' > /dev/null 2>&1 - if [ $? -eq 0 ]; then - echo "help message contains obsolete option no-jre-restrict-search" - exit 1 - fi -} - -# # Just as the name says. We sprinkle these in the appropriate location # in the test file system and they just say who they are pretending to be. # @@ -461,33 +431,4 @@ LaunchVM "" "${RELEASE}" fi -# -# Now test specification of mJRE -# -# In some cases this should result in failure of the command, -# in some cases, a warning messages, with the command succeeding. -# - - # Commandline use of "-version:" should fail - # with a message containing "no longer supported" - LaunchVM "-version:1.10+" "Error: Specifying an alternate JDK/JRE" - LaunchVM "-version:prettymuchanything" "Error: Specifying an alternate JDK/JRE" - - # Commandline use of "-jre-restrict-search" should now fail - LaunchVM "-jre-restrict-search" "\-jre\-no\-restrict\-search are also no longer valid" - # Commandline use of "-jre-no-restrict-search" should now fail - LaunchVM "-jre-no-restrict-search" "\-jre\-no\-restrict\-search are also no longer valid" - - - # mJRE directives to use a specific version should be flagged - # with a warning, but the jar should be executed with the - # current jre - CreateFullJar "junk request" "" - LaunchVM "" "${RELEASE}" - # Going to silently ignore JRE-Version setting in jar file manifest - #LaunchVM "" "warning: The jarfile JRE-Version" - - # Verify help does not contain obsolete options - TestHelp - exit 0 diff -r 0bf78b38bc0b -r 3e9d7d7dd362 jdk/test/tools/launcher/MultipleJRERemoved.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/tools/launcher/MultipleJRERemoved.java Wed Jan 14 12:09:38 2015 -0800 @@ -0,0 +1,212 @@ +/* + * Copyright (c) 2014, 2015, 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 8067437 + * @summary Verify Multiple JRE version support has been removed. + * @build TestHelper + * @run main MultipleJRERemoved + */ + +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.nio.file.Files; +import java.util.*; +import java.util.jar.Attributes; +import java.util.jar.JarOutputStream; +import java.util.jar.Manifest; +import java.util.regex.Pattern; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import java.util.zip.ZipEntry; + +public class MultipleJRERemoved extends TestHelper { + + public static final String VERSION_JAR = "version.jar"; + public static final String PRINT_VERSION_CLASS = "PrintVersion"; + private final File javaFile = new File(PRINT_VERSION_CLASS + ".java"); + private final File clsFile = new File(PRINT_VERSION_CLASS + ".class"); + + private MultipleJRERemoved() { + } + + /** + * @param args the command line arguments + * @throws java.io.FileNotFoundException + */ + public static void main(String[] args) throws Exception { + MultipleJRERemoved a = new MultipleJRERemoved(); + a.run(args); + } + + /** + * Check all combinations of flags: "-version:", "-jre-restrict-search", "-jre-no-restrict-search". Test expects to see errors. + */ + @Test + public void allFlagCombinations() throws IOException { + final Pattern newLine = Pattern.compile("\n"); + createJar(Collections.emptyMap()); + + for (Flag flag1 : Flag.values()) { + for (Flag flag2 : Flag.values()) { + for (Flag flag3 : Flag.values()) { + List flags = Stream.of(flag1, flag2, flag3) + .filter(f -> !Flag.EMPTY.equals(f)) + .collect(Collectors.toList()); + + if (flags.size() == 0) continue; + + List flagValues = flags.stream() + .map(Flag::value) + .collect(Collectors.toList()); + + List errorMessages = flags.stream() + .map(Flag::errorMessage) + .flatMap(newLine::splitAsStream) + .collect(Collectors.toList()); + + List jarCmd = new ArrayList<>(); + jarCmd.add(javaCmd); + jarCmd.addAll(flagValues); + jarCmd.add("-jar"); + jarCmd.add("version.jar"); + + check(jarCmd, errorMessages); + + List cmd = new ArrayList<>(); + cmd.add(javaCmd); + cmd.addAll(flagValues); + cmd.add(PRINT_VERSION_CLASS); + + check(cmd, errorMessages); + } + } + } + } + + private void check(List cmd, List errorMessages) { + TestResult tr = doExec(cmd.toArray(new String[cmd.size()])); + tr.checkNegative(); + tr.isNotZeroOutput(); + errorMessages.forEach(tr::contains); + + if (!tr.testStatus) { + System.out.println(tr); + throw new RuntimeException("test case: failed\n" + cmd); + } + } + + /** + * Verifies that java -help output doesn't contain information about "mJRE" flags. + */ + @Test + public void javaHelp() { + TestResult tr = doExec(javaCmd, "-help"); + tr.checkPositive(); + tr.isNotZeroOutput(); + tr.notContains("-version:"); + tr.notContains("-jre-restrict-search"); + tr.notContains("-jre-no-restrict-search"); + tr.notContains("-no-jre-restrict-search"); //it's not a typo in flag name. + if (!tr.testStatus) { + System.out.println(tr); + throw new RuntimeException("Failed. java -help output contains obsolete flags.\n"); + } + } + + /** + * Verifies that java -jar version.jar output ignores "mJRE" manifest directives. + */ + @Test + public void manifestDirectives() throws IOException { + Map manifest = new TreeMap<>(); + manifest.put("JRE-Version", "1.8"); + manifest.put("JRE-Restrict-Search", "1.8"); + createJar(manifest); + + TestResult tr = doExec(javaCmd, "-jar", VERSION_JAR); + tr.checkPositive(); + tr.contains(System.getProperty("java.version")); + if (!tr.testStatus) { + System.out.println(tr); + throw new RuntimeException("Failed.\n"); + } + } + + private void emitFile() throws IOException { + List scr = new ArrayList<>(); + scr.add("public class PrintVersion {"); + scr.add(" public static void main(String... args) {"); + scr.add(" System.out.println(System.getProperty(\"java.version\"));"); + scr.add(" }"); + scr.add("}"); + createFile(javaFile, scr); + compile(javaFile.getName()); + } + + private void createJar(Map manifestAttributes) throws IOException { + emitFile(); + + Manifest manifest = new Manifest(); + final Attributes mainAttributes = manifest.getMainAttributes(); + mainAttributes.putValue("Manifest-Version", "1.0"); + mainAttributes.putValue("Main-Class", PRINT_VERSION_CLASS); + manifestAttributes.forEach(mainAttributes::putValue); + + try (JarOutputStream jar = new JarOutputStream(new FileOutputStream(VERSION_JAR), manifest)) { + jar.putNextEntry(new ZipEntry(PRINT_VERSION_CLASS + ".class")); + jar.write(Files.readAllBytes(clsFile.toPath())); + jar.closeEntry(); + } finally { + javaFile.delete(); + } + } + + private enum Flag { + EMPTY("", ""), + VERSION("-version:1.9", "Error: Specifying an alternate JDK/JRE version is no longer supported.\n" + + "The use of the flag '-version:' is no longer valid.\n" + + "Please download and execute the appropriate version."), + JRE_RESTRICT_SEARCH("-jre-restrict-search", "Error: Specifying an alternate JDK/JRE is no longer supported.\n" + + "The related flags -jre-restrict-search | -jre-no-restrict-search are also no longer valid."), + JRE_NO_RESTRICT_SEARCH("-jre-no-restrict-search", "Error: Specifying an alternate JDK/JRE is no longer supported.\n" + + "The related flags -jre-restrict-search | -jre-no-restrict-search are also no longer valid."); + private final String flag; + private final String errorMessage; + + Flag(String flag, String errorMessage) { + this.flag = flag; + this.errorMessage = errorMessage; + } + + String value() { + return flag; + } + + String errorMessage() { + return errorMessage; + } + } +}