/*
* Copyright (c) 2015, 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 combo;
import com.sun.source.tree.CompilationUnitTree;
import com.sun.source.util.JavacTask;
import com.sun.source.util.TaskEvent.Kind;
import com.sun.source.util.TaskListener;
import com.sun.tools.javac.api.JavacTool;
import com.sun.tools.javac.util.List;
import combo.ComboParameter.Resolver;
import javax.lang.model.element.Element;
import javax.tools.Diagnostic;
import javax.tools.DiagnosticListener;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import java.io.IOException;
import java.io.Writer;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;
/**
* This class represents a compilation task associated with a combo test instance. This is a small
* wrapper around {@link JavacTask} which allows for fluent setup style and which makes use of
* the shared compilation context to speedup performances.
*/
public class ComboTask {
/** Sources to be compiled in this task. */
private List<JavaFileObject> sources = List.nil();
/** Options associated with this task. */
private List<String> options = List.nil();
/** Diagnostic collector. */
private DiagnosticCollector diagsCollector = new DiagnosticCollector();
/** Output writer. */
private Writer out;
/** Listeners associated with this task. */
private List<TaskListener> listeners = List.nil();
/** Underlying javac task object. */
private JavacTask task;
/** Combo execution environment. */
private ComboTestHelper<?>.Env env;
ComboTask(ComboTestHelper<?>.Env env) {
this.env = env;
}
/**
* Add a new source to this task.
*/
public ComboTask withSource(JavaFileObject comboSource) {
sources = sources.prepend(comboSource);
return this;
}
/**
* Add a new template source with given name to this task; the template is replaced with
* corresponding combo parameters (as defined in the combo test environment).
*/
public ComboTask withSourceFromTemplate(String name, String template) {
return withSource(new ComboTemplateSource(name, template));
}
/**
* Add a new template source with default name ("Test") to this task; the template is replaced with
* corresponding combo parameters (as defined in the combo test environment).
*/
public ComboTask withSourceFromTemplate(String template) {
return withSource(new ComboTemplateSource("Test", template));
}
/**
* Add a new template source with given name to this task; the template is replaced with
* corresponding combo parameters (as defined in the combo test environment). A custom resolver
* is used to add combo parameter mappings to the current combo test environment.
*/
public ComboTask withSourceFromTemplate(String name, String template, Resolver resolver) {
return withSource(new ComboTemplateSource(name, template, resolver));
}
/**
* Add a new template source with default name ("Test") to this task; the template is replaced with
* corresponding combo parameters (as defined in the combo test environment). A custom resolver
* is used to add combo parameter mappings to the current combo test environment.
*/
public ComboTask withSourceFromTemplate(String template, Resolver resolver) {
return withSource(new ComboTemplateSource("Test", template, resolver));
}
/**
* Add a new option to this task.
*/
public ComboTask withOption(String opt) {
options = options.append(opt);
return this;
}
/**
* Add a set of options to this task.
*/
public ComboTask withOptions(String[] opts) {
for (String opt : opts) {
options = options.append(opt);
}
return this;
}
/**
* Add a set of options to this task.
*/
public ComboTask withOptions(Iterable<? extends String> opts) {
for (String opt : opts) {
options = options.append(opt);
}
return this;
}
/**
* Set the output writer associated with this task.
*/
public ComboTask withWriter(Writer out) {
this.out = out;
return this;
}
/**
* Add a task listener to this task.
*/
public ComboTask withListener(TaskListener listener) {
listeners = listeners.prepend(listener);
return this;
}
/**
* Parse the sources associated with this task.
*/
public Result<Iterable<? extends CompilationUnitTree>> parse() throws IOException {
return new Result<>(getTask().parse());
}
/**
* Parse and analyzes the sources associated with this task.
*/
public Result<Iterable<? extends Element>> analyze() throws IOException {
return new Result<>(getTask().analyze());
}
/**
* Parse, analyze and perform code generation for the sources associated with this task.
*/
public Result<Iterable<? extends JavaFileObject>> generate() throws IOException {
return new Result<>(getTask().generate());
}
/**
* Fork a new compilation task; if possible the compilation context from previous executions is
* retained (see comments in ReusableContext as to when it's safe to do so); otherwise a brand
* new context is created.
*/
public JavacTask getTask() {
if (task == null) {
ReusableContext context = env.context();
String opts = options == null ? "" :
StreamSupport.stream(options.spliterator(), false).collect(Collectors.joining());
context.clear();
if (!context.polluted && (context.opts == null || context.opts.equals(opts))) {
//we can reuse former context
env.info().ctxReusedCount++;
} else {
env.info().ctxDroppedCount++;
//it's not safe to reuse context - create a new one
context = env.setContext(new ReusableContext());
}
context.opts = opts;
JavacTask javacTask = ((JavacTool)env.javaCompiler()).getTask(out, env.fileManager(),
diagsCollector, options, null, sources, context);
javacTask.setTaskListener(context);
for (TaskListener l : listeners) {
javacTask.addTaskListener(l);
}
task = javacTask;
}
return task;
}
/**
* This class is used to help clients accessing the results of a given compilation task.
* Contains several helper methods to inspect diagnostics generated during the task execution.
*/
public class Result<D> {
/** The underlying compilation results. */
private final D data;
public Result(D data) {
this.data = data;
}
public D get() {
return data;
}
/**
* Did this task generate any error diagnostics?
*/
public boolean hasErrors() {
return diagsCollector.diagsByKind.containsKey(Diagnostic.Kind.ERROR);
}
/**
* Did this task generate any warning diagnostics?
*/
public boolean hasWarnings() {
return diagsCollector.diagsByKind.containsKey(Diagnostic.Kind.WARNING);
}
/**
* Did this task generate any note diagnostics?
*/
public boolean hasNotes() {
return diagsCollector.diagsByKind.containsKey(Diagnostic.Kind.NOTE);
}
/**
* Did this task generate any diagnostic with given key?
*/
public boolean containsKey(String key) {
return diagsCollector.diagsByKeys.containsKey(key);
}
/**
* Retrieve the list of diagnostics of a given kind.
*/
public List<Diagnostic<? extends JavaFileObject>> diagnosticsForKind(Diagnostic.Kind kind) {
List<Diagnostic<? extends JavaFileObject>> diags = diagsCollector.diagsByKind.get(kind);
return diags != null ? diags : List.nil();
}
/**
* Retrieve the list of diagnostics with given key.
*/
public List<Diagnostic<? extends JavaFileObject>> diagnosticsForKey(String key) {
List<Diagnostic<? extends JavaFileObject>> diags = diagsCollector.diagsByKeys.get(key);
return diags != null ? diags : List.nil();
}
/**
* Dump useful info associated with this task.
*/
public String compilationInfo() {
return "instance#" + env.info().comboCount + ":[ options = " + options
+ ", diagnostics = " + diagsCollector.diagsByKeys.keySet()
+ ", dimensions = " + env.bindings
+ ", sources = \n" + sources.stream().map(s -> {
try {
return s.getCharContent(true);
} catch (IOException ex) {
return "";
}
}).collect(Collectors.joining(",")) + "]";
}
}
/**
* This class represents a Java source file whose contents are defined in terms of a template
* string. The holes in such template are expanded using corresponding combo parameter
* instances which can be retrieved using a resolver object.
*/
class ComboTemplateSource extends SimpleJavaFileObject {
String source;
Map<String, ComboParameter> localParametersCache = new HashMap<>();
protected ComboTemplateSource(String name, String template) {
this(name, template, null);
}
protected ComboTemplateSource(String name, String template, Resolver resolver) {
super(URI.create("myfo:/" + env.info().comboCount + "/" + name + ".java"), Kind.SOURCE);
source = ComboParameter.expandTemplate(template, pname -> resolveParameter(pname, resolver));
}
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) {
return source;
}
/**
* Combo parameter resolver function. First parameters are looked up in the global environment,
* then the local environment is looked up as a fallback.
*/
ComboParameter resolveParameter(String pname, Resolver resolver) {
//first search the env
ComboParameter parameter = env.parametersCache.get(pname);
if (parameter == null) {
//then lookup local cache
parameter = localParametersCache.get(pname);
if (parameter == null && resolver != null) {
//if still null and we have a custom resolution function, try that
parameter = resolver.lookup(pname);
if (parameter != null) {
//if a match was found, store it in the local cache to aviod redundant recomputation
localParametersCache.put(pname, parameter);
}
}
}
return parameter;
}
}
/**
* Helper class to collect all diagnostic generated during the execution of a given compilation task.
*/
class DiagnosticCollector implements DiagnosticListener<JavaFileObject> {
Map<Diagnostic.Kind, List<Diagnostic<? extends JavaFileObject>>> diagsByKind = new HashMap<>();
Map<String, List<Diagnostic<? extends JavaFileObject>>> diagsByKeys = new HashMap<>();
public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
List<Diagnostic<? extends JavaFileObject>> diags =
diagsByKeys.getOrDefault(diagnostic.getCode(), List.nil());
diagsByKeys.put(diagnostic.getCode(), diags.prepend(diagnostic));
Diagnostic.Kind kind = diagnostic.getKind();
diags = diagsByKind.getOrDefault(kind, List.nil());
diagsByKind.put(kind, diags.prepend(diagnostic));
}
}
}