/*

 * 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 6437138 6482554

 * @summary JSR 199: Compiler doesn't diagnose crash in user code

 * @library ../lib

 * @build JavacTestingAbstractProcessor TestClientCodeWrapper

 * @run main TestClientCodeWrapper

 */

import java.io.*;

import java.lang.reflect.Method;

import java.net.URI;

import java.util.*;

import javax.annotation.processing.*;

import javax.lang.model.*;

import javax.lang.model.element.*;

import javax.tools.*;

import com.sun.source.util.*;

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

import javax.tools.JavaFileObject.Kind;

public class TestClientCodeWrapper extends JavacTestingAbstractProcessor {

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

        new TestClientCodeWrapper().run();

    }

    /**

     * Run a series of compilations, each with a different user-provided object

     * configured to throw an exception when a specific method is invoked.

     * Then, verify the exception is thrown as expected.

     *

     * Some methods are not invoked from the compiler, and are excluded from the test.

     */

    void run() throws Exception {

        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

        }

    }

    /** Get a sorted set of the methods declared on a class. */

    Set<Method> getMethods(Class<?> clazz) {

        return getMethodsExcept(clazz, new String[0]);

    }

    /** Get a sorted set of the methods declared on a class, excluding

     *  specified methods by name. */

    Set<Method> getMethodsExcept(Class<?> clazz, String... exclude) {

        Set<Method> methods = new TreeSet<Method>(new Comparator<Method>() {

            public int compare(Method m1, Method m2) {

                return m1.toString().compareTo(m2.toString());

            }

        });

        Set<String> e = new HashSet<String>(Arrays.asList(exclude));

        for (Method m: clazz.getDeclaredMethods()) {

            if (!e.contains(m.getName()))

                methods.add(m);

        }

        return methods;

    }

    /**

     * Test a method in a user supplied component, to verify javac's handling

     * of any exceptions thrown by that method.

     */

    void test(Method m) throws Exception {

        testNum++;

        File extDirs = new File("empty-extdirs");

        extDirs.mkdirs();

        File testClasses = new File("test" + testNum);

        testClasses.mkdirs();

        defaultFileManager.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(testClasses));

        System.err.println("test " + testNum + ": "

                + m.getDeclaringClass().getSimpleName() + "." + m.getName());

        StringWriter sw = new StringWriter();

        PrintWriter pw = new PrintWriter(sw);

        List<String> javacOptions = Arrays.asList(

                "-extdirs", extDirs.getPath(), // for use by filemanager handleOption

                "-processor", TestClientCodeWrapper.class.getName()

                );

        List<String> classes = Collections.emptyList();

        JavacTool tool = JavacTool.create();

        try {

            JavacTask task = tool.getTask(pw,

                    getFileManager(m, defaultFileManager),

                    getDiagnosticListener(m, pw),

                    javacOptions,

                    classes,

                    getCompilationUnits(m));

            if (isDeclaredIn(m, Processor.class))

                task.setProcessors(getProcessors(m));

            if (isDeclaredIn(m, TaskListener.class))

                task.setTaskListener(getTaskListener(m, pw));

            boolean ok = task.call();

            error("compilation " + (ok ? "succeeded" : "failed") + " unexpectedly");

        } catch (RuntimeException e) {

            System.err.println("caught " + e);

            if (e.getClass() == RuntimeException.class) {

                Throwable cause = e.getCause();

                if (cause instanceof UserError) {

                    String expect = m.getName();

                    String found = cause.getMessage();

                    checkEqual("exception messaqe", expect, found);

                } else {

                    cause.printStackTrace(System.err);

                    error("Unexpected exception: " + cause);

                }

            } else {

                e.printStackTrace(System.err);

                error("Unexpected exception: " + e);

            }

        }

        pw.close();

        String out = sw.toString();

        System.err.println(out);

    }

    /** Get a file manager to use for the test compilation. */

    JavaFileManager getFileManager(Method m, JavaFileManager defaultFileManager) {

        return isDeclaredIn(m, JavaFileManager.class, FileObject.class, JavaFileObject.class)

                ? new UserFileManager(m, defaultFileManager)

                : defaultFileManager;

    }

    /** Get a diagnostic listener to use for the test compilation. */

    DiagnosticListener<JavaFileObject> getDiagnosticListener(Method m, PrintWriter out) {

        return isDeclaredIn(m, DiagnosticListener.class)

                ? new UserDiagnosticListener(m, out)

                : null;

    }

    /** Get a set of file objects to use for the test compilation. */

    Iterable<? extends JavaFileObject> getCompilationUnits(Method m) {

        File testSrc = new File(System.getProperty("test.src"));

        File thisSrc = new File(testSrc, TestClientCodeWrapper.class.getName() + ".java");

        Iterable<? extends JavaFileObject> files = defaultFileManager.getJavaFileObjects(thisSrc);

        if (isDeclaredIn(m, FileObject.class, JavaFileObject.class))

            return Arrays.asList(new UserFileObject(m, files.iterator().next()));

        else

            return files;

    }

    /** Get a set of annotation processors to use for the test compilation. */

    Iterable<? extends Processor> getProcessors(Method m) {

        return Arrays.asList(new UserProcessor(m));

    }

    /** Get a task listener to use for the test compilation. */

    TaskListener getTaskListener(Method m, PrintWriter out) {

        return new UserTaskListener(m, out);

    }

    /** Check if two values are .equal, and report an error if not. */

    <T> void checkEqual(String label, T expect, T found) {

        if (!expect.equals(found))

            error("Unexpected value for " + label + ": " + found + "; expected: " + expect);

    }

    /** Report an error. */

    void error(String msg) {

        System.err.println("Error: " + msg);

        errors++;

    }

    /** Check if a method is declared in any of a set of classes */

    static boolean isDeclaredIn(Method m, Class<?>... classes) {

        Class<?> dc = m.getDeclaringClass();

        for (Class<?> c: classes) {

            if (c == dc) return true;

        }

        return false;

    }

    /** Throw an intentional error if the method has a given name. */

    static void throwUserExceptionIfNeeded(Method m, String name) {

        if (m != null && m.getName().equals(name))

            throw new UserError(name);

    }

    StandardJavaFileManager defaultFileManager;

    int testNum;

    int errors;

    //--------------------------------------------------------------------------

    /**

     * Processor used to trigger use of methods not normally used by javac.

     */

    @Override

    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

        boolean firstRound = false;

        for (Element e: roundEnv.getRootElements()) {

            if (e.getSimpleName().contentEquals(TestClientCodeWrapper.class.getSimpleName()))

                firstRound = true;

        }

        if (firstRound) {

            try {

                FileObject f1 = filer.getResource(StandardLocation.CLASS_PATH, "",

                    TestClientCodeWrapper.class.getName() + ".java");

                f1.openInputStream().close();

                f1.openReader(false).close();

                FileObject f2 = filer.createResource(

                        StandardLocation.CLASS_OUTPUT, "", "f2.txt", (Element[]) null);

                f2.openOutputStream().close();

                FileObject f3 = filer.createResource(

                        StandardLocation.CLASS_OUTPUT, "", "f3.txt", (Element[]) null);

                f3.openWriter().close();

                JavaFileObject f4 = filer.createSourceFile("f4", (Element[]) null);

                f4.openWriter().close();

                f4.getNestingKind();

                f4.getAccessLevel();

                messager.printMessage(Diagnostic.Kind.NOTE, "informational note",

                        roundEnv.getRootElements().iterator().next());

            } catch (IOException e) {

                throw new UserError(e);

            }

        }

        return true;

    }

    //--------------------------------------------------------------------------

    // <editor-fold defaultstate="collapsed" desc="User classes">

    static class UserError extends Error {

        private static final long serialVersionUID = 1L;

        UserError(String msg) {

            super(msg);

        }

        UserError(Throwable t) {

            super(t);

        }

    }

    static class UserFileManager extends ForwardingJavaFileManager<JavaFileManager> {

        Method fileManagerMethod;

        Method fileObjectMethod;

        UserFileManager(Method m, JavaFileManager delegate) {

            super(delegate);

            if (isDeclaredIn(m, JavaFileManager.class)) {

                fileManagerMethod = m;

            } else if (isDeclaredIn(m, FileObject.class, JavaFileObject.class)) {

                fileObjectMethod = m;

            } else

                assert false;

        }

        @Override

        public ClassLoader getClassLoader(Location location) {

            throwUserExceptionIfNeeded(fileManagerMethod, "getClassLoader");

            return super.getClassLoader(location);

        }

        @Override

        public Iterable<JavaFileObject> list(Location location, String packageName, Set<Kind> kinds, boolean recurse) throws IOException {

            throwUserExceptionIfNeeded(fileManagerMethod, "list");

            return wrap(super.list(location, packageName, kinds, recurse));

        }

        @Override

        public String inferBinaryName(Location location, JavaFileObject file) {

            throwUserExceptionIfNeeded(fileManagerMethod, "inferBinaryName");

            return super.inferBinaryName(location, unwrap(file));

        }

        @Override

        public boolean isSameFile(FileObject a, FileObject b) {

            throwUserExceptionIfNeeded(fileManagerMethod, "isSameFile");

            return super.isSameFile(unwrap(a), unwrap(b));

        }

        @Override

        public boolean handleOption(String current, Iterator<String> remaining) {

            throwUserExceptionIfNeeded(fileManagerMethod, "handleOption");

            return super.handleOption(current, remaining);

        }

        @Override

        public boolean hasLocation(Location location) {

            throwUserExceptionIfNeeded(fileManagerMethod, "hasLocation");

            return super.hasLocation(location);

        }

        @Override

        public JavaFileObject getJavaFileForInput(Location location, String className, Kind kind) throws IOException {

            throwUserExceptionIfNeeded(fileManagerMethod, "getJavaFileForInput");

            return wrap(super.getJavaFileForInput(location, className, kind));

        }

        @Override

        public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind, FileObject sibling) throws IOException {

            throwUserExceptionIfNeeded(fileManagerMethod, "getJavaFileForOutput");

            return wrap(super.getJavaFileForOutput(location, className, kind, sibling));

        }

        @Override

        public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException {

            throwUserExceptionIfNeeded(fileManagerMethod, "getFileForInput");

            return wrap(super.getFileForInput(location, packageName, relativeName));

        }

        @Override

        public FileObject getFileForOutput(Location location, String packageName, String relativeName, FileObject sibling) throws IOException {

            throwUserExceptionIfNeeded(fileManagerMethod, "getFileForOutput");

            return wrap(super.getFileForOutput(location, packageName, relativeName, sibling));

        }

        @Override

        public void flush() throws IOException {

            throwUserExceptionIfNeeded(fileManagerMethod, "flush");

            super.flush();

        }

        @Override

        public void close() throws IOException {

            throwUserExceptionIfNeeded(fileManagerMethod, "close");

            super.close();

        }

        @Override

        public int isSupportedOption(String option) {

            throwUserExceptionIfNeeded(fileManagerMethod, "isSupportedOption");

            return super.isSupportedOption(option);

        }

        public FileObject wrap(FileObject fo) {

            if (fileObjectMethod == null)

                return fo;

            return new UserFileObject(fileObjectMethod, (JavaFileObject)fo);

        }

        FileObject unwrap(FileObject fo) {

            if (fo instanceof UserFileObject)

                return ((UserFileObject) fo).unwrap();

            else

                return fo;

        }

        public JavaFileObject wrap(JavaFileObject fo) {

            if (fileObjectMethod == null)

                return fo;

            return new UserFileObject(fileObjectMethod, fo);

        }

        public Iterable<JavaFileObject> wrap(Iterable<? extends JavaFileObject> list) {

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

            for (JavaFileObject fo : list)

                wrapped.add(wrap(fo));

            return Collections.unmodifiableList(wrapped);

        }

        JavaFileObject unwrap(JavaFileObject fo) {

            if (fo instanceof UserFileObject)

                return ((UserFileObject) fo).unwrap();

            else

                return fo;

        }

    }

    static class UserFileObject extends ForwardingJavaFileObject<JavaFileObject> {

        Method method;

        UserFileObject(Method m, JavaFileObject delegate) {

            super(delegate);

            assert isDeclaredIn(m, FileObject.class, JavaFileObject.class);

            this.method = m;

        }

        JavaFileObject unwrap() {

            return fileObject;

        }

        @Override

        public Kind getKind() {

            throwUserExceptionIfNeeded(method, "getKind");

            return super.getKind();

        }

        @Override

        public boolean isNameCompatible(String simpleName, Kind kind) {

            throwUserExceptionIfNeeded(method, "isNameCompatible");

            return super.isNameCompatible(simpleName, kind);

        }

        @Override

        public NestingKind getNestingKind() {

            throwUserExceptionIfNeeded(method, "getNestingKind");

            return super.getNestingKind();

        }

        @Override

        public Modifier getAccessLevel() {

            throwUserExceptionIfNeeded(method, "getAccessLevel");

            return super.getAccessLevel();

        }

        @Override

        public URI toUri() {

            throwUserExceptionIfNeeded(method, "toUri");

            return super.toUri();

        }

        @Override

        public String getName() {

            throwUserExceptionIfNeeded(method, "getName");

            return super.getName();

        }

        @Override

        public InputStream openInputStream() throws IOException {

            throwUserExceptionIfNeeded(method, "openInputStream");

            return super.openInputStream();

        }

        @Override

        public OutputStream openOutputStream() throws IOException {

            throwUserExceptionIfNeeded(method, "openOutputStream");

            return super.openOutputStream();

        }

        @Override

        public Reader openReader(boolean ignoreEncodingErrors) throws IOException {

            throwUserExceptionIfNeeded(method, "openReader");

            return super.openReader(ignoreEncodingErrors);

        }

        @Override

        public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {

            throwUserExceptionIfNeeded(method, "getCharContent");

            return super.getCharContent(ignoreEncodingErrors);

        }

        @Override

        public Writer openWriter() throws IOException {

            throwUserExceptionIfNeeded(method, "openWriter");

            return super.openWriter();

        }

        @Override

        public long getLastModified() {

            throwUserExceptionIfNeeded(method, "getLastModified");

            return super.getLastModified();

        }

        @Override

        public boolean delete() {

            throwUserExceptionIfNeeded(method, "delete");

            return super.delete();

        }

    }

    static class UserProcessor extends JavacTestingAbstractProcessor {

        Method method;

        UserProcessor(Method m) {

            assert isDeclaredIn(m, Processor.class);

            method = m;

        }