* The {@code run} method, expects arguments to identify test-case classes. * A test-case class is a class extending the test class, and annotated * with {@code TestCase}. *
* If no test-cases are specified, the test class directory is searched for * co-located test-case classes (i.e. any class extending the test class, * annotated with {@code TestCase}). *
* Besides serving to group test-cases, extending the driver allow
* setting up a test-case template, and possibly overwrite default
* test-driver behaviour.
*/
public abstract class JavapTester {
private static boolean debug = false;
private static final PrintStream out = System.err;
private static final PrintStream err = System.err;
protected void run(String... args) throws Exception {
final File classesdir = new File(System.getProperty("test.classes", "."));
String[] classNames = args;
// If no test-cases are specified, we regard all co-located classes
// as potential test-cases.
if (args.length == 0) {
final String pattern = ".*\\.class";
final File classFiles[] = classesdir.listFiles(new FileFilter() {
public boolean accept(File f) {
return f.getName().matches(pattern);
}
});
ArrayList
* Sets a default test-case template, which is empty except
* for a key of {@code "TESTCASE"}.
* Subclasses will typically call {@code setSrc(TestSource)}
* to setup a useful test-case template.
*/
public JavapTester() {
this.testCase = this.getClass().getName();
src = new TestSource("TESTCASE");
}
/**
* Set the top-level source template.
*/
protected JavapTester setSrc(TestSource src) {
this.src = src;
return this;
}
/**
* Convenience method for calling {@code innerSrc("TESTCASE", ...)}.
*/
protected JavapTester setSrc(String... lines) {
return innerSrc("TESTCASE", lines);
}
/**
* Convenience method for calling {@code innerSrc(key, new TestSource(...))}.
*/
protected JavapTester innerSrc(String key, String... lines) {
return innerSrc(key, new TestSource(lines));
}
/**
* Specialize the testcase template, setting replacement content
* for the specified key.
*/
protected JavapTester innerSrc(String key, TestSource content) {
if (src == null) {
src = new TestSource(key);
}
src.setInner(key, content);
return this;
}
/**
* On the first invocation, call {@code execute()} to compile
* the test-case source and process the resulting class(se)
* into verifiable output.
*
* Verify that the output matches each of the regular expressions
* given as argument.
*
* Any failure to match constitutes a test failure, but doesn't
* abort the test-case.
*
* Any exception (e.g. bad regular expression syntax) results in
* a test failure, and aborts the test-case.
*/
protected void verify(String... expect) {
if (!didExecute) {
try {
execute();
} catch(Exception ue) {
throw new Error(ue);
} finally {
didExecute = true;
}
}
if (output == null) {
error("output is null");
return;
}
for (String e: expect) {
// Escape regular expressions (to allow input to be literals).
// Notice, characters to be escaped are themselves identified
// using regular expressions
String rc[] = { "(", ")", "[", "]", "{", "}", "$" };
for (String c : rc) {
e = e.replace(c, "\\" + c);
}
// DEBUG: Uncomment this to test modulo constant pool index.
// e = e.replaceAll("#[0-9]{2}", "#[0-9]{2}");
if (!output.matches("(?s).*" + e + ".*")) {
if (!didPrint) {
out.println(output);
didPrint = true;
}
error("not matched: '" + e + "'");
} else if(debug) {
out.println("matched: '" + e + "'");
}
}
}
/**
* Calls {@code writeTestFile()} to write out the test-case source
* content to a file, then call {@code compileTestFile()} to
* compile it, and finally run the {@link process} method to produce
* verifiable output. The default {@code process} method runs javap.
*
* If an exception occurs, it results in a test failure, and
* aborts the test-case.
*/
protected void execute() throws IOException {
err.println("TestCase: " + testCase);
writeTestFile();
compileTestFile();
process();
}
/**
* Generate java source from test-case.
* TBD: change to use javaFileObject, possibly make
* this class extend JavaFileObject.
*/
protected void writeTestFile() throws IOException {
javaFile = new File("Test.java");
FileWriter fw = new FileWriter(javaFile);
BufferedWriter bw = new BufferedWriter(fw);
PrintWriter pw = new PrintWriter(bw);
for (String line : src) {
pw.println(line);
if (debug) out.println(line);
}
pw.close();
}
/**
* Compile the Java source code.
*/
protected void compileTestFile() {
String path = javaFile.getPath();
String params[] = {"-g", path };
int rc = com.sun.tools.javac.Main.compile(params);
if (rc != 0)
throw new Error("compilation failed. rc=" + rc);
classFile = new File(path.substring(0, path.length() - 5) + ".class");
}
/**
* Process class file to generate output for verification.
* The default implementation simply runs javap. This might be
* overwritten to generate output in a different manner.
*/
protected void process() {
String testClasses = "."; //System.getProperty("test.classes", ".");
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
String[] args = { "-v", "-classpath", testClasses, "Test" };
int rc = com.sun.tools.javap.Main.run(args, pw);
if (rc != 0)
throw new Error("javap failed. rc=" + rc);
pw.close();
output = sw.toString();
if (debug) {
out.println(output);
didPrint = true;
}
}
private String testCase;
private TestSource src;
private File javaFile = null;
private File classFile = null;
private String output = null;
private boolean didExecute = false;
private boolean didPrint = false;
protected void error(String msg) {
err.println("Error: " + msg);
errors++;
}
private int cases;
private int fcases;
private int errors;
private int ignored;
/**
* The TestSource class provides a simple container for
* test cases. It contains an array of source code lines,
* where zero or more lines may be markers for nested lines.
* This allows representing templates, with specialization.
*
* This may be generalized to support more advance combo
* tests, but presently it's only used with a static template,
* and one level of specialization.
*/
public class TestSource implements Iterable