|
/*
* Copyright (c) 2014, 2022, 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.
*/
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.spi.ToolProvider;
import toolbox.ToolBox;
/**
* Utility methods for use by tests in the `Paths` directory.
*/
class Util {
ToolBox tb = new ToolBox();
PrintStream out = tb.out;
Path javaHome = Path.of(System.getProperty("java.home"));
String PS = File.pathSeparator;
Path curDir = Path.of(".");
static final String JAR = "jar";
static final String JAVA = "java";
static final String JAVAC = "javac";
static final String JIMAGE = "jimage";
/** The number of test-case failures. */
int failCount = 0;
/** The number of test-case passes. */
int passCount = 0;
/** A map recording how often each tool is executed in a separate process. */
Map<String, Integer> execCounts = new TreeMap<>();
/** A map recording how often each tool is invoked via its ToolProvider API. */
Map<String, Integer> toolCounts = new TreeMap<>();
/**
* Reports a summary of the overall test statistics, and throws an exception
* if any test cases failed.
*
* @throws Exception if any test cases failed
*/
void bottomLine() throws Exception {
out.println();
out.println("-- Summary --");
out.println("Passed: " + passCount);
out.println("Failed: " + failCount);
out.println("exec: " + execCounts);
out.println("tool: " + toolCounts);
if (failCount > 0) {
throw new Exception(failCount + " tests failed");
}
}
/**
* The result of executing a tool, either in a separate process, or via its ToolProvider API.
*
* @param exitCode the exit code from the tool: 0 for success
* @param out the output from the tool
*/
record Result(int exitCode, String out) { }
/**
* Executes a tool with given arguments and verifies that it passes.
*
* @param command the name of a JDK tool: java, javac or jar
* @param args a string containing whitespace separated arguments
* @throws Exception if there was an issue trying to execute the tool
* @see #passCount
* @see #failCount
* @see #splitArgs(String)
*/
void expectPass(String command, String args) throws Exception {
expectPass(null, null, command, splitArgs(args));
}
/**
* Executes a tool in a specific directory with given arguments and verifies that it passes.
* In order to set the directory, the tool will be executed in a separate process.
*
* @param dir the directory
* @param command the name of a JDK tool: java, javac or jar
* @param args a string containing whitespace separated arguments
* @throws Exception if there was an issue trying to execute the tool
* @see #passCount
* @see #failCount
* @see #splitArgs(String)
*/
void expectPass(Path dir, String command, String args) throws Exception {
expectPass(dir, null, command, splitArgs(args));
}
/**
* Executes a tool with additional env variables with given arguments and verifies that it passes.
* In order to set the env variables, the tool will be executed in a separate process.
* Note that any value of {@code CLASSPATH} inherited from this process will always be removed.
*
* @param env the additional env variables
* @param command the name of a JDK tool: java, javac or jar
* @param args a string containing whitespace separated arguments
* @throws Exception if there was an issue trying to execute the tool
* @see #passCount
* @see #failCount
* @see #splitArgs(String)
*/
void expectPass(Map<String, String> env, String command, String args) throws Exception {
expectPass(null, env, command, splitArgs(args));
}
/**
* Executes a tool in a given directory with additional env variables with given arguments
* and verifies that it passes.
* In order to set any directory and env variables, the tool will be executed in a separate process.
* Note that any value of {@code CLASSPATH} inherited from this process will always be removed.
*
* @param dir the directory, or {@code null}
* @param env the additional env variables, or {@code null}
* @param command the name of a JDK tool: java, javac or jar
* @param args the arguments
* @throws Exception if there was an issue trying to execute the tool
* @see #passCount
* @see #failCount
*/
void expectPass(Path dir, Map<String, String> env, String command, String... args) throws Exception {
Result result = switch (command) {
case JAR -> jar(args);
case JAVAC -> javac(dir, env, args);
case JAVA -> java(dir, env, args);
default -> throw new Exception("unknown command: " + command);
};
if (result.exitCode == 0) {
out.println("PASS: test passed as expected");
passCount++;
} else {
out.println("FAIL: test failed unexpectedly");
failCount++;
}
}
/**
* Executes a tool with given arguments and verifies that it fails.
*
* @param command the name of a JDK tool: java, javac or jar
* @param args a string containing whitespace separated arguments
* @throws Exception if there was an issue trying to execute the tool
* @see #passCount
* @see #failCount
* @see #splitArgs(String)
*/
void expectFail(String command, String args) throws Exception {
expectFail(null, null, command, splitArgs(args));
}
/**
* Executes a tool in a specific directory with given arguments and verifies that it fails.
* In order to set the directory, the tool will be executed in a separate process.
*
* @param dir the directory
* @param command the name of a JDK tool: java, javac or jar
* @param args a string containing whitespace separated arguments
* @throws Exception if there was an issue trying to execute the tool
* @see #passCount
* @see #failCount
* @see #splitArgs(String)
*/
void expectFail(Path dir, String command, String args) throws Exception {
expectFail(dir, null, command, splitArgs(args));
}
/**
* Executes a tool with additional env variables with given arguments and verifies that it passes.
* In order to set the env variables, the tool will be executed in a separate process.
* Note that any value of {@code CLASSPATH} inherited from this process will always be removed.
*
* @param env the additional env variables
* @param command the name of a JDK tool: java, javac or jar
* @param args a string containing whitespace separated arguments
* @throws Exception if there was an issue trying to execute the tool
* @see #passCount
* @see #failCount
* @see #splitArgs(String)
*/
void expectFail(Map<String, String> env, String command, String args) throws Exception {
expectFail(null, env, command, splitArgs(args));
}
/**
* Executes a tool in a given directory with additional env variables with given arguments
* and verifies that it passes.
* In order to set any directory and env variables, the tool will be executed in a separate process.
* Note that any value of {@code CLASSPATH} inherited from this process will always be removed.
*
* @param dir the directory, or {@code null}
* @param env the additional env variables, or {@code null}
* @param command the name of a JDK tool: java, javac or jar
* @param args the arguments
* @throws Exception if there was an issue trying to execute the tool
* @see #passCount
* @see #failCount
*/
void expectFail(Path dir, Map<String, String> env, String command, String... args) throws Exception {
Result result = switch (command) {
case JAR -> jar(args);
case JAVAC -> javac(dir, env, args);
case JAVA -> java(dir, env, args);
default -> throw new Exception("unknown command: " + command);
};
if (result.exitCode == 0) {
out.println("FAIL: test passed unexpectedly");
failCount++;
} else {
out.println("PASS: failed as expected");
passCount++;
}
}
/**
* Splits a string into a list of strings that were separated by whitespace.
* Leading and trailing whitespace is removed.
* The character sequence {@code ${PS}} is replaced by the platform path separator.
* Note, quotes are not supported, and so there is no support for embedded whitespace
* or empty strings in the output.
*
* @param args a string of tokens separated by whitespace
* @return an array of the tokens that were separated by whitespace
*/
String[] splitArgs(String args) {
return args.trim()
.replace("${PS}", PS)
.split("\\s+");
}
/**
* Executes {@code javac} using its ToolProvider API.
*
* @param args the arguments
* @return an object containing the output and exit code from the tool
* @throws Exception if there is an issue executing the tool
*/
Result javac(String... args) throws Exception {
return runTool(JAVAC, args);
}
/**
* Executes {@code javac} in either a separate process or using its ToolProvider API.
* The ToolProvider API is used if the directory and env parameters are {@code null},
* and if the arguments definitely do not use "classpath wildcards", which are
* only supported when the tool is invoked by the launcher.
*
* @param dir the directory, or {@code null}
* @param env any additional environment variables, or {@code null}
* @param args the arguments
* @return an object containing the output and exit code from the tool
* @throws Exception if there is an issue executing the tool
*/
Result javac(Path dir, Map<String, String> env, String... args) throws Exception {
return (env != null || dir != null || hasWildcardClassPath(args))
? execTool(dir, env, JAVAC, args)
: runTool(JAVAC, args);
}
/**
* {@return true if the arguments may contain a classpath option using a "classpath wildcard"}
*
* The result is {@code true} if there is any form of a classpath option whose value contains {@code *}.
* Note: this may include "false positives", where the {@code *} is not at the end of
* any element in the path, such as when the character is part of the filename.
* However, in context, the approximation is safe, and just means that we may sometimes
* execute javac in a separate process when it would be sufficient to use its ToolProvider API.
*
* A more refined implementation could split apart the path elements and looking for
* an element that is {@code *} or which ends in {@code *}.
*
* @param args the arguments to be checked
*/
private boolean hasWildcardClassPath(String... args) {
for (int i = 0; i < args.length; i++) {
String arg = args[i];
switch (arg) {
case "-classpath", "--class-path", "-cp" -> {
if (i + 1 < args.length && args[i + 1].contains("*")) {
return true;
}
}
default -> {
if (arg.startsWith("--class-path=") && arg.contains("*")) {
return true;
}
}
}
}
return false;
}
/**
* Executes {@code jar} using its ToolProvider API.
*
* @param args the arguments
* @return an object containing the output and exit code from the tool
* @throws Exception if there is an issue executing the tool
*/
Result jar(String... args) throws Exception {
return runTool(JAR, args);
}
/**
* Executes {@code jimage} using its ToolProvider API.
*
* @param args the arguments
* @return an object containing the output and exit code from the tool
* @throws Exception if there is an issue executing the tool
*/
Result jimage(String... args) throws Exception {
return execTool(null, null, JIMAGE, args);
}
/**
* Executes {@code java} in a separate process.
*
* @param dir the directory, or {@code null}
* @param env any additional environment variables, or {@code null}
* @param args the arguments
* @return an object containing the output and exit code from the launcher
* @throws Exception if there is an issue executing the tool
*/
Result java(Path dir, Map<String, String> env, String... args) throws Exception {
return execTool(dir, env, JAVA, args);
}
/**
* Runs a tool using its ToolProvider API.
*
* @param args the arguments
* @return an object containing the output and exit code from the launcher
* @throws Exception if there is an issue executing the tool
*/
Result runTool(String name, String... args) throws Exception {
out.println(name + ": " + String.join(" ", args));
var tool = ToolProvider.findFirst(name)
.orElseThrow(() -> new Exception("cannot find " + name));
try (StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw)) {
int rc = tool.run(pw, pw, args);
pw.flush();
String output = sw.toString();
output.lines()
.forEach(l -> out.println(name + ": " + l));
if (rc != 0) {
out.println(name + ": exit code " + rc);
}
toolCounts.put(name, toolCounts.computeIfAbsent(name, n -> 0) + 1);
return new Result(rc, output);
}
}
/**
* Executes a tool in a separate process.
*
* Note that any value of {@code CLASSPATH} inherited from this process will always be removed.
*
* @param dir the directory, or {@code null}
* @param env any additional environment variables, or {@code null}
* @param args the arguments
* @return an object containing the output and exit code from the launcher
* @throws Exception if there is an issue executing the tool
*/
Result execTool(Path dir, Map<String, String> env, String name, String... args) throws Exception {
out.print(name + ":");
if (env != null) {
out.print(" " + env);
}
if (dir != null) {
out.print(" (" + dir + ")");
}
out.println(" " + String.join(" ", args));
Path tool = javaHome.resolve("bin").resolve(name + (ToolBox.isWindows() ? ".exe" : ""));
if (!Files.exists(tool)) {
throw new Exception("cannot find " + name);
}
var cmd = new ArrayList<String>();
cmd.add(tool.toString());
cmd.addAll(List.of(args));
ProcessBuilder pb = new ProcessBuilder(cmd)
.redirectErrorStream(true);
pb.environment().remove("CLASSPATH"); // always remove default value set by jtreg
if (env != null) {
pb.environment().putAll(env);
}
if (dir != null) {
pb.directory(dir.toFile());
}
Process p = pb.start();
StringBuilder sb = new StringBuilder();
try (var in = p.inputReader()) {
in.lines().forEach(l -> {
sb.append(l).append("\n");
out.println(name + ": " + l);
});
}
p.waitFor();
int rc = p.exitValue();
if (rc != 0) {
out.println(name + ": exit code " + rc);
}
execCounts.put(name, execCounts.computeIfAbsent(name, n -> 0) + 1);
return new Result(rc, sb.toString());
}
/**
* Checks that a series of files exist and are readable.
*
* @param paths the files
* @throws Exception if any of the files are not found or are not readable
*/
void checkFiles(String... paths) throws Exception {
for (String p : paths) {
Path path = Path.of(p);
if (!Files.isReadable(path) ) {
throw new Exception("file not found: " + path);
}
}
}
/**
* List the files in a directory that match a "glob" pattern.
*
* @param dir the directory
* @param glob the pattern
* @return the list of files
* @throws IOException if there is a problem listing the contents of the directory
*/
List<Path> listFiles(Path dir, String glob) throws IOException {
var files = new ArrayList<Path>();
try (DirectoryStream<Path> ds = Files.newDirectoryStream(dir, glob)) {
for (Path p : ds) {
files.add(p);
}
}
return files;
}
/**
* Deletes a series of files.
* The files are deleted using {@link ToolBox#cleanDirectory(Path)} and
* {@code ToolBox#deleteFiles}, which together try hard to delete the files,
* even on Windows.
*
* @param paths the paths
* @throws IOException if there is a problem deleting any of the files
* @see #deleteFiles(List)
*/
void deleteFiles(String... paths) throws IOException {
deleteFiles(Arrays.stream(paths)
.map(Path::of)
.toList());
}
/**
* Deletes a series of files.
* The files are deleted using {@link ToolBox#cleanDirectory(Path)} and
* {@code ToolBox#deleteFiles}, which together try hard to delete the files,
* even on Windows.
*
* @param paths the paths
* @throws IOException if there is a problem deleting any of the files
*/
void deleteFiles(List<Path> paths) throws IOException {
for (Path path : paths) {
if (Files.exists(path)) {
if (Files.isDirectory(path)) {
tb.cleanDirectory(path);
}
tb.deleteFiles(path);
}
}
}
/**
* Moves a series of files into a given directory.
*
* @param files the files
* @param dir the target directory
* @throws IOException if there is a problem moving any of the files
*/
void moveFiles(List<Path> files, Path dir) throws IOException {
for (Path p : files) {
tb.moveFile(p, dir);
}
}
/**
* Moves a series of files into a given directory.
*
* @param files the files
* @param dir the target directory
* @throws IOException if there is a problem moving any of the files
*/
void moveFiles(List<String> files, String dir) throws IOException {
for (String p : files) {
tb.moveFile(p, dir);
}
}
/**
* {@return a map containing a setting for the {@code CLASSPATH} env variable}
*
* @param classpath the value for the env variable
*/
Map<String, String> classpath(String classpath) {
return Map.of("CLASSPATH", classpath.replace("${PS}", PS));
}
/**
* Writes a file called {@code MANIFEST.MF} containing a given value for
* the {@code Class-Path} entry.
*
* @param path the value for the {@code Class-Path} entry
* @throws IOException if there is a problem writing the file
*/
void makeManifestWithClassPath(String path) throws IOException {
Files.writeString(Path.of("MANIFEST.MF"),
"Manifest-Version: 1.0\n"
+ "Class-Path: " + path + "\n");
}
}
¤ Dauer der Verarbeitung: 0.130 Sekunden
(vorverarbeitet)
¤
|
Haftungshinweis
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
|
