--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/options/modes/OptionModesTester.java Fri Aug 12 17:45:31 2016 -0700
@@ -0,0 +1,376 @@
+/*
+ * 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;
+
+}