infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-02-09 09:58:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

8067437: New tests for mJRE feature removal

Browse Source 
Reviewed-by: darcy, ksrini
This commit is contained in:
Andrey Nazarov 2015-01-14 12:09:38 -08:00 committed by Kumar Srinivasan
parent 7882032236
commit fa39b2bbf2
3 changed files with 214 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
jdk/test/tools/launcher/Arrrghs.java
View File

@ -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 @@ public class Arrrghs extends TestHelper {
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 @@ public class Arrrghs extends TestHelper {
*
*/
// 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 @@ public class Arrrghs extends TestHelper {
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<String, String> 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]*\\].*=.*");

59
jdk/test/tools/launcher/MultipleJRE.sh
View File

@ -89,36 +89,6 @@ TestSyntax() {
fi
}
#
# 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:<value>' > /dev/null 2>&1
if [ $? -eq 0 ]; then
echo "help message contains obsolete option version:<value>"
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 @@ if [ -x /usr/bin/zipnote ]; then
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

212
jdk/test/tools/launcher/MultipleJRERemoved.java Normal file
View File

@ -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<Flag> flags = Stream.of(flag1, flag2, flag3)
.filter(f -> !Flag.EMPTY.equals(f))
.collect(Collectors.toList());
if (flags.size() == 0) continue;
List<String> flagValues = flags.stream()
.map(Flag::value)
.collect(Collectors.toList());
List<String> errorMessages = flags.stream()
.map(Flag::errorMessage)
.flatMap(newLine::splitAsStream)
.collect(Collectors.toList());
List<String> jarCmd = new ArrayList<>();
jarCmd.add(javaCmd);
jarCmd.addAll(flagValues);
jarCmd.add("-jar");
jarCmd.add("version.jar");
check(jarCmd, errorMessages);
List<String> cmd = new ArrayList<>();
cmd.add(javaCmd);
cmd.addAll(flagValues);
cmd.add(PRINT_VERSION_CLASS);
check(cmd, errorMessages);
}
}
}
}
private void check(List<String> cmd, List<String> 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:<value>");
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<String, String> 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<String> 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<String, String> 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;
}
}
}