/*
* Copyright (c) 2013, 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.
*/
package tools.javac.combo;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.StandardLocation;
import javax.tools.ToolProvider;
import com.sun.source.util.JavacTask;
import com.sun.tools.javac.util.Pair;
import org.testng.ITestResult;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.AfterSuite;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import static org.testng.Assert.fail;
/**
* Base class for template-driven TestNG javac tests that support on-the-fly
* source file generation, compilation, classloading, execution, and separate
* compilation.
*
* <p>Manages a set of templates (which have embedded tags of the form
* {@code #\{NAME\}}), source files (which are also templates), and compile
* options. Test cases can register templates and source files, cause them to
* be compiled, validate whether the set of diagnostic messages output by the
* compiler is correct, and optionally load and run the compiled classes.
*
* @author Brian Goetz
*/
@Test
public abstract class JavacTemplateTestBase {
private static final Set<String> suiteErrors = Collections.synchronizedSet(new HashSet<>());
private static final AtomicInteger counter = new AtomicInteger();
private static final File root = new File("gen");
private static final File nullDir = new File("empty");
protected final Map<String, Template> templates = new HashMap<>();
protected final Diagnostics diags = new Diagnostics();
protected final List<Pair<String, Template>> sourceFiles = new ArrayList<>();
protected final List<String> compileOptions = new ArrayList<>();
protected final List<File> classpaths = new ArrayList<>();
protected final Template.Resolver defaultResolver = new MapResolver(templates);
private Template.Resolver currentResolver = defaultResolver;
/** Add a template with a specified name */
protected void addTemplate(String name, Template t) {
templates.put(name, t);
}
/** Add a template with a specified name */
protected void addTemplate(String name, String s) {
templates.put(name, new StringTemplate(s));
}
/** Add a source file */
protected void addSourceFile(String name, Template t) {
sourceFiles.add(new Pair<>(name, t));
}
/** Add a File to the class path to be used when loading classes; File values
* will generally be the result of a previous call to {@link #compile()}.
* This enables testing of separate compilation scenarios if the class path
* is set up properly.
*/
protected void addClassPath(File path) {
classpaths.add(path);
}
/**
* Add a set of compilation command-line options
*/
protected void addCompileOptions(String... opts) {
Collections.addAll(compileOptions, opts);
}
/** Reset the compile options to the default (empty) value */
protected void resetCompileOptions() { compileOptions.clear(); }
/** Remove all templates */
protected void resetTemplates() { templates.clear(); }
/** Remove accumulated diagnostics */
protected void resetDiagnostics() { diags.reset(); }
/** Remove all source files */
protected void resetSourceFiles() { sourceFiles.clear(); }
/** Remove registered class paths */
protected void resetClassPaths() { classpaths.clear(); }
// Before each test method, reset everything
@BeforeMethod
public void reset() {
resetCompileOptions();
resetDiagnostics();
resetSourceFiles();
resetTemplates();
resetClassPaths();
}
// After each test method, if the test failed, capture source files and diagnostics and put them in the log
@AfterMethod
public void copyErrors(ITestResult result) {
if (!result.isSuccess()) {
suiteErrors.addAll(diags.errorKeys());
List<Object> list = new ArrayList<>();
Collections.addAll(list, result.getParameters());
list.add("Test case: " + getTestCaseDescription());
for (Pair<String, Template> e : sourceFiles)
list.add("Source file " + e.fst + ": " + e.snd);
if (diags.errorsFound())
list.add("Compile diagnostics: " + diags.toString());
result.setParameters(list.toArray(new Object[list.size()]));
}
}
@AfterSuite
// After the suite is done, dump any errors to output
public void dumpErrors() {
if (!suiteErrors.isEmpty())
System.err.println("Errors found in test suite: " + suiteErrors);
}
/**
* Get a description of this test case; since test cases may be combinatorially
* generated, this should include all information needed to describe the test case
*/
protected String getTestCaseDescription() {
return this.toString();
}
/** Assert that all previous calls to compile() succeeded */
protected void assertCompileSucceeded() {
if (diags.errorsFound())
fail("Expected successful compilation");
}
/**
* If the provided boolean is true, assert all previous compiles succeeded,
* otherwise assert that a compile failed.
* */
protected void assertCompileSucceededIff(boolean b) {
if (b)
assertCompileSucceeded();
else
assertCompileFailed();
}
/** Assert that a previous call to compile() failed */
protected void assertCompileFailed() {
if (!diags.errorsFound())
fail("Expected failed compilation");
}
/** Assert that a previous call to compile() failed with a specific error key */
protected void assertCompileFailed(String message) {
if (!diags.errorsFound())
fail("Expected failed compilation: " + message);
}
/** Assert that a previous call to compile() failed with all of the specified error keys */
protected void assertCompileErrors(String... keys) {
if (!diags.errorsFound())
fail("Expected failed compilation");
for (String k : keys)
if (!diags.containsErrorKey(k))
fail("Expected compilation error " + k);
}
/** Convert an object, which may be a Template or a String, into a Template */
protected Template asTemplate(Object o) {
if (o instanceof Template)
return (Template) o;
else if (o instanceof String)
return new StringTemplate((String) o);
else
return new StringTemplate(o.toString());
}
/** Compile all registered source files */
protected void compile() throws IOException {
compile(false);
}
/** Compile all registered source files, optionally generating class files
* and returning a File describing the directory to which they were written */
protected File compile(boolean generate) throws IOException {
List<JavaFileObject> files = new ArrayList<>();
for (Pair<String, Template> e : sourceFiles)
files.add(new FileAdapter(e.fst, asTemplate(e.snd)));
return compile(classpaths, files, generate);
}
/** Compile all registered source files, using the provided list of class paths
* for finding required classfiles, optionally generating class files
* and returning a File describing the directory to which they were written */
protected File compile(List<File> classpaths, boolean generate) throws IOException {
List<JavaFileObject> files = new ArrayList<>();
for (Pair<String, Template> e : sourceFiles)
files.add(new FileAdapter(e.fst, asTemplate(e.snd)));
return compile(classpaths, files, generate);
}
private File compile(List<File> classpaths, List<JavaFileObject> files, boolean generate) throws IOException {
JavaCompiler systemJavaCompiler = ToolProvider.getSystemJavaCompiler();
try (StandardJavaFileManager fm = systemJavaCompiler.getStandardFileManager(null, null, null)) {
if (classpaths.size() > 0)
fm.setLocation(StandardLocation.CLASS_PATH, classpaths);
JavacTask ct = (JavacTask) systemJavaCompiler.getTask(null, fm, diags, compileOptions, null, files);
if (generate) {
File destDir = new File(root, Integer.toString(counter.incrementAndGet()));
// @@@ Assert that this directory didn't exist, or start counter at max+1
destDir.mkdirs();
fm.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(destDir));
ct.generate();
return destDir;
}
else {
ct.analyze();
return nullDir;
}
}
}
/** Load the given class using the provided list of class paths */
protected Class<?> loadClass(String className, File... destDirs) {
try {
List<URL> list = new ArrayList<>();
for (File f : destDirs)
list.add(new URL("file:" + f.toString().replace("\\", "/") + "/"));
return Class.forName(className, true, new URLClassLoader(list.toArray(new URL[list.size()])));
} catch (ClassNotFoundException | MalformedURLException e) {
throw new RuntimeException("Error loading class " + className, e);
}
}
/** An implementation of Template which is backed by a String */
protected class StringTemplate implements Template {
protected final String template;
public StringTemplate(String template) {
this.template = template;
}
public String expand(String selector) {
return Behavior.expandTemplate(template, currentResolver);
}
public String toString() {
return expand("");
}
public StringTemplate with(final String key, final String value) {
return new StringTemplateWithResolver(template, new KeyResolver(key, value));
}
}
/** An implementation of Template which is backed by a String and which
* encapsulates a Resolver for resolving embedded tags. */
protected class StringTemplateWithResolver extends StringTemplate {
private final Resolver localResolver;
public StringTemplateWithResolver(String template, Resolver localResolver) {
super(template);
this.localResolver = localResolver;
}
@Override
public String expand(String selector) {
Resolver saved = currentResolver;
currentResolver = new ChainedResolver(currentResolver, localResolver);
try {
return super.expand(selector);
}
finally {
currentResolver = saved;
}
}
@Override
public StringTemplate with(String key, String value) {
return new StringTemplateWithResolver(template, new ChainedResolver(localResolver, new KeyResolver(key, value)));
}
}
/** A Resolver which uses a Map to resolve tags */
private class KeyResolver implements Template.Resolver {
private final String key;
private final String value;
public KeyResolver(String key, String value) {
this.key = key;
this.value = value;
}
@Override
public Template lookup(String k) {
return key.equals(k) ? new StringTemplate(value) : null;
}
}
private class FileAdapter extends SimpleJavaFileObject {
private final String filename;
private final Template template;
public FileAdapter(String filename, Template template) {
super(URI.create("myfo:/" + filename), Kind.SOURCE);
this.template = template;
this.filename = filename;
}
public CharSequence getCharContent(boolean ignoreEncodingErrors) {
return toString();
}
public String toString() {
return Template.Behavior.expandTemplate(template.expand(filename), defaultResolver);
}
}
}