/*

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

import java.io.BufferedWriter;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FilterOutputStream;

import java.io.FilterWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.PrintStream;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.io.Writer;

import java.net.URI;

import java.nio.charset.Charset;

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.Collections;

import java.util.EnumMap;

import java.util.HashMap;

import java.util.List;

import java.util.ListIterator;

import java.util.Locale;

import java.util.Map;

import java.util.Objects;

import java.util.jar.Attributes;

import java.util.jar.JarEntry;

import java.util.jar.JarOutputStream;

import java.util.jar.Manifest;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

import javax.tools.FileObject;

import javax.tools.ForwardingJavaFileManager;

import javax.tools.JavaCompiler;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import javax.tools.SimpleJavaFileObject;

import javax.tools.StandardJavaFileManager;

import javax.tools.StandardLocation;

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

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

import java.io.IOError;

/**

 * Utility methods and classes for writing jtreg tests for

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

 * see JavadocTester.)

 *

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

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

 *

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

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

 *

 * <p><em>File separators</em>: 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 current directory. */

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

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

    public PrintStream out = System.err;

    JavaCompiler compiler;

    StandardJavaFileManager standardJavaFileManager;

    /**

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

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

     */

    public 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 = l1.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.

     * @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);

    }

    /**

     * Filters a list of strings according to the given 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 lines.stream()

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

                .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.

     * <p>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(Paths.get(from), Paths.get(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.

     * <p>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 {

            Files.createDirectories(to.getParent());

        }

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

    }

    /**

     * Creates one of more directories.

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

     * including any necessary parent directories.

     * <p>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(Paths.get(p));

    }

    /**

     * Creates one or more directories.

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

     * including any necessary parent directories.

     * <p>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.

     * Any directories to be deleted must be empty.

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

     * @param files the files to be deleted

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

     */

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

        if (files.length == 0)

            throw new IllegalArgumentException("no files specified");

        for (String file: files)

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

    }

    /**

     * 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.

     * <p>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(Paths.get(from), Paths.get(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.

     * <p>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(Paths.get(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);

    }

    /**

     * 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(Paths.get(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.

     * <p>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.

     * <p>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 Paths.get(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(",", "[", "]"));

    }

    /**

     * The supertype for tasks.

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

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

     */

    public interface Task {

        /**

         * Returns the name of the task.

         * @return the name of the task

         */

        String name();

        /**

         * Executes the task as currently configured.

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

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

         */

        Result run() throws TaskError;

    }

    /**

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

     * expected.

     */

    public static class TaskError extends Error {

        /**

         * Creates a TaskError object with the given message.

         * @param message the message

         */

        public TaskError(String message) {

            super(message);

        }

    }

    /**

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

     */

    public enum Mode {

        /**

         * The task should use the interface used by the command

         * line launcher for the task.

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

         */

        CMDLINE,

        /**

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

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

         */

        API,

        /**

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

         * For example, $JAVA_HOME/bin/javac

         */

        EXEC

    }

    /**

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

     */

    public enum Expect {

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

        SUCCESS,

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

        FAIL

    }

    /**

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

     */

    public enum OutputKind {

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

        STDOUT,

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

        STDERR,

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

        DIRECT

    };

    /**

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

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

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

     * execution of the tool.

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

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

     * stream as "main".

     */

    public class Result {

        final Task task;

        final int exitCode;

        final Map<OutputKind, String> outputMap;

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

            this.task = task;

            this.exitCode = exitCode;

            this.outputMap = outputMap;

        }

        /**

         * Returns the content of a specified stream.

         * @param outputKind the kind of the selected stream

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

         *  was executed.

         */

        public String getOutput(OutputKind outputKind) {

            return outputMap.get(outputKind);

        }