362 lines
12 KiB
Java
362 lines
12 KiB
Java
/*
|
|
* 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.
|
|
*/
|
|
|
|
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.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 Tester {
|
|
|
|
/** 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 {
|
|
((JavacFileManager) context.get(JavaFileManager.class)).close();
|
|
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;
|
|
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 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 (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;
|
|
|
|
}
|