| /* | |
| * 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"); | |
| } | |
| } |