options/modes/OptionModesTester.java

/*
 * Copyright (c) 2014, 2016, 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 com.sun.tools.javac.api.JavacTool;
import com.sun.tools.javac.file.JavacFileManager;
import com.sun.tools.javac.util.Context;
import java.io.ByteArrayOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.UncheckedIOException;
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

public class OptionModesTester {

    /** Marker annotation for test methods to be invoked by runTests. */
    @Retention(RetentionPolicy.RUNTIME)
    @interface Test { }

    /**
     * Run all methods annotated with @Test, and throw an exception if any
     * errors are reported..
     * Typically called on a tester object in main()
     * @throws Exception if any errors occurred
     */
    void runTests() throws Exception {
        for (Method m: getClass().getDeclaredMethods()) {
            Annotation a = m.getAnnotation(Test.class);
            if (a != null) {
                try {
                    out.println("Running test " + m.getName());
                    m.invoke(this);
                } catch (InvocationTargetException e) {
                    Throwable cause = e.getCause();
                    throw (cause instanceof Exception) ? ((Exception) cause) : e;
                }
                out.println();
            }
        }
        if (errors > 0)
            throw new Exception(errors + " errors occurred");
    }

    TestResult runMain(String[] opts, String[] files) {
        out.println("Main " + Arrays.toString(opts) + " " + Arrays.toString(files));
        return run(new TestResult(opts), (tr, c, pw) -> {
            com.sun.tools.javac.main.Main compiler =
                new com.sun.tools.javac.main.Main("javac", pw);
            int rc = compiler.compile(join(opts, files), c).exitCode;
            tr.setResult(rc);
        });
    }

    TestResult runCall(String[] opts, String[] files) {
        out.println("Call " + Arrays.toString(opts) + " " + Arrays.toString(files));
        return run(new TestResult(opts), (tr, c, pw) -> {
            boolean ok = JavacTool.create()
                    .getTask(pw, null, null, Arrays.asList(opts), null, getFiles(files), c)
                    .call();
            tr.setResult(ok);
        });
    }

    TestResult runParse(String[] opts, String[] files) {
        out.println("Parse " + Arrays.toString(opts) + " " + Arrays.toString(files));
        return run(new TestResult(opts), (tr, c, pw) -> {
            JavacTool.create()
                    .getTask(pw, null, null, Arrays.asList(opts), null, getFiles(files), c)
                    .parse();
            tr.setResult(true);
        });
    }

    TestResult runAnalyze(String[] opts, String[] files) {
        out.println("Analyze " + Arrays.toString(opts) + " " + Arrays.toString(files));
        return run(new TestResult(opts), (tr, c, pw) -> {
            JavacTool.create()
                    .getTask(pw, null, null, Arrays.asList(opts), null, getFiles(files), c)
                    .analyze();
            tr.setResult(true);
        });
    }

    interface Runnable {
        void run(TestResult tr, Context c, PrintWriter pw) throws IOException;
    }

    TestResult run(TestResult tr, Runnable r) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        StreamOutput sysOut = new StreamOutput(System.out, System::setOut);
        StreamOutput sysErr = new StreamOutput(System.err, System::setErr);
        Context context = new Context();
        JavacFileManager.preRegister(context);
        try {
            r.run(tr, context, pw);
        } catch (IllegalArgumentException | IllegalStateException | IOException e) {
            tr.setThrown(e);
        } finally {
            try {
                ((JavacFileManager) context.get(JavaFileManager.class)).close();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
            tr.setLogs(sw.toString(), sysOut.close(), sysErr.close());
        }
        tr.setContext(context);
        tr.show();
        return tr;
    }

    enum Log { DIRECT, STDOUT, STDERR };

    class TestResult {
        final List<String> args;
        Throwable thrown;
        List<Throwable> suppressed = new ArrayList<>();
        Object rc; // Number or Boolean
        Map<Log, String> logs;
        Context context;

        TestResult(String... args) {
            this.args = Arrays.asList(args);
        }

        TestResult(List<String> args, Iterable<? extends JavaFileObject> files) {
            this.args = new ArrayList<>();
            this.args.addAll(args);
            for (JavaFileObject f: files)
                this.args.add(f.getName());
        }

        void setResult(int rc) {
            this.rc = rc;
        }

        void setResult(boolean ok) {
            this.rc = ok ? 0 : 1;
        }

        void setSuppressed(Throwable thrown) {
            this.suppressed.add(thrown);
        }

        void setThrown(Throwable thrown) {
            this.thrown = thrown;
        }

        void setLogs(String direct, String stdOut, String stdErr) {
            logs = new EnumMap<>(Log.class);
            logs.put(Log.DIRECT, direct);
            logs.put(Log.STDOUT, stdOut);
            logs.put(Log.STDERR, stdErr);
        }

        void setContext(Context context) {
            this.context = context;
        }

        final void show() {
            String NL = System.getProperty("line.separator");
            boolean needSep = false;
            if (rc != null) {
                out.print("rc:" + rc);
                needSep = true;
            }
            if (thrown != null) {
                if (needSep) out.print("; ");
                out.print("thrown:" + thrown);
                needSep = true;
            }
            if (!suppressed.isEmpty()) {
                if (needSep) out.print("; ");
                out.print("suppressed:" + suppressed);
                needSep = true;
            }
            if (needSep)
                out.println();
            logs.forEach((k, v) -> {
                if (!v.isEmpty()) {
                    out.println("javac/" + k + ":");
                    if (v.endsWith(NL))
                        out.print(v);
                    else
                        out.println(v);
                }

            });
        }

        TestResult checkOK() {
            if (thrown != null) {
                error("unexpected exception thrown: " + thrown);
            } else if (rc == null) {
                error("no result set");
            } else if (rc != (Integer) 0 && rc != (Boolean) true) {
                error("compilation failed unexpectedly; rc=" + rc);
            }
            return this;
        }

        TestResult checkResult(int expect) {
            if (thrown != null) {
                error("unexpected exception thrown: " + thrown);
            } else if (rc != (Integer) expect) {
                error("unexpected result: " + rc +", expected:" + expect);
            }
            return this;
        }

        TestResult checkResult(boolean expect) {
            if (thrown != null) {
                error("unexpected exception thrown: " + thrown);
            } else if (rc != (Integer) (expect ? 0 : 1)) {
                error("unexpected result: " + rc +", expected:" + expect);
            }
            return this;
        }

        TestResult checkLog(String... expects) {
            return checkLog(Log.DIRECT, expects);
        }

        TestResult checkLog(Log l, String... expects) {
            for (String e: expects) {
                if (!logs.get(l).contains(e))
                    error("expected string not found: " + e);
            }
            return this;
        }

        TestResult checkIllegalArgumentException() {
            return checkThrown(IllegalArgumentException.class);
        }

        TestResult checkIllegalStateException() {
            return checkThrown(IllegalStateException.class);
        }

        TestResult checkThrown(Class<? extends Throwable> t) {
            if (thrown == null)
                error("expected exception not thrown: " + t);
            else if (!t.isAssignableFrom(thrown.getClass()))
                error("unexpected exception thrown: " + thrown + ";  expected: " + t);
            return this;
        }

        TestResult checkClass(String name) {
            Path p = getOutDir().resolve(name.replace(".", "/") + ".class");
            if (!Files.exists(p))
                error("expected class not found: " + name + " (" + p + ")");
            return this;
        }

        Path getOutDir() {
            Iterator<String> iter = args.iterator();
            while (iter.hasNext()) {
                if (iter.next().equals("-d")) {
                    return Paths.get(iter.next());
                }
            }
            return null;
        }
    }

    /**
     * Utility class to simplify the handling of temporarily setting a
     * new stream for System.out or System.err.
     */
    private static class StreamOutput {
        // functional interface to set a stream.
        private interface Initializer {
            void set(PrintStream s);
        }

        private final ByteArrayOutputStream baos = new ByteArrayOutputStream();
        private final PrintStream ps = new PrintStream(baos);
        private final PrintStream prev;
        private final Initializer init;

        StreamOutput(PrintStream s, Initializer init) {
            prev = s;
            init.set(ps);
            this.init = init;
        }

        String close() {
            init.set(prev);
            ps.close();
            return baos.toString();
        }
    }

    List<JavaFileObject> getFiles(String... paths) {
        List<JavaFileObject> files = new ArrayList<>();
        for (JavaFileObject f : fm.getJavaFileObjects(paths))
            files.add(f);
        return files;
    }

    String toString(List<JavaFileObject> files) {
        return files.stream().map(f -> f.getName()).collect(Collectors.toList()).toString();
    }

    void mkdirs(String path) throws IOException {
        Files.createDirectories(Paths.get(path));
    }

    void writeFile(String path, String body) throws IOException {
        Path p = Paths.get(path);
        if (p.getParent() != null)
            Files.createDirectories(p.getParent());
        try (FileWriter w = new FileWriter(path)) {
            w.write(body);
        }
    }

    String[] join(String[] a, String[] b) {
        String[] result = new String[a.length + b.length];
        System.arraycopy(a, 0, result, 0, a.length);
        System.arraycopy(b, 0, result, a.length, b.length);
        return result;
    }

    void error(String message) {
        out.print(">>>>> ");
        out.println(message);
        errors++;
    }

    StandardJavaFileManager fm =
            ToolProvider.getSystemJavaCompiler().getStandardFileManager(null, null, null);
    PrintStream out = System.err;
    int errors;

}