/*

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

 */

/*

 * @test

 * @bug 7026941

 * @summary path options ignored when reusing filemanager across tasks

 */

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.PrintWriter;

import java.net.URI;

import java.nio.file.Files;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.EnumSet;

import java.util.List;

import java.util.Objects;

import java.util.jar.JarEntry;

import java.util.jar.JarOutputStream;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import javax.tools.JavaCompiler;

import javax.tools.JavaCompiler.CompilationTask;

import javax.tools.JavaFileObject;

import javax.tools.SimpleJavaFileObject;

import javax.tools.StandardJavaFileManager;

import javax.tools.StandardLocation;

import javax.tools.ToolProvider;

import static javax.tools.StandardLocation.*;

/**

 * Test for combinations of using javac command-line options and fileManager setLocation

 * calls to affect the locations available in the fileManager.

 *

 * Using a single Java compiler and file manager, for each of the standard locations,

 * a series of operations is performed, using either compiler options or setLocation

 * calls. Each operation includes a compilation, and then a check for the value of

 * the standard location available in the file manager.

 *

 * The operations generate and use unique files to minimize the possibility of false

 * positive results.

 */

public class TestSearchPaths {

    public static void main(String... args) throws Exception {

        TestSearchPaths t = new TestSearchPaths();

        t.run();

    }

    void run() throws Exception {

        compiler = ToolProvider.getSystemJavaCompiler();

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

        try {

            // basic output path

            testClassOutput();

            // basic search paths

            testClassPath();

            testSourcePath();

            testPlatformClassPath();

            // annotation processing

            testAnnotationProcessorPath();

            testSourceOutput();

            // javah equivalent

            testNativeHeaderOutput();

            // future-proof: guard against new StandardLocations being added

            if (!tested.equals(EnumSet.allOf(StandardLocation.class))) {

                error("not all standard locations have been tested");

                out.println("not yet tested: " + EnumSet.complementOf(tested));

            }

            if (errors > 0) {

                throw new Exception(errors + " errors occurred");

            }

        } finally {

            fileManager.close();

        }

    }

    void testClassOutput() throws IOException {

        String test = "testClassOutput";

        System.err.println("test: " + test);

        for (int i = 1; i <= 5; i++) {

            File classes = createDir(test + "/" + i + "/classes");

            List<String> options;

            switch (i) {

                default:

                    options = getOptions("-d", classes.getPath());

                    break;

                case 3:

                    setLocation(CLASS_OUTPUT, classes);

                    options = null;

                    break;

            }

            List<JavaFileObject> sources = getSources("class C" + i + " { }");

            callTask(options, sources);

            checkPath(CLASS_OUTPUT, Mode.EQUALS, classes);

            checkFile(CLASS_OUTPUT, "C" + i + ".class");

        }

        tested.add(CLASS_OUTPUT);

    }

    void testClassPath() throws IOException {

        String test = "testClassPath";

        System.err.println("test: " + test);

        for (int i = 1; i <= 5; i++) {

            File classes = createDir(test + "/" + i + "/classes");

            File classpath = new File("testClassOutput/" + i + "/classes");

            List<String> options;

            switch (i) {

                default:

                    options = getOptions("-d", classes.getPath(), "-classpath", classpath.getPath());

                    break;

                case 3:

                    setLocation(CLASS_PATH, classpath);

                    options = getOptions("-d", classes.getPath());

                    break;

                case 4:

                    options = getOptions("-d", classes.getPath(), "-cp", classpath.getPath());

                    break;

            }

            List<JavaFileObject> sources = getSources("class D" + i + " { C" + i + " c; }");

            callTask(options, sources);

            checkPath(CLASS_PATH, Mode.EQUALS, classpath);

            checkFile(CLASS_OUTPUT, "D" + i + ".class");

        }

        tested.add(CLASS_PATH);

        System.err.println();

    }

    void testSourcePath() throws IOException {

        String test = "testSourcePath";

        System.err.println("test: " + test);

        setLocation(CLASS_PATH); // empty

        for (int i = 1; i <= 5; i++) {

            File src = createDir(test + "/" + i + "/src");

            writeFile(src, "C" + i + ".java", "class C" + i + "{ }");

            File classes = createDir(test + "/" + i + "/classes");

            File srcpath = src;

            List<String> options;

            switch (i) {

                default:

                    options = getOptions("-d", classes.getPath(), "-sourcepath", srcpath.getPath());

                    break;

                case 3:

                    setLocation(SOURCE_PATH, srcpath);

                    options = getOptions("-d", classes.getPath());

                    break;

            }

            List<JavaFileObject> sources = getSources("class D" + i + " { C" + i + " c; }");

            callTask(options, sources);

            checkPath(SOURCE_PATH, Mode.EQUALS, srcpath);

            checkFile(CLASS_OUTPUT, "D" + i + ".class");

        }

        tested.add(SOURCE_PATH);

        System.err.println();

    }

    void testPlatformClassPath() throws IOException {

        String test = "testPlatformClassPath";

        System.err.println("test: " + test);

        List<File> defaultPath = getLocation(PLATFORM_CLASS_PATH);

        StringBuilder sb = new StringBuilder();

        for (File f: defaultPath) {

            if (sb.length() > 0)

                sb.append(File.pathSeparator);

            sb.append(f);

        }

        String defaultPathString = sb.toString();

        setLocation(CLASS_PATH); // empty

        setLocation(SOURCE_PATH); // empty

        // FIXME: temporarily exclude cases referring to default bootclasspath

        // for (int i = 1; i <= 10; i++) {

        int[] cases = new int[] { 1, 2, 4, 5, 6, 7 };

        for (int i : cases) {

            File classes = createDir(test + "/" + i + "/classes");

            File testJars = createDir(test + "/" + i + "/testJars");

            File testClasses = createDir(test + "/" + i + "/testClasses");

            callTask(getOptions("-d", testClasses.getPath()), getSources("class C" + i + " { }"));

            List<String> options;

            Mode mode;

            List<File> match;

            String reference = "C" + i + " c;";

            File jar;

            switch (i) {

                case 1:

                    options = getOptions("-d", classes.getPath(), "-Xbootclasspath/p:" + testClasses);

                    mode = Mode.STARTS_WITH;

                    match = Arrays.asList(testClasses);

                    break;

                case 2:

                    // the default values for -extdirs and -endorseddirs come after the bootclasspath;

                    // so to check -Xbootclasspath/a: we specify empty values for those options.

                    options = getOptions("-d", classes.getPath(),

                            "-Xbootclasspath/a:" + testClasses,

                            "-extdirs", "",

                            "-endorseddirs", "");

                    mode = Mode.ENDS_WITH;

                    match = Arrays.asList(testClasses);

                    break;

                case 3:

                    options = getOptions("-d", classes.getPath(), "-Xbootclasspath:" + defaultPathString);

                    mode = Mode.EQUALS;

                    match = defaultPath;

                    reference = "";

                    break;

                case 4:

                    fileManager.setLocation(PLATFORM_CLASS_PATH, null);

                    jar = new File(testJars, "j" + i + ".jar");

                    writeJar(jar, testClasses, "C" + i + ".class");

                    options = getOptions("-d", classes.getPath(), "-endorseddirs", testJars.getPath());

                    mode = Mode.CONTAINS;

                    match = Arrays.asList(jar);

                    break;

                case 5:

                    fileManager.setLocation(PLATFORM_CLASS_PATH, null);

                    jar = new File(testJars, "j" + i + ".jar");

                    writeJar(jar, testClasses, "C" + i + ".class");

                    options = getOptions("-d", classes.getPath(), "-Djava.endorsed.dirs=" + testJars.getPath());

                    mode = Mode.CONTAINS;

                    match = Arrays.asList(jar);

                    break;

                case 6:

                    fileManager.setLocation(PLATFORM_CLASS_PATH, null);

                    jar = new File(testJars, "j" + i + ".jar");

                    writeJar(jar, testClasses, "C" + i + ".class");

                    options = getOptions("-d", classes.getPath(), "-extdirs", testJars.getPath());

                    mode = Mode.CONTAINS;

                    match = Arrays.asList(jar);

                    break;

                case 7:

                    fileManager.setLocation(PLATFORM_CLASS_PATH, null);

                    jar = new File(testJars, "j" + i + ".jar");

                    writeJar(jar, testClasses, "C" + i + ".class");

                    options = getOptions("-d", classes.getPath(), "-Djava.ext.dirs=" + testJars.getPath());

                    mode = Mode.CONTAINS;

                    match = Arrays.asList(jar);

                    break;

                case 8:

                    setLocation(PLATFORM_CLASS_PATH, defaultPath);

                    options = getOptions("-d", classes.getPath());

                    mode = Mode.EQUALS;

                    match = defaultPath;

                    reference = "";

                    break;

                default:

                    options = getOptions("-d", classes.getPath(), "-bootclasspath", defaultPathString);

                    mode = Mode.EQUALS;

                    match = defaultPath;

                    reference = "";

                    break;

            }

            List<JavaFileObject> sources = getSources("class D" + i + " { " + reference + " }");

            callTask(options, sources);

            checkPath(PLATFORM_CLASS_PATH, mode, match);

            checkFile(CLASS_OUTPUT, "D" + i + ".class");

        }

        tested.add(PLATFORM_CLASS_PATH);

        System.err.println();

    }

    void testAnnotationProcessorPath() throws IOException {

        String test = "testAnnotationProcessorPath";

        System.err.println("test: " + test);

        fileManager.setLocation(PLATFORM_CLASS_PATH, null);

        String template =

                "import java.util.*;\n"

                + "import javax.annotation.processing.*;\n"

                + "import javax.lang.model.*;\n"

                + "import javax.lang.model.element.*;\n"

                + "@SupportedAnnotationTypes(\"*\")\n"

                + "public class A%d extends AbstractProcessor {\n"

                + "    public boolean process(Set<? extends TypeElement> annos, RoundEnvironment rEnv) {\n"

                + "        return true;\n"

                + "    }\n"

                + "    public SourceVersion getSupportedSourceVersion() {\n"

                + "        return SourceVersion.latest();\n"

                + "    }\n"

                + "}";

        for (int i = 1; i <= 5; i++) {

            File classes = createDir(test + "/" + i + "/classes");

            File annodir = createDir(test + "/" + i + "/processors");

            callTask(getOptions("-d", annodir.getPath()), getSources(String.format(template, i)));

            File annopath = annodir;

            List<String> options;

            switch (i) {

                default:

                    options = getOptions("-d", classes.getPath(),

                            "-processorpath", annopath.getPath(),

                            "-processor", "A" + i);

                    break;

                case 3:

                    setLocation(ANNOTATION_PROCESSOR_PATH, annopath);

                    options = getOptions("-d", classes.getPath(),

                            "-processor", "A" + i);

                    break;

            }

            List<JavaFileObject> sources = getSources("class D" + i + " { }");

            callTask(options, sources);

            checkPath(ANNOTATION_PROCESSOR_PATH, Mode.EQUALS, annopath);

            checkFile(CLASS_OUTPUT, "D" + i + ".class");

        }

        tested.add(ANNOTATION_PROCESSOR_PATH);

        System.err.println();

    }

    void testSourceOutput() throws IOException {

        String test = "testAnnotationProcessorPath";

        System.err.println("test: " + test);

        String source =

                "import java.io.*;\n"

                + "import java.util.*;\n"

                + "import javax.annotation.processing.*;\n"

                + "import javax.lang.model.*;\n"

                + "import javax.lang.model.element.*;\n"

                + "import javax.tools.*;\n"

                + "@SupportedOptions(\"name\")\n"

                + "@SupportedAnnotationTypes(\"*\")\n"

                + "public class A extends AbstractProcessor {\n"

                + "    int round = 0;\n"

                + "    public boolean process(Set<? extends TypeElement> annos, RoundEnvironment rEnv) {\n"

                + "        if (round++ == 0) try {\n"

                + "            String name = processingEnv.getOptions().get(\"name\");\n"

                + "            JavaFileObject fo = processingEnv.getFiler().createSourceFile(name);\n"

                + "            try (Writer out = fo.openWriter()) {\n"

                + "                out.write(\"class \" + name + \" { }\");\n"

                + "            }\n"

                + "        } catch (IOException e) { throw new Error(e); }\n"

                + "        return true;\n"

                + "    }\n"

                + "    public SourceVersion getSupportedSourceVersion() {\n"

                + "        return SourceVersion.latest();\n"

                + "    }\n"

                + "}";

        File annodir = createDir(test + "/processors");

        callTask(getOptions("-d", annodir.getPath()), getSources(source));

        setLocation(ANNOTATION_PROCESSOR_PATH, annodir);

        for (int i = 1; i <= 5; i++) {

            File classes = createDir(test + "/" + i + "/classes");

            File genSrc = createDir(test + "/" + "/genSrc");

            List<String> options;

            switch (i) {

                default:

                    options = getOptions("-d", classes.getPath(),

                            "-processor", "A", "-Aname=G" + i,

                            "-s", genSrc.getPath());

                    break;

                case 3:

                    setLocation(SOURCE_OUTPUT, genSrc);

                    options = getOptions("-d", classes.getPath(),

                            "-processor", "A", "-Aname=G" + i);

                    break;

            }

            List<JavaFileObject> sources = getSources("class D" + i + " { }");

            callTask(options, sources);

            checkPath(SOURCE_OUTPUT, Mode.EQUALS, genSrc);

            checkFile(CLASS_OUTPUT, "D" + i + ".class");

            checkFile(CLASS_OUTPUT, "G" + i + ".class");

        }

        tested.add(SOURCE_OUTPUT);

        System.err.println();

    }

    void testNativeHeaderOutput() throws IOException {

        String test = "testNativeHeaderOutput";

        System.err.println("test: " + test);

        for (int i = 1; i <= 5; i++) {

            File classes = createDir(test + "/" + i + "/classes");

            File headers = createDir(test + "/" + i + "/hdrs");

            List<String> options;

            switch (i) {

                default:

                    options = getOptions("-d", classes.getPath(), "-h", headers.getPath());

                    break;

                case 3:

                    setLocation(NATIVE_HEADER_OUTPUT, headers);

                    options = getOptions("-d", classes.getPath());

                    break;

            }

            List<JavaFileObject> sources = getSources("class C" + i + " { native void m(); }");

            callTask(options, sources);

            checkPath(NATIVE_HEADER_OUTPUT, Mode.EQUALS, headers);

            checkFile(NATIVE_HEADER_OUTPUT, "C" + i + ".h");

        }

        tested.add(StandardLocation.NATIVE_HEADER_OUTPUT);

        System.err.println();

    }

    List<String> getOptions(String... args) {

        return Arrays.asList(args);

    }

    List<JavaFileObject> getSources(String... sources) {

        List<JavaFileObject> list = new ArrayList<>();

        for (String s: sources)

            list.add(getSource(s));

        return list;

    }

    JavaFileObject getSource(final String source) {

        return new SimpleJavaFileObject(getURIFromSource(source), JavaFileObject.Kind.SOURCE) {

            @Override

            public CharSequence getCharContent(boolean ignoreEncodingErrors) {

                return source;

            }

        };

    }

    void callTask(List<String> options, List<JavaFileObject> files) {

        out.print("compile: ");

        if (options != null) {

            for (String o: options) {

                if (o.length() > 64) {

                    o = o.substring(0, 32) + "..." + o.substring(o.length() - 32);

                }

                out.print(" " + o);

            }

        }

        for (JavaFileObject f: files)

            out.print(" " + f.getName());

        out.println();

        CompilationTask t = compiler.getTask(out, fileManager, null, options, null, files);

        boolean ok = t.call();

        if (!ok)

            error("compilation failed");

    }

    enum Mode { EQUALS, CONTAINS, STARTS_WITH, ENDS_WITH };

    void checkFile(StandardLocation l, String path) {

        if (!l.isOutputLocation()) {

            error("Not an output location: " + l);

            return;

        }

        List<File> files = getLocation(l);

        if (files == null) {

            error("location is unset: " + l);

            return;

        }

        if (files.size() != 1)

            error("unexpected number of entries on " + l + ": " + files.size());

        File f = new File(files.get(0), path);

        if (!f.exists())

            error("file not found: " + f);

    }

    void checkPath(StandardLocation l, Mode m, File expect) {

        checkPath(l, m, Arrays.asList(expect));

    }

    void checkPath(StandardLocation l, Mode m, List<File> expect) {

        List<File> files = getLocation(l);

        if (files == null) {