Quelle ToolBox.java Sprache: JAVA

/*
* Copyright (c) 2013, 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.
*/

package toolbox;

import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.FilterOutputStream;
import java.io.FilterWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.StringWriter;
import java.io.Writer;
import java.net.URI;
import java.nio.charset.Charset;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.FileVisitOption;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Deque;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

import javax.tools.FileObject;
import javax.tools.ForwardingJavaFileManager;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.ToolProvider;

/**
* Utility methods and classes for writing jtreg tests for
* javac, javah, and javap. (For javadoc support, see JavadocTester.)
*
* There is support for common file operations similar to
* shell commands like cat, cp, diff, mv, rm, grep.
*
* There is also support for invoking various tools, like
* javac, javah, javap, jar, java and other JDK tools.
*
* File separators: for convenience, many operations accept strings
* to represent filenames. On all platforms on which JDK is supported,
* "/" is a legal filename component separator. In particular, even
* on Windows, where the official file separator is "\", "/" is a legal
* alternative. It is therefore recommended that any client code using
* strings to specify filenames should use "/".
*
* @author Vicente Romero (original)
* @author Jonathan Gibbons (revised)
*/
public class ToolBox {
 /** The platform line separator. */
 public static final String lineSeparator = System.getProperty("line.separator");
 /** The platform OS name. */
 public static final String osName = System.getProperty("os.name");

 /** The location of the class files for this test, or null if not set. */
 public static final String testClasses = System.getProperty("test.classes");
 /** The location of the source files for this test, or null if not set. */
 public static final String testSrc = System.getProperty("test.src");
 /** The location of the test JDK for this test, or null if not set. */
 public static final String testJDK = System.getProperty("test.jdk");
 /** The timeout factor for slow systems. */
 public static final float timeoutFactor;
 static {
 String ttf = System.getProperty("test.timeout.factor");
 timeoutFactor = (ttf == null) ? 1.0f : Float.parseFloat(ttf);
 }

 /** The current directory. */
 public static final Path currDir = Path.of(".");

 /** The stream used for logging output. */
 public PrintStream out = System.err;

 /**
 * Checks if the host OS is some version of Windows.
 * @return true if the host OS is some version of Windows
 */
 public static boolean isWindows() {
 return osName.toLowerCase(Locale.ENGLISH).startsWith("windows");
 }

 /**
 * Splits a string around matches of the given regular expression.
 * If the string is empty, an empty list will be returned.
 *
 * @param text the string to be split
 * @param sep the delimiting regular expression
 * @return the strings between the separators
 */
 public List<String> split(String text, String sep) {
 if (text.isEmpty())
 return Collections.emptyList();
 return Arrays.asList(text.split(sep));
 }

 /**
 * Checks if two lists of strings are equal.
 *
 * @param l1 the first list of strings to be compared
 * @param l2 the second list of strings to be compared
 * @throws Error if the lists are not equal
 */
 public void checkEqual(List<String> l1, List<String> l2) throws Error {
 if (!Objects.equals(l1, l2)) {
 // l1 and l2 cannot both be null
 if (l1 == null)
 throw new Error("comparison failed: l1 is null");
 if (l2 == null)
 throw new Error("comparison failed: l2 is null");
 // report first difference
 for (int i = 0; i < Math.min(l1.size(), l2.size()); i++) {
 String s1 = l1.get(i);
 String s2 = l2.get(i);
 if (!Objects.equals(s1, s2)) {
 throw new Error("comparison failed, index " + i +
 ", (" + s1 + ":" + s2 + ")");
 }
 }
 throw new Error("comparison failed: l1.size=" + l1.size() + ", l2.size=" + l2.size());
 }
 }

 /**
 * Filters a list of strings according to the given regular expression,
 * returning the strings that match the regular expression.
 *
 * @param regex the regular expression
 * @param lines the strings to be filtered
 * @return the strings matching the regular expression
 */
 public List<String> grep(String regex, List<String> lines) {
 return grep(Pattern.compile(regex), lines, true);
 }

 /**
 * Filters a list of strings according to the given regular expression,
 * returning the strings that match the regular expression.
 *
 * @param pattern the regular expression
 * @param lines the strings to be filtered
 * @return the strings matching the regular expression
 */
 public List<String> grep(Pattern pattern, List<String> lines) {
 return grep(pattern, lines, true);
 }

 /**
 * Filters a list of strings according to the given regular expression,
 * returning either the strings that match or the strings that do not match.
 *
 * @param regex the regular expression
 * @param lines the strings to be filtered
 * @param match if true, return the lines that match; otherwise if false, return the lines that do not match.
 * @return the strings matching(or not matching) the regular expression
 */
 public List<String> grep(String regex, List<String> lines, boolean match) {
 return grep(Pattern.compile(regex), lines, match);
 }

 /**
 * Filters a list of strings according to the given regular expression,
 * returning either the strings that match or the strings that do not match.
 *
 * @param pattern the regular expression
 * @param lines the strings to be filtered
 * @param match if true, return the lines that match; otherwise if false, return the lines that do not match.
 * @return the strings matching(or not matching) the regular expression
 */
 public List<String> grep(Pattern pattern, List<String> lines, boolean match) {
 return lines.stream()
 .filter(s -> pattern.matcher(s).find() == match)
 .collect(Collectors.toList());
 }

 /**
 * Copies a file.
 * If the given destination exists and is a directory, the copy is created
 * in that directory. Otherwise, the copy will be placed at the destination,
 * possibly overwriting any existing file.
 * Similar to the shell "cp" command: {@code cp from to}.
 *
 * @param from the file to be copied
 * @param to where to copy the file
 * @throws IOException if any error occurred while copying the file
 */
 public void copyFile(String from, String to) throws IOException {
 copyFile(Path.of(from), Path.of(to));
 }

 /**
 * Copies a file.
 * If the given destination exists and is a directory, the copy is created
 * in that directory. Otherwise, the copy will be placed at the destination,
 * possibly overwriting any existing file.
 * Similar to the shell "cp" command: {@code cp from to}.
 *
 * @param from the file to be copied
 * @param to where to copy the file
 * @throws IOException if an error occurred while copying the file
 */
 public void copyFile(Path from, Path to) throws IOException {
 if (Files.isDirectory(to)) {
 to = to.resolve(from.getFileName());
 } else if (to.getParent() != null) {
 Files.createDirectories(to.getParent());
 }
 Files.copy(from, to, StandardCopyOption.REPLACE_EXISTING);
 }

 /**
 * Copies the contents of a directory to another directory.
 * Similar to the shell command: {@code rsync fromDir/ toDir/}.
 *
 * @param fromDir the directory containing the files to be copied
 * @param toDir the destination to which to copy the files
 */
 public void copyDir(String fromDir, String toDir) {
 copyDir(Path.of(fromDir), Path.of(toDir));
 }

 /**
 * Copies the contents of a directory to another directory.
 * The destination direction should not already exist.
 * Similar to the shell command: {@code rsync fromDir/ toDir/}.
 *
 * @param fromDir the directory containing the files to be copied
 * @param toDir the destination to which to copy the files
 */
 public void copyDir(Path fromDir, Path toDir) {
 try {
 if (toDir.getParent() != null) {
 Files.createDirectories(toDir.getParent());
 }
 Files.walkFileTree(fromDir, new SimpleFileVisitor<Path>() {
 @Override
 public FileVisitResult preVisitDirectory(Path fromSubdir, BasicFileAttributes attrs)
 throws IOException {
 Files.copy(fromSubdir, toDir.resolve(fromDir.relativize(fromSubdir)));
 return FileVisitResult.CONTINUE;
 }

 @Override
 public FileVisitResult visitFile(Path fromFile, BasicFileAttributes attrs)
 throws IOException {
 Files.copy(fromFile, toDir.resolve(fromDir.relativize(fromFile)));
 return FileVisitResult.CONTINUE;
 }
 });
 } catch (IOException e) {
 throw new Error("Could not copy " + fromDir + " to " + toDir + ": " + e, e);
 }
 }

 /**
 * Creates one or more directories.
 * For each of the series of paths, a directory will be created,
 * including any necessary parent directories.
 * Similar to the shell command: {@code mkdir -p paths}.
 *
 * @param paths the directories to be created
 * @throws IOException if an error occurred while creating the directories
 */
 public void createDirectories(String... paths) throws IOException {
 if (paths.length == 0)
 throw new IllegalArgumentException("no directories specified");
 for (String p : paths)
 Files.createDirectories(Path.of(p));
 }

 /**
 * Creates one or more directories.
 * For each of the series of paths, a directory will be created,
 * including any necessary parent directories.
 * Similar to the shell command: {@code mkdir -p paths}.
 *
 * @param paths the directories to be created
 * @throws IOException if an error occurred while creating the directories
 */
 public void createDirectories(Path... paths) throws IOException {
 if (paths.length == 0)
 throw new IllegalArgumentException("no directories specified");
 for (Path p : paths)
 Files.createDirectories(p);
 }

 /**
 * Deletes one or more files, awaiting confirmation that the files
 * no longer exist. Any directories to be deleted must be empty.
 * Similar to the shell command: {@code rm files}.
 *
 * @param files the names of the files to be deleted
 * @throws IOException if an error occurred while deleting the files
 */
 public void deleteFiles(String... files) throws IOException {
 deleteFiles(List.of(files).stream().map(Paths::get).collect(Collectors.toList()));
 }

 /**
 * Deletes one or more files, awaiting confirmation that the files
 * no longer exist. Any directories to be deleted must be empty.
 * Similar to the shell command: {@code rm files}.
 *
 * @param paths the paths for the files to be deleted
 * @throws IOException if an error occurred while deleting the files
 */
 public void deleteFiles(Path... paths) throws IOException {
 deleteFiles(List.of(paths));
 }

 /**
 * Deletes one or more files, awaiting confirmation that the files
 * no longer exist. Any directories to be deleted must be empty.
 * Similar to the shell command: {@code rm files}.
 *
 * @param paths the paths for the files to be deleted
 * @throws IOException if an error occurred while deleting the files
 */
 public void deleteFiles(List<Path> paths) throws IOException {
 if (paths.isEmpty())
 throw new IllegalArgumentException("no files specified");
 IOException ioe = null;
 for (Path path : paths) {
 ioe = deleteFile(path, ioe);
 }
 if (ioe != null) {
 throw ioe;
 }
 ensureDeleted(paths);
 }

 /**
 * Deletes all content of a directory (but not the directory itself),
 * awaiting confirmation that the content has been deleted.
 *
 * @param root the directory to be cleaned
 * @throws IOException if an error occurs while cleaning the directory
 */
 public void cleanDirectory(Path root) throws IOException {
 if (!Files.isDirectory(root)) {
 throw new IOException(root + " is not a directory");
 }
 Files.walkFileTree(root, new SimpleFileVisitor<>() {
 private IOException ioe = null;
 // for each directory we visit, maintain a list of the files that we try to delete
 private final Deque<List<Path>> dirFiles = new LinkedList<>();

 @Override
 public FileVisitResult visitFile(Path file, BasicFileAttributes a) {
 ioe = deleteFile(file, ioe);
 dirFiles.peekFirst().add(file);
 return FileVisitResult.CONTINUE;
 }

 @Override
 public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes a) {
 if (!dir.equals(root)) {
 dirFiles.peekFirst().add(dir);
 }
 dirFiles.addFirst(new ArrayList<>());
 return FileVisitResult.CONTINUE;
 }

 @Override
 public FileVisitResult postVisitDirectory(Path dir, IOException e) throws IOException {
 if (e != null) {
 throw e;
 }
 if (ioe != null) {
 throw ioe;
 }
 ensureDeleted(dirFiles.removeFirst());
 if (!dir.equals(root)) {
 ioe = deleteFile(dir, ioe);
 }
 return FileVisitResult.CONTINUE;
 }
 });
 }

 /**
 * Internal method to delete a file, using {@code Files.delete}.
 * It does not wait to confirm deletion, nor does it retry.
 * If an exception occurs it is either returned or added to the set of
 * suppressed exceptions for an earlier exception.
 *
 * @param path the path for the file to be deleted
 * @param ioe the earlier exception, or null
 * @return the earlier exception or an exception that occurred while
 * trying to delete the file
 */
 private IOException deleteFile(Path path, IOException ioe) {
 try {
 Files.delete(path);
 } catch (IOException e) {
 if (ioe == null) {
 ioe = e;
 } else {
 ioe.addSuppressed(e);
 }
 }
 return ioe;
 }

 /**
 * Wait until it is confirmed that a set of files have been deleted.
 *
 * @param paths the paths for the files to be deleted
 * @throws IOException if a file has not been deleted
 */
 private void ensureDeleted(Collection<Path> paths)
 throws IOException {
 for (Path path : paths) {
 ensureDeleted(path);
 }
 }

 /**
 * Wait until it is confirmed that a file has been deleted.
 *
 * @param path the path for the file to be deleted
 * @throws IOException if problems occur while deleting the file
 */
 private void ensureDeleted(Path path) throws IOException {
 long startTime = System.currentTimeMillis();
 do {
 // Note: Files.notExists is not the same as !Files.exists
 if (Files.notExists(path)) {
 return;
 }
 System.gc(); // allow finalizers and cleaners to run
 try {
 Thread.sleep(RETRY_DELETE_MILLIS);
 } catch (InterruptedException e) {
 throw new IOException("Interrupted while waiting for file to be deleted: " + path, e);
 }
 } while ((System.currentTimeMillis() - startTime) <= MAX_RETRY_DELETE_MILLIS);

 throw new IOException("File not deleted: " + path);
 }

 private static final int RETRY_DELETE_MILLIS = isWindows() ? (int)(500 * timeoutFactor): 0;
 private static final int MAX_RETRY_DELETE_MILLIS = isWindows() ? (int)(15 * 1000 * timeoutFactor) : 0;

 /**
 * Moves a file.
 * If the given destination exists and is a directory, the file will be moved
 * to that directory. Otherwise, the file will be moved to the destination,
 * possibly overwriting any existing file.
 * Similar to the shell "mv" command: {@code mv from to}.
 *
 * @param from the file to be moved
 * @param to where to move the file
 * @throws IOException if an error occurred while moving the file
 */
 public void moveFile(String from, String to) throws IOException {
 moveFile(Path.of(from), Path.of(to));
 }

 /**
 * Moves a file.
 * If the given destination exists and is a directory, the file will be moved
 * to that directory. Otherwise, the file will be moved to the destination,
 * possibly overwriting any existing file.
 * Similar to the shell "mv" command: {@code mv from to}.
 *
 * @param from the file to be moved
 * @param to where to move the file
 * @throws IOException if an error occurred while moving the file
 */
 public void moveFile(Path from, Path to) throws IOException {
 if (Files.isDirectory(to)) {
 to = to.resolve(from.getFileName());
 } else {
 Files.createDirectories(to.getParent());
 }
 Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);
 }

 /**
 * Reads the lines of a file.
 * The file is read using the default character encoding.
 *
 * @param path the file to be read
 * @return the lines of the file
 * @throws IOException if an error occurred while reading the file
 */
 public List<String> readAllLines(String path) throws IOException {
 return readAllLines(path, null);
 }

 /**
 * Reads the lines of a file.
 * The file is read using the default character encoding.
 *
 * @param path the file to be read
 * @return the lines of the file
 * @throws IOException if an error occurred while reading the file
 */
 public List<String> readAllLines(Path path) throws IOException {
 return readAllLines(path, null);
 }

 /**
 * Reads the lines of a file using the given encoding.
 *
 * @param path the file to be read
 * @param encoding the encoding to be used to read the file
 * @return the lines of the file.
 * @throws IOException if an error occurred while reading the file
 */
 public List<String> readAllLines(String path, String encoding) throws IOException {
 return readAllLines(Path.of(path), encoding);
 }

 /**
 * Reads the lines of a file using the given encoding.
 *
 * @param path the file to be read
 * @param encoding the encoding to be used to read the file
 * @return the lines of the file
 * @throws IOException if an error occurred while reading the file
 */
 public List<String> readAllLines(Path path, String encoding) throws IOException {
 return Files.readAllLines(path, getCharset(encoding));
 }

 private Charset getCharset(String encoding) {
 return (encoding == null) ? Charset.defaultCharset() : Charset.forName(encoding);
 }

 /**
 * Find .java files in one or more directories.
 * Similar to the shell "find" command: {@code find paths -name \*.java}.
 *
 * @param paths the directories in which to search for .java files
 * @return the .java files found
 * @throws IOException if an error occurred while searching for files
 */
 public Path[] findJavaFiles(Path... paths) throws IOException {
 return findFiles(".java", paths);
 }

 /**
 * Find files matching the file extension, in one or more directories.
 * Similar to the shell "find" command: {@code find paths -name \*.ext}.
 *
 * @param fileExtension the extension to search for
 * @param paths the directories in which to search for files
 * @return the files matching the file extension
 * @throws IOException if an error occurred while searching for files
 */
 public Path[] findFiles(String fileExtension, Path... paths) throws IOException {
 Set<Path> files = new TreeSet<>(); // use TreeSet to force a consistent order
 for (Path p : paths) {
 Files.walkFileTree(p, new SimpleFileVisitor<>() {
 @Override
 public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
 if (file.getFileName().toString().endsWith(fileExtension)) {
 files.add(file);
 }
 return FileVisitResult.CONTINUE;
 }
 });
 }
 return files.toArray(new Path[0]);
 }

 /**
 * Writes a file containing the given content.
 * Any necessary directories for the file will be created.
 *
 * @param path where to write the file
 * @param content the content for the file
 * @throws IOException if an error occurred while writing the file
 */
 public void writeFile(String path, String content) throws IOException {
 writeFile(Path.of(path), content);
 }

 /**
 * Writes a file containing the given content.
 * Any necessary directories for the file will be created.
 *
 * @param path where to write the file
 * @param content the content for the file
 * @throws IOException if an error occurred while writing the file
 */
 public void writeFile(Path path, String content) throws IOException {
 Path dir = path.getParent();
 if (dir != null)
 Files.createDirectories(dir);
 try (BufferedWriter w = Files.newBufferedWriter(path)) {
 w.write(content);
 }
 }

 /**
 * Writes one or more files containing Java source code.
 * For each file to be written, the filename will be inferred from the
 * given base directory, the package declaration (if present) and from the
 * the name of the first class, interface or enum declared in the file.
 * For example, if the base directory is /my/dir/ and the content
 * contains "package p; class C { }", the file will be written to
 * /my/dir/p/C.java.
 * Note: the content is analyzed using regular expressions;
 * errors can occur if any contents have initial comments that might trip
 * up the analysis.
 *
 * @param dir the base directory
 * @param contents the contents of the files to be written
 * @throws IOException if an error occurred while writing any of the files.
 */
 public void writeJavaFiles(Path dir, String... contents) throws IOException {
 if (contents.length == 0)
 throw new IllegalArgumentException("no content specified for any files");
 for (String c : contents) {
 new JavaSource(c).write(dir);
 }
 }

 /**
 * Returns the path for the binary of a JDK tool within {@link #testJDK}.
 *
 * @param tool the name of the tool
 * @return the path of the tool
 */
 public Path getJDKTool(String tool) {
 return Path.of(testJDK, "bin", tool);
 }

 /**
 * Returns a string representing the contents of an {@code Iterable} as a list.
 *
 * @param <T> the type parameter of the {@code Iterable}
 * @param items the iterable
 * @return the string
 */
 <T> String toString(Iterable<T> items) {
 return StreamSupport.stream(items.spliterator(), false)
 .map(Objects::toString)
 .collect(Collectors.joining(",", "[", "]"));
 }

 /**
 * An in-memory Java source file.
 * It is able to extract the file name from simple source text using
 * regular expressions.
 */
 public static class JavaSource extends SimpleJavaFileObject {
 private final String source;

 /**
 * Creates a in-memory file object for Java source code.
 *
 * @param className the name of the class
 * @param source the source text
 */
 public JavaSource(String className, String source) {
 super(URI.create(className), JavaFileObject.Kind.SOURCE);
 this.source = source;
 }

 /**
 * Creates a in-memory file object for Java source code.
 * The name of the class will be inferred from the source code.
 *
 * @param source the source text
 */
 public JavaSource(String source) {
 super(URI.create(getJavaFileNameFromSource(source)),
 JavaFileObject.Kind.SOURCE);
 this.source = source;
 }

 /**
 * Writes the source code to a file in the current directory.
 *
 * @throws IOException if there is a problem writing the file
 */
 public void write() throws IOException {
 write(currDir);
 }

 /**
 * Writes the source code to a file in a specified directory.
 *
 * @param dir the directory
 * @throws IOException if there is a problem writing the file
 */
 public void write(Path dir) throws IOException {
 Path file = dir.resolve(getJavaFileNameFromSource(source));
 Files.createDirectories(file.getParent());
 try (BufferedWriter out = Files.newBufferedWriter(file)) {
 out.write(source.replace("\n", lineSeparator));
 }
 }

 @Override
 public CharSequence getCharContent(boolean ignoreEncodingErrors) {
 return source;
 }

 private final static Pattern commentPattern =
 Pattern.compile("(?s)(\\s+//.*?\n|/\\*.*?\\*/)");
 private final static Pattern modulePattern =
 Pattern.compile("module\\s+((?:\\w+\\.)*)");
 private final static Pattern packagePattern =
 Pattern.compile("package\\s+(((?:\\w+\\.)*)\\w+)");
 private final static Pattern classPattern =
 Pattern.compile("(?:public\\s+)?(?:class|enum|interface|record)\\s+((\\w|\\$)+)");

 /**
 * Extracts the Java file name from the class declaration.
 * This method is intended for simple files and uses regular expressions.
 * Comments in the source are stripped before looking for the
 * declarations from which the name is derived.
 */
 static String getJavaFileNameFromSource(String source) {
 StringBuilder sb = new StringBuilder();
 Matcher matcher = commentPattern.matcher(source);
 int start = 0;
 while (matcher.find()) {
 sb.append(source, start, matcher.start());
 start = matcher.end();
 }
 sb.append(source.substring(start));
 source = sb.toString();

 String packageName = null;

 matcher = modulePattern.matcher(source);
 if (matcher.find())
 return "module-info.java";

 matcher = packagePattern.matcher(source);
 if (matcher.find()) {
 packageName = matcher.group(1).replace(".", "/");
 validateName(packageName);
 }

 matcher = classPattern.matcher(source);
 if (matcher.find()) {
 String className = matcher.group(1) + ".java";
 validateName(className);
 return (packageName == null) ? className : packageName + "/" + className;
 } else if (packageName != null) {
 return packageName + "/package-info.java";
 } else {
 throw new Error("Could not extract the java class " +
 "name from the provided source");
 }
 }
 }

 /**
 * Extracts the Java file name from the class declaration.
 * This method is intended for simple files and uses regular expressions,
 * so comments matching the pattern can make the method fail.
 *
 * @param source the source text
 * @return the Java file name inferred from the source
 * @deprecated This is a legacy method for compatibility with ToolBox v1.
 * Use {@link JavaSource#getName JavaSource.getName} instead.
 */
 @Deprecated
 public static String getJavaFileNameFromSource(String source) {
 return JavaSource.getJavaFileNameFromSource(source);
 }

 private static final Set<String> RESERVED_NAMES = Set.of(
 "con", "prn", "aux", "nul",
 "com1", "com2", "com3", "com4", "com5", "com6", "com7", "com8", "com9",
 "lpt1", "lpt2", "lpt3", "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9"
 );

 /**
 * Validates if a given name is a valid file name
 * or path name on known platforms.
 *
 * @param name the name
 * @throws IllegalArgumentException if the name is a reserved name
 */
 public static void validateName(String name) {
 for (String part : name.split("[./\\\\]")) {
 if (RESERVED_NAMES.contains(part.toLowerCase(Locale.US))) {
 throw new IllegalArgumentException("Name: " + name + " is" +
 "a reserved name on Windows, " +
 "and will not work!");
 }
 }
 }

 public static class MemoryFileManager extends ForwardingJavaFileManager<JavaFileManager> {
 private interface Content {
 byte[] getBytes();
 String getString();
 }

 /**
 * Maps binary class names to generated content.
 */
 private final Map<Location, Map<String, Content>> files;

 /**
 * Constructs a memory file manager which stores output files in memory,
 * and delegates to a default file manager for input files.
 */
 public MemoryFileManager() {
 this(ToolProvider.getSystemJavaCompiler().getStandardFileManager(null, null, null));
 }

 /**
 * Constructs a memory file manager which stores output files in memory,
 * and delegates to a specified file manager for input files.
 *
 * @param fileManager the file manager to be used for input files
 */
 public MemoryFileManager(JavaFileManager fileManager) {
 super(fileManager);
 files = new HashMap<>();
 }

 @Override
 public JavaFileObject getJavaFileForOutput(Location location,
 String name,
 JavaFileObject.Kind kind,
 FileObject sibling)
 {
 return new MemoryFileObject(location, name, kind);
 }

 /**
 * Returns the set of names of files that have been written to a given
 * location.
 *
 * @param location the location
 * @return the set of file names
 */
 public Set<String> getFileNames(Location location) {
 Map<String, Content> filesForLocation = files.get(location);
 return (filesForLocation == null)
 ? Collections.emptySet() : filesForLocation.keySet();
 }

 /**
 * Returns the content written to a file in a given location,
 * or null if no such file has been written.
 *
 * @param location the location
 * @param name the name of the file
 * @return the content as an array of bytes
 */
 public byte[] getFileBytes(Location location, String name) {
 Content content = getFile(location, name);
 return (content == null) ? null : content.getBytes();
 }

 /**
 * Returns the content written to a file in a given location,
 * or null if no such file has been written.
 *
 * @param location the location
 * @param name the name of the file
 * @return the content as a string
 */
 public String getFileString(Location location, String name) {
 Content content = getFile(location, name);
 return (content == null) ? null : content.getString();
 }

 private Content getFile(Location location, String name) {
 Map<String, Content> filesForLocation = files.get(location);
 return (filesForLocation == null) ? null : filesForLocation.get(name);
 }

 private void save(Location location, String name, Content content) {
 files.computeIfAbsent(location, k -> new HashMap<>())
 .put(name, content);
 }

 /**
 * A writable file object stored in memory.
 */
 private class MemoryFileObject extends SimpleJavaFileObject {
 private final Location location;
 private final String name;

 /**
 * Constructs a memory file object.
 *
 * @param location the location in which to save the file object
 * @param name binary name of the class to be stored in this file object
 * @param kind the kind of file object
 */
 MemoryFileObject(Location location, String name, JavaFileObject.Kind kind) {
 super(URI.create("mfm:///" + name.replace('.','/') + kind.extension),
 Kind.CLASS);
 this.location = location;
 this.name = name;
 }

 @Override
 public OutputStream openOutputStream() {
 return new FilterOutputStream(new ByteArrayOutputStream()) {
 @Override
 public void close() throws IOException {
 out.close();
 byte[] bytes = ((ByteArrayOutputStream) out).toByteArray();
 save(location, name, new Content() {
 @Override
 public byte[] getBytes() {
 return bytes;
 }
 @Override
 public String getString() {
 return new String(bytes);
 }

 });
 }
 };
 }

 @Override
 public Writer openWriter() {
 return new FilterWriter(new StringWriter()) {
 @Override
 public void close() throws IOException {
 out.close();
 String text = out.toString();
 save(location, name, new Content() {
 @Override
 public byte[] getBytes() {
 return text.getBytes();
 }
 @Override
 public String getString() {
 return text;
 }

 });
 }
 };
 }
 }
 }
}

Messung V0.5

¤ Dauer der Verarbeitung: 0.5 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

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 und die Messung sind noch experimentell.