1 /*

     2  * Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 import java.io.BufferedInputStream;

    25 import java.io.BufferedReader;

    26 import java.io.BufferedWriter;

    27 import java.io.ByteArrayInputStream;

    28 import java.io.ByteArrayOutputStream;

    29 import java.io.File;

    30 import java.io.FilterOutputStream;

    31 import java.io.FilterWriter;

    32 import java.io.IOError;

    33 import java.io.IOException;

    34 import java.io.InputStream;

    35 import java.io.InputStreamReader;

    36 import java.io.OutputStream;

    37 import java.io.PrintStream;

    38 import java.io.PrintWriter;

    39 import java.io.StringWriter;

    40 import java.io.Writer;

    41 import java.net.URI;

    42 import java.nio.charset.Charset;

    43 import java.nio.file.FileVisitResult;

    44 import java.nio.file.Files;

    45 import java.nio.file.Path;

    46 import java.nio.file.Paths;

    47 import java.nio.file.SimpleFileVisitor;

    48 import java.nio.file.StandardCopyOption;

    49 import java.nio.file.attribute.BasicFileAttributes;

    50 import java.util.ArrayList;

    51 import java.util.Arrays;

    52 import java.util.Collections;

    53 import java.util.EnumMap;

    54 import java.util.EnumSet;

    55 import java.util.HashMap;

    56 import java.util.LinkedHashSet;

    57 import java.util.List;

    58 import java.util.ListIterator;

    59 import java.util.Locale;

    60 import java.util.Map;

    61 import java.util.Objects;

    62 import java.util.Set;

    63 import java.util.jar.Attributes;

    64 import java.util.jar.JarEntry;

    65 import java.util.jar.JarOutputStream;

    66 import java.util.jar.Manifest;

    67 import java.util.regex.Matcher;

    68 import java.util.regex.Pattern;

    69 import java.util.stream.Collectors;

    70 import java.util.stream.Stream;

    71 import java.util.stream.StreamSupport;

    72 

    73 import javax.tools.FileObject;

    74 import javax.tools.ForwardingJavaFileManager;

    75 import javax.tools.JavaCompiler;

    76 import javax.tools.JavaFileManager;

    77 import javax.tools.JavaFileObject;

    78 import javax.tools.JavaFileObject.Kind;

    79 import javax.tools.JavaFileManager.Location;

    80 import javax.tools.SimpleJavaFileObject;

    81 import javax.tools.StandardJavaFileManager;

    82 import javax.tools.StandardLocation;

    83 

    84 import com.sun.tools.javac.api.JavacTaskImpl;

    85 import com.sun.tools.javac.api.JavacTool;

    86 

    87 /**

    88  * Utility methods and classes for writing jtreg tests for

    89  * javac, javah, javap, and sjavac. (For javadoc support,

    90  * see JavadocTester.)

    91  *

    92  * <p>There is support for common file operations similar to

    93  * shell commands like cat, cp, diff, mv, rm, grep.

    94  *

    95  * <p>There is also support for invoking various tools, like

    96  * javac, javah, javap, jar, java and other JDK tools.

    97  *

    98  * <p><em>File separators</em>: for convenience, many operations accept strings

    99  * to represent filenames. On all platforms on which JDK is supported,

   100  * "/" is a legal filename component separator. In particular, even

   101  * on Windows, where the official file separator is "\", "/" is a legal

   102  * alternative. It is therefore recommended that any client code using

   103  * strings to specify filenames should use "/".

   104  *

   105  * @author Vicente Romero (original)

   106  * @author Jonathan Gibbons (revised)

   107  */

   108 public class ToolBox {

   109     /** The platform line separator. */

   110     public static final String lineSeparator = System.getProperty("line.separator");

   111     /** The platform OS name. */

   112     public static final String osName = System.getProperty("os.name");

   113 

   114     /** The location of the class files for this test, or null if not set. */

   115     public static final String testClasses = System.getProperty("test.classes");

   116     /** The location of the source files for this test, or null if not set. */

   117     public static final String testSrc = System.getProperty("test.src");

   118     /** The location of the test JDK for this test, or null if not set. */

   119     public static final String testJDK = System.getProperty("test.jdk");

   120 

   121     /** The current directory. */

   122     public static final Path currDir = Paths.get(".");

   123 

   124     /** The stream used for logging output. */

   125     public PrintStream out = System.err;

   126 

   127     /**

   128      * Checks if the host OS is some version of Windows.

   129      * @return true if the host OS is some version of Windows

   130      */

   131     public boolean isWindows() {

   132         return osName.toLowerCase(Locale.ENGLISH).startsWith("windows");

   133     }

   134 

   135     /**

   136      * Splits a string around matches of the given regular expression.

   137      * If the string is empty, an empty list will be returned.

   138      * @param text the string to be split

   139      * @param sep  the delimiting regular expression

   140      * @return the strings between the separators

   141      */

   142     public List<String> split(String text, String sep) {

   143         if (text.isEmpty())

   144             return Collections.emptyList();

   145         return Arrays.asList(text.split(sep));

   146     }

   147 

   148     /**

   149      * Checks if two lists of strings are equal.

   150      * @param l1 the first list of strings to be compared

   151      * @param l2 the second list of strings to be compared

   152      * @throws Error if the lists are not equal

   153      */

   154     public void checkEqual(List<String> l1, List<String> l2) throws Error {

   155         if (!Objects.equals(l1, l2)) {

   156             // l1 and l2 cannot both be null

   157             if (l1 == null)

   158                 throw new Error("comparison failed: l1 is null");

   159             if (l2 == null)

   160                 throw new Error("comparison failed: l2 is null");

   161             // report first difference

   162             for (int i = 0; i < Math.min(l1.size(), l2.size()); i++) {

   163                 String s1 = l1.get(i);

   164                 String s2 = l1.get(i);

   165                 if (!Objects.equals(s1, s2)) {

   166                     throw new Error("comparison failed, index " + i +

   167                             ", (" + s1 + ":" + s2 + ")");

   168                 }

   169             }

   170             throw new Error("comparison failed: l1.size=" + l1.size() + ", l2.size=" + l2.size());

   171         }

   172     }

   173 

   174     /**

   175      * Filters a list of strings according to the given regular expression.

   176      * @param regex the regular expression

   177      * @param lines the strings to be filtered

   178      * @return the strings matching the regular expression

   179      */

   180     public List<String> grep(String regex, List<String> lines) {

   181         return grep(Pattern.compile(regex), lines);

   182     }

   183 

   184     /**

   185      * Filters a list of strings according to the given regular expression.

   186      * @param pattern the regular expression

   187      * @param lines the strings to be filtered

   188      * @return the strings matching the regular expression

   189      */

   190     public List<String> grep(Pattern pattern, List<String> lines) {

   191         return lines.stream()

   192                 .filter(s -> pattern.matcher(s).find())

   193                 .collect(Collectors.toList());

   194     }

   195 

   196     /**

   197      * Copies a file.

   198      * If the given destination exists and is a directory, the copy is created

   199      * in that directory.  Otherwise, the copy will be placed at the destination,

   200      * possibly overwriting any existing file.

   201      * <p>Similar to the shell "cp" command: {@code cp from to}.

   202      * @param from the file to be copied

   203      * @param to where to copy the file

   204      * @throws IOException if any error occurred while copying the file

   205      */

   206     public void copyFile(String from, String to) throws IOException {

   207         copyFile(Paths.get(from), Paths.get(to));

   208     }

   209 

   210     /**

   211      * Copies a file.

   212      * If the given destination exists and is a directory, the copy is created

   213      * in that directory.  Otherwise, the copy will be placed at the destination,

   214      * possibly overwriting any existing file.

   215      * <p>Similar to the shell "cp" command: {@code cp from to}.

   216      * @param from the file to be copied

   217      * @param to where to copy the file

   218      * @throws IOException if an error occurred while copying the file

   219      */

   220     public void copyFile(Path from, Path to) throws IOException {

   221         if (Files.isDirectory(to)) {

   222             to = to.resolve(from.getFileName());

   223         } else {

   224             Files.createDirectories(to.getParent());

   225         }

   226         Files.copy(from, to, StandardCopyOption.REPLACE_EXISTING);

   227     }

   228 

   229     /**

   230      * Creates one of more directories.

   231      * For each of the series of paths, a directory will be created,

   232      * including any necessary parent directories.

   233      * <p>Similar to the shell command: {@code mkdir -p paths}.

   234      * @param paths the directories to be created

   235      * @throws IOException if an error occurred while creating the directories

   236      */

   237     public void createDirectories(String... paths) throws IOException {

   238         if (paths.length == 0)

   239             throw new IllegalArgumentException("no directories specified");

   240         for (String p : paths)

   241             Files.createDirectories(Paths.get(p));

   242     }

   243 

   244     /**

   245      * Creates one or more directories.

   246      * For each of the series of paths, a directory will be created,

   247      * including any necessary parent directories.

   248      * <p>Similar to the shell command: {@code mkdir -p paths}.

   249      * @param paths the directories to be created

   250      * @throws IOException if an error occurred while creating the directories

   251      */

   252     public void createDirectories(Path... paths) throws IOException {

   253         if (paths.length == 0)

   254             throw new IllegalArgumentException("no directories specified");

   255         for (Path p : paths)

   256             Files.createDirectories(p);

   257     }

   258 

   259     /**

   260      * Deletes one or more files.

   261      * Any directories to be deleted must be empty.

   262      * <p>Similar to the shell command: {@code rm files}.

   263      * @param files the files to be deleted

   264      * @throws IOException if an error occurred while deleting the files

   265      */

   266     public void deleteFiles(String... files) throws IOException {

   267         if (files.length == 0)

   268             throw new IllegalArgumentException("no files specified");

   269         for (String file : files)

   270             Files.delete(Paths.get(file));

   271     }

   272 

   273     /**

   274      * Deletes all content of a directory (but not the directory itself).

   275      * @param root the directory to be cleaned

   276      */

   277     public void cleanDirectory(Path root) throws IOException {

   278         if (!Files.isDirectory(root)) {

   279             throw new IOException(root + " is not a directory");

   280         }

   281         Files.walkFileTree(root, new SimpleFileVisitor<Path>() {

   282             @Override

   283             public FileVisitResult visitFile(Path file, BasicFileAttributes a) throws IOException {

   284                 Files.delete(file);

   285                 return FileVisitResult.CONTINUE;

   286             }

   287 

   288             @Override

   289             public FileVisitResult postVisitDirectory(Path dir, IOException e) throws IOException {

   290                 if (e != null) {

   291                     throw e;

   292                 }

   293                 if (!dir.equals(root)) {

   294                     Files.delete(dir);

   295                 }

   296                 return FileVisitResult.CONTINUE;

   297             }

   298         });

   299     }

   300 

   301     /**

   302      * Moves a file.

   303      * If the given destination exists and is a directory, the file will be moved

   304      * to that directory.  Otherwise, the file will be moved to the destination,

   305      * possibly overwriting any existing file.

   306      * <p>Similar to the shell "mv" command: {@code mv from to}.

   307      * @param from the file to be moved

   308      * @param to where to move the file

   309      * @throws IOException if an error occurred while moving the file

   310      */

   311     public void moveFile(String from, String to) throws IOException {

   312         moveFile(Paths.get(from), Paths.get(to));

   313     }

   314 

   315     /**

   316      * Moves a file.

   317      * If the given destination exists and is a directory, the file will be moved

   318      * to that directory.  Otherwise, the file will be moved to the destination,

   319      * possibly overwriting any existing file.

   320      * <p>Similar to the shell "mv" command: {@code mv from to}.

   321      * @param from the file to be moved

   322      * @param to where to move the file

   323      * @throws IOException if an error occurred while moving the file

   324      */

   325     public void moveFile(Path from, Path to) throws IOException {

   326         if (Files.isDirectory(to)) {

   327             to = to.resolve(from.getFileName());

   328         } else {

   329             Files.createDirectories(to.getParent());

   330         }

   331         Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);

   332     }

   333 

   334     /**

   335      * Reads the lines of a file.

   336      * The file is read using the default character encoding.

   337      * @param path the file to be read

   338      * @return the lines of the file.

   339      * @throws IOException if an error occurred while reading the file

   340      */

   341     public List<String> readAllLines(String path) throws IOException {

   342         return readAllLines(path, null);

   343     }

   344 

   345     /**

   346      * Reads the lines of a file.

   347      * The file is read using the default character encoding.

   348      * @param path the file to be read

   349      * @return the lines of the file.

   350      * @throws IOException if an error occurred while reading the file

   351      */

   352     public List<String> readAllLines(Path path) throws IOException {

   353         return readAllLines(path, null);

   354     }

   355 

   356     /**

   357      * Reads the lines of a file using the given encoding.

   358      * @param path the file to be read

   359      * @param encoding the encoding to be used to read the file

   360      * @return the lines of the file.

   361      * @throws IOException if an error occurred while reading the file

   362      */

   363     public List<String> readAllLines(String path, String encoding) throws IOException {

   364         return readAllLines(Paths.get(path), encoding);

   365     }

   366 

   367     /**

   368      * Reads the lines of a file using the given encoding.

   369      * @param path the file to be read

   370      * @param encoding the encoding to be used to read the file

   371      * @return the lines of the file.

   372      * @throws IOException if an error occurred while reading the file

   373      */

   374     public List<String> readAllLines(Path path, String encoding) throws IOException {

   375         return Files.readAllLines(path, getCharset(encoding));

   376     }

   377 

   378     private Charset getCharset(String encoding) {

   379         return (encoding == null) ? Charset.defaultCharset() : Charset.forName(encoding);

   380     }

   381 

   382     /**

   383      * Writes a file containing the given content.

   384      * Any necessary directories for the file will be created.

   385      * @param path where to write the file

   386      * @param content the content for the file

   387      * @throws IOException if an error occurred while writing the file

   388      */

   389     public void writeFile(String path, String content) throws IOException {

   390         writeFile(Paths.get(path), content);

   391     }

   392 

   393     /**

   394      * Writes a file containing the given content.

   395      * Any necessary directories for the file will be created.

   396      * @param path where to write the file

   397      * @param content the content for the file

   398      * @throws IOException if an error occurred while writing the file

   399      */

   400     public void writeFile(Path path, String content) throws IOException {

   401         Path dir = path.getParent();

   402         if (dir != null)

   403             Files.createDirectories(dir);

   404         try (BufferedWriter w = Files.newBufferedWriter(path)) {

   405             w.write(content);

   406         }

   407     }

   408 

   409     /**

   410      * Writes one or more files containing Java source code.

   411      * For each file to be written, the filename will be inferred from the

   412      * given base directory, the package declaration (if present) and from the

   413      * the name of the first class, interface or enum declared in the file.

   414      * <p>For example, if the base directory is /my/dir/ and the content

   415      * contains "package p; class C { }", the file will be written to

   416      * /my/dir/p/C.java.

   417      * <p>Note: the content is analyzed using regular expressions;

   418      * errors can occur if any contents have initial comments that might trip

   419      * up the analysis.

   420      * @param dir the base directory

   421      * @param contents the contents of the files to be written

   422      * @throws IOException if an error occurred while writing any of the files.

   423      */

   424     public void writeJavaFiles(Path dir, String... contents) throws IOException {

   425         if (contents.length == 0)

   426             throw new IllegalArgumentException("no content specified for any files");

   427         for (String c : contents) {

   428             new JavaSource(c).write(dir);

   429         }

   430     }

   431 

   432     /**

   433      * Returns the path for the binary of a JDK tool within {@link testJDK}.

   434      * @param tool the name of the tool

   435      * @return the path of the tool

   436      */

   437     public Path getJDKTool(String tool) {

   438         return Paths.get(testJDK, "bin", tool);

   439     }

   440 

   441     /**

   442      * Returns a string representing the contents of an {@code Iterable} as a list.

   443      * @param <T> the type parameter of the {@code Iterable}

   444      * @param items the iterable

   445      * @return the string

   446      */

   447     <T> String toString(Iterable<T> items) {

   448         return StreamSupport.stream(items.spliterator(), false)

   449                 .map(Objects::toString)

   450                 .collect(Collectors.joining(",", "[", "]"));

   451     }

   452 

   453     /**

   454      * The supertype for tasks.

   455      * Complex operations are modelled by building and running a "Task" object.

   456      * Tasks are typically configured in a fluent series of calls.

   457      */

   458     public interface Task {

   459         /**

   460          * Returns the name of the task.

   461          * @return the name of the task

   462          */

   463         String name();

   464 

   465         /**

   466          * Executes the task as currently configured.

   467          * @return a Result object containing the results of running the task

   468          * @throws TaskError if the outcome of the task was not as expected

   469          */

   470         Result run() throws TaskError;

   471     }

   472 

   473     /**

   474      * Exception thrown by {@code Task.run} when the outcome is not as

   475      * expected.

   476      */

   477     public static class TaskError extends Error {

   478         /**

   479          * Creates a TaskError object with the given message.

   480          * @param message the message

   481          */

   482         public TaskError(String message) {

   483             super(message);

   484         }

   485     }

   486 

   487     /**

   488      * An enum to indicate the mode a task should use it is when executed.

   489      */

   490     public enum Mode {

   491         /**

   492          * The task should use the interface used by the command

   493          * line launcher for the task.

   494          * For example, for javac: com.sun.tools.javac.Main.compile

   495          */

   496         CMDLINE,

   497         /**

   498          * The task should use a publicly defined API for the task.

   499          * For example, for javac: javax.tools.JavaCompiler

   500          */

   501         API,

   502         /**

   503          * The task should use the standard launcher for the task.

   504          * For example, $JAVA_HOME/bin/javac

   505          */

   506         EXEC

   507     }

   508 

   509     /**

   510      * An enum to indicate the expected success or failure of executing a task.

   511      */

   512     public enum Expect {

   513         /** It is expected that the task will complete successfully. */

   514         SUCCESS,

   515         /** It is expected that the task will not complete successfully. */

   516         FAIL

   517     }

   518 

   519     /**

   520      * An enum to identify the streams that may be written by a {@code Task}.

   521      */

   522     public enum OutputKind {

   523         /** Identifies output written to {@code System.out} or {@code stdout}. */

   524         STDOUT,

   525         /** Identifies output written to {@code System.err} or {@code stderr}. */

   526         STDERR,

   527         /** Identifies output written to a stream provided directly to the task. */

   528         DIRECT

   529     };

   530 

   531     /**

   532      * The results from running a {@link Task}.

   533      * The results contain the exit code returned when the tool was invoked,

   534      * and a map containing the output written to any streams during the

   535      * execution of the tool.

   536      * All tools support "stdout" and "stderr".

   537      * Tools that take an explicit PrintWriter save output written to that

   538      * stream as "main".

   539      */

   540     public class Result {

   541 

   542         final Task task;

   543         final int exitCode;

   544         final Map<OutputKind, String> outputMap;

   545 

   546         Result(Task task, int exitCode, Map<OutputKind, String> outputMap) {

   547             this.task = task;

   548             this.exitCode = exitCode;

   549             this.outputMap = outputMap;

   550         }

   551 

   552         /**

   553          * Returns the content of a specified stream.

   554          * @param outputKind the kind of the selected stream

   555          * @return the content that was written to that stream when the tool

   556          *  was executed.

   557          */

   558         public String getOutput(OutputKind outputKind) {

   559             return outputMap.get(outputKind);

   560         }

   561 

   562         /**

   563          * Returns the content of named streams as a list of lines.

   564          * @param outputKinds the kinds of the selected streams

   565          * @return the content that was written to the given streams when the tool

   566          *  was executed.

   567          */

   568         public List<String> getOutputLines(OutputKind... outputKinds) {

   569             List<String> result = new ArrayList<>();

   570             for (OutputKind outputKind : outputKinds) {

   571                 result.addAll(Arrays.asList(outputMap.get(outputKind).split(lineSeparator)));

   572             }

   573             return result;

   574         }

   575 

   576         /**

   577          * Writes the content of the specified stream to the log.

   578          * @param kind the kind of the selected stream

   579          * @return this Result object

   580          */

   581         public Result write(OutputKind kind) {

   582             String text = getOutput(kind);

   583             if (text == null || text.isEmpty())

   584                 out.println("[" + task.name() + ":" + kind + "]: empty");

   585             else {

   586                 out.println("[" + task.name() + ":" + kind + "]:");

   587                 out.print(text);

   588             }

   589             return this;

   590         }

   591 

   592         /**

   593          * Writes the content of all streams with any content to the log.

   594          * @return this Result object

   595          */

   596         public Result writeAll() {

   597             outputMap.forEach((name, text) -> {

   598                 if (!text.isEmpty()) {

   599                     out.println("[" + name + "]:");

   600                     out.print(text);

   601                 }

   602             });

   603             return this;

   604         }

   605     }

   606 

   607     /**

   608      * A utility base class to simplify the implementation of tasks.

   609      * Provides support for running the task in a process and for

   610      * capturing output written by the task to stdout, stderr and

   611      * other writers where applicable.

   612      * @param <T> the implementing subclass

   613      */

   614     protected static abstract class AbstractTask<T extends AbstractTask<T>> implements Task {

   615         protected final Mode mode;

   616         private final Map<OutputKind, String> redirects = new EnumMap<>(OutputKind.class);

   617         private final Map<String, String> envVars = new HashMap<>();

   618         private Expect expect = Expect.SUCCESS;

   619         int expectedExitCode = 0;

   620 

   621         /**

   622          * Create a task that will execute in the specified mode.

   623          * @param mode the mode

   624          */

   625         protected AbstractTask(Mode mode) {

   626             this.mode = mode;

   627         }

   628 

   629         /**

   630          * Sets the expected outcome of the task and calls {@code run()}.

   631          * @param expect the expected outcome

   632          * @return the result of calling {@code run()}

   633          */

   634         public Result run(Expect expect) {

   635             expect(expect, Integer.MIN_VALUE);

   636             return run();

   637         }

   638 

   639         /**

   640          * Sets the expected outcome of the task and calls {@code run()}.

   641          * @param expect the expected outcome

   642          * @param exitCode the expected exit code if the expected outcome

   643          *      is {@code FAIL}

   644          * @return the result of calling {@code run()}

   645          */

   646         public Result run(Expect expect, int exitCode) {

   647             expect(expect, exitCode);

   648             return run();

   649         }

   650 

   651         /**

   652          * Sets the expected outcome and expected exit code of the task.

   653          * The exit code will not be checked if the outcome is

   654          * {@code Expect.SUCCESS} or if the exit code is set to

   655          * {@code Integer.MIN_VALUE}.

   656          * @param expect the expected outcome

   657          * @param exitCode the expected exit code

   658          */

   659         protected void expect(Expect expect, int exitCode) {

   660             this.expect = expect;

   661             this.expectedExitCode = exitCode;

   662         }

   663 

   664         /**

   665          * Checks the exit code contained in a {@code Result} against the

   666          * expected outcome and exit value

   667          * @param result the result object

   668          * @return the result object

   669          * @throws TaskError if the exit code stored in the result object

   670          *      does not match the expected outcome and exit code.

   671          */

   672         protected Result checkExit(Result result) throws TaskError {

   673             switch (expect) {

   674                 case SUCCESS:

   675                     if (result.exitCode != 0) {

   676                         result.writeAll();

   677                         throw new TaskError("Task " + name() + " failed: rc=" + result.exitCode);

   678                     }

   679                     break;

   680 

   681                 case FAIL:

   682                     if (result.exitCode == 0) {

   683                         result.writeAll();

   684                         throw new TaskError("Task " + name() + " succeeded unexpectedly");

   685                     }

   686 

   687                     if (expectedExitCode != Integer.MIN_VALUE

   688                             && result.exitCode != expectedExitCode) {

   689                         result.writeAll();

   690                         throw new TaskError("Task " + name() + "failed with unexpected exit code "

   691                             + result.exitCode + ", expected " + expectedExitCode);

   692                     }

   693                     break;

   694             }

   695             return result;

   696         }

   697 

   698         /**

   699          * Sets an environment variable to be used by this task.

   700          * @param name the name of the environment variable

   701          * @param value the value for the environment variable

   702          * @return this task object

   703          * @throws IllegalStateException if the task mode is not {@code EXEC}

   704          */

   705         protected T envVar(String name, String value) {

   706             if (mode != Mode.EXEC)

   707                 throw new IllegalStateException();

   708             envVars.put(name, value);

   709             return (T) this;

   710         }

   711 

   712         /**

   713          * Redirects output from an output stream to a file.

   714          * @param outputKind the name of the stream to be redirected.

   715          * @param path the file

   716          * @return this task object

   717          * @throws IllegalStateException if the task mode is not {@code EXEC}

   718          */

   719         protected T redirect(OutputKind outputKind, String path) {

   720             if (mode != Mode.EXEC)

   721                 throw new IllegalStateException();

   722             redirects.put(outputKind, path);

   723             return (T) this;

   724         }

   725 

   726         /**

   727          * Returns a {@code ProcessBuilder} initialized with any

   728          * redirects and environment variables that have been set.

   729          * @return a {@code ProcessBuilder}

   730          */

   731         protected ProcessBuilder getProcessBuilder() {

   732             if (mode != Mode.EXEC)

   733                 throw new IllegalStateException();

   734             ProcessBuilder pb = new ProcessBuilder();

   735             if (redirects.get(OutputKind.STDOUT) != null)

   736                 pb.redirectOutput(new File(redirects.get(OutputKind.STDOUT)));

   737             if (redirects.get(OutputKind.STDERR) != null)

   738                 pb.redirectError(new File(redirects.get(OutputKind.STDERR)));

   739             pb.environment().putAll(envVars);

   740             return pb;

   741         }

   742 

   743         /**

   744          * Collects the output from a process and saves it in a {@code Result}.

   745          * @param tb the {@code ToolBox} containing the task {@code t}

   746          * @param t the task initiating the process

   747          * @param p the process

   748          * @return a Result object containing the output from the process and its

   749          *      exit value.

   750          * @throws InterruptedException if the thread is interrupted

   751          */

   752         protected Result runProcess(ToolBox tb, Task t, Process p) throws InterruptedException {

   753             if (mode != Mode.EXEC)

   754                 throw new IllegalStateException();

   755             ProcessOutput sysOut = new ProcessOutput(p.getInputStream()).start();

   756             ProcessOutput sysErr = new ProcessOutput(p.getErrorStream()).start();

   757             sysOut.waitUntilDone();

   758             sysErr.waitUntilDone();

   759             int rc = p.waitFor();

   760             Map<OutputKind, String> outputMap = new EnumMap<>(OutputKind.class);

   761             outputMap.put(OutputKind.STDOUT, sysOut.getOutput());

   762             outputMap.put(OutputKind.STDERR, sysErr.getOutput());

   763             return checkExit(tb.new Result(t, rc, outputMap));

   764         }

   765 

   766         /**

   767          * Thread-friendly class to read the output from a process until the stream

   768          * is exhausted.

   769          */

   770         static class ProcessOutput implements Runnable {

   771             ProcessOutput(InputStream from) {

   772                 in = new BufferedReader(new InputStreamReader(from));

   773                 out = new StringBuilder();

   774             }

   775 

   776             ProcessOutput start() {

   777                 new Thread(this).start();

   778                 return this;

   779             }

   780 

   781             @Override

   782             public void run() {

   783                 try {

   784                     String line;

   785                     while ((line = in.readLine()) != null) {

   786                         out.append(line).append(lineSeparator);

   787                     }

   788                 } catch (IOException e) {

   789                 }

   790                 synchronized (this) {

   791                     done = true;

   792                     notifyAll();

   793                 }

   794             }

   795 

   796             synchronized void waitUntilDone() throws InterruptedException {

   797                 boolean interrupted = false;

   798 

   799                 // poll interrupted flag, while waiting for copy to complete

   800                 while (!(interrupted = Thread.interrupted()) && !done)

   801                     wait(1000);

   802 

   803                 if (interrupted)

   804                     throw new InterruptedException();

   805             }

   806 

   807             String getOutput() {

   808                 return out.toString();

   809             }

   810 

   811             private BufferedReader in;

   812             private final StringBuilder out;

   813             private boolean done;

   814         }

   815 

   816         /**

   817          * Utility class to simplify the handling of temporarily setting a

   818          * new stream for System.out or System.err.

   819          */

   820         static class StreamOutput {

   821             // Functional interface to set a stream.

   822             // Expected use: System::setOut, System::setErr

   823             private interface Initializer {

   824                 void set(PrintStream s);

   825             }

   826 

   827             private final ByteArrayOutputStream baos = new ByteArrayOutputStream();

   828             private final PrintStream ps = new PrintStream(baos);

   829             private final PrintStream prev;

   830             private final Initializer init;

   831 

   832             StreamOutput(PrintStream s, Initializer init) {

   833                 prev = s;

   834                 init.set(ps);

   835                 this.init = init;

   836             }

   837 

   838             /**

   839              * Closes the stream and returns the contents that were written to it.

   840              * @return the contents that were written to it.

   841              */

   842             String close() {

   843                 init.set(prev);

   844                 ps.close();

   845                 return baos.toString();

   846             }

   847         }

   848 

   849         /**

   850          * Utility class to simplify the handling of creating an in-memory PrintWriter.

   851          */

   852         static class WriterOutput {

   853             private final StringWriter sw = new StringWriter();

   854             final PrintWriter pw = new PrintWriter(sw);

   855 

   856             /**

   857              * Closes the stream and returns the contents that were written to it.

   858              * @return the contents that were written to it.

   859              */

   860             String close() {

   861                 pw.close();

   862                 return sw.toString();

   863             }

   864         }

   865     }

   866 

   867     /**

   868      * A task to configure and run the Java compiler, javac.

   869      */

   870     public class JavacTask extends AbstractTask<JavacTask> {

   871         private boolean includeStandardOptions;

   872         private List<Path> classpath;

   873         private List<Path> sourcepath;

   874         private Path outdir;

   875         private List<String> options;

   876         private List<String> classes;

   877         private List<String> files;

   878         private List<JavaFileObject> fileObjects;

   879         private JavaFileManager fileManager;

   880 

   881         private JavaCompiler compiler;

   882         private StandardJavaFileManager internalFileManager;

   883 

   884         /**

   885          * Creates a task to execute {@code javac} using API mode.

   886          */

   887         public JavacTask() {

   888             super(Mode.API);

   889         }

   890 

   891         /**

   892          * Creates a task to execute {@code javac} in a specified mode.

   893          * @param mode the mode to be used

   894          */

   895         public JavacTask(Mode mode) {

   896             super(mode);

   897         }

   898 

   899         /**

   900          * Sets the classpath.

   901          * @param classpath the classpath

   902          * @return this task object

   903          */

   904         public JavacTask classpath(String classpath) {

   905             this.classpath = Stream.of(classpath.split(File.pathSeparator))

   906                     .filter(s -> !s.isEmpty())

   907                     .map(s -> Paths.get(s))

   908                     .collect(Collectors.toList());

   909             return this;

   910         }

   911 

   912         /**

   913          * Sets the classpath.

   914          * @param classpath the classpath

   915          * @return this task object

   916          */

   917         public JavacTask classpath(Path... classpath) {

   918             this.classpath = Arrays.asList(classpath);

   919             return this;

   920         }

   921 

   922         /**

   923          * Sets the sourcepath.

   924          * @param sourcepath the sourcepath

   925          * @return this task object

   926          */

   927         public JavacTask sourcepath(String sourcepath) {

   928             this.sourcepath = Stream.of(sourcepath.split(File.pathSeparator))

   929                     .filter(s -> !s.isEmpty())

   930                     .map(s -> Paths.get(s))

   931                     .collect(Collectors.toList());

   932             return this;

   933         }

   934 

   935         /**

   936          * Sets the sourcepath.

   937          * @param classpath the sourcepath

   938          * @return this task object

   939          */

   940         public JavacTask sourcepath(Path... sourcepath) {

   941             this.sourcepath = Arrays.asList(sourcepath);

   942             return this;

   943         }

   944 

   945         /**

   946          * Sets the output directory.

   947          * @param outdir the output directory

   948          * @return this task object

   949          */

   950         public JavacTask outdir(String outdir) {

   951             this.outdir = Paths.get(outdir);

   952             return this;

   953         }

   954 

   955         /**

   956          * Sets the output directory.

   957          * @param outdir the output directory

   958          * @return this task object

   959          */

   960         public JavacTask outdir(Path outdir) {

   961             this.outdir = outdir;

   962             return this;

   963         }

   964 

   965         /**

   966          * Sets the options.

   967          * @param options the options

   968          * @return this task object

   969          */

   970         public JavacTask options(String... options) {

   971             this.options = Arrays.asList(options);

   972             return this;

   973         }

   974 

   975         /**

   976          * Sets the classes to be analyzed.

   977          * @param classes the classes

   978          * @return this task object

   979          */

   980         public JavacTask classes(String... classes) {

   981             this.classes = Arrays.asList(classes);

   982             return this;

   983         }

   984 

   985         /**

   986          * Sets the files to be compiled or analyzed.

   987          * @param files the files

   988          * @return this task object

   989          */

   990         public JavacTask files(String... files) {

   991             this.files = Arrays.asList(files);

   992             return this;

   993         }

   994 

   995         /**

   996          * Sets the files to be compiled or analyzed.

   997          * @param files the files

   998          * @return this task object

   999          */

  1000         public JavacTask files(Path... files) {

  1001             this.files = Stream.of(files)

  1002                     .map(Path::toString)

  1003                     .collect(Collectors.toList());

  1004             return this;

  1005         }

  1006 

  1007         /**

  1008          * Sets the sources to be compiled or analyzed.

  1009          * Each source string is converted into an in-memory object that

  1010          * can be passed directly to the compiler.

  1011          * @param sources the sources

  1012          * @return this task object

  1013          */

  1014         public JavacTask sources(String... sources) {

  1015             fileObjects = Stream.of(sources)

  1016                     .map(s -> new JavaSource(s))

  1017                     .collect(Collectors.toList());

  1018             return this;

  1019         }

  1020 

  1021         /**

  1022          * Sets the file manager to be used by this task.

  1023          * @param fileManager the file manager

  1024          * @return this task object

  1025          */

  1026         public JavacTask fileManager(JavaFileManager fileManager) {

  1027             this.fileManager = fileManager;

  1028             return this;

  1029         }

  1030 

  1031         /**

  1032          * {@inheritDoc}

  1033          * @return the name "javac"

  1034          */

  1035         @Override

  1036         public String name() {

  1037             return "javac";

  1038         }

  1039 

  1040         /**

  1041          * Calls the compiler with the arguments as currently configured.

  1042          * @return a Result object indicating the outcome of the compilation

  1043          * and the content of any output written to stdout, stderr, or the

  1044          * main stream by the compiler.

  1045          * @throws TaskError if the outcome of the task is not as expected.

  1046          */

  1047         @Override

  1048         public Result run() {

  1049             if (mode == Mode.EXEC)

  1050                 return runExec();

  1051 

  1052             WriterOutput direct = new WriterOutput();

  1053             // The following are to catch output to System.out and System.err,

  1054             // in case these are used instead of the primary (main) stream

  1055             StreamOutput sysOut = new StreamOutput(System.out, System::setOut);

  1056             StreamOutput sysErr = new StreamOutput(System.err, System::setErr);

  1057             int rc;

  1058             Map<OutputKind, String> outputMap = new HashMap<>();

  1059             try {

  1060                 switch (mode == null ? Mode.API : mode) {

  1061                     case API:

  1062                         rc = runAPI(direct.pw);

  1063                         break;

  1064                     case CMDLINE:

  1065                         rc = runCommand(direct.pw);

  1066                         break;

  1067                     default:

  1068                         throw new IllegalStateException();

  1069                 }

  1070             } catch (IOException e) {

  1071                 out.println("Exception occurred: " + e);

  1072                 rc = 99;

  1073             } finally {

  1074                 outputMap.put(OutputKind.STDOUT, sysOut.close());

  1075                 outputMap.put(OutputKind.STDERR, sysErr.close());

  1076                 outputMap.put(OutputKind.DIRECT, direct.close());

  1077             }

  1078             return checkExit(new Result(this, rc, outputMap));

  1079         }

  1080 

  1081         private int runAPI(PrintWriter pw) throws IOException {

  1082             try {

  1083 //                if (compiler == null) {

  1084                     // TODO: allow this to be set externally

  1085 //                    compiler = ToolProvider.getSystemJavaCompiler();

  1086                     compiler = JavacTool.create();

  1087 //                }

  1088 

  1089                 if (fileManager == null)

  1090                     fileManager = internalFileManager = compiler.getStandardFileManager(null, null, null);

  1091                 if (outdir != null)

  1092                     setLocationFromPaths(StandardLocation.CLASS_OUTPUT, Collections.singletonList(outdir));

  1093                 if (classpath != null)

  1094                     setLocationFromPaths(StandardLocation.CLASS_PATH, classpath);

  1095                 if (sourcepath != null)

  1096                     setLocationFromPaths(StandardLocation.SOURCE_PATH, sourcepath);

  1097                 List<String> allOpts = new ArrayList<>();

  1098                 if (options != null)

  1099                     allOpts.addAll(options);

  1100 

  1101                 Iterable<? extends JavaFileObject> allFiles = joinFiles(files, fileObjects);

  1102                 JavaCompiler.CompilationTask task = compiler.getTask(pw,

  1103                         fileManager,

  1104                         null,  // diagnostic listener; should optionally collect diags

  1105                         allOpts,

  1106                         classes,

  1107                         allFiles);

  1108                 return ((JavacTaskImpl) task).doCall().exitCode;

  1109             } finally {

  1110                 if (internalFileManager != null)

  1111                     internalFileManager.close();

  1112             }

  1113         }

  1114 

  1115         private void setLocationFromPaths(StandardLocation location, List<Path> files) throws IOException {

  1116             if (!(fileManager instanceof StandardJavaFileManager))

  1117                 throw new IllegalStateException("not a StandardJavaFileManager");

  1118             ((StandardJavaFileManager) fileManager).setLocationFromPaths(location, files);

  1119         }

  1120 

  1121         private int runCommand(PrintWriter pw) {

  1122             List<String> args = getAllArgs();

  1123             String[] argsArray = args.toArray(new String[args.size()]);

  1124             return com.sun.tools.javac.Main.compile(argsArray, pw);

  1125         }

  1126 

  1127         private Result runExec() {

  1128             List<String> args = new ArrayList<>();

  1129             Path javac = getJDKTool("javac");

  1130             args.add(javac.toString());

  1131             if (includeStandardOptions) {

  1132                 args.addAll(split(System.getProperty("test.tool.vm.opts"), " +"));

  1133                 args.addAll(split(System.getProperty("test.compiler.opts"), " +"));

  1134             }

  1135             args.addAll(getAllArgs());