jdk8-mips64-public/langtools: test/lib/combo/tools/javac/combo/JavacTemplateTestBase.java@67c5110c60fe (annotated)

test/lib/combo/tools/javac/combo/JavacTemplateTestBase.java@67c5110c60fe (annotated)

test/lib/combo/tools/javac/combo/JavacTemplateTestBase.java

Mon, 09 Sep 2013 17:11:55 -0400

author: emc
date: Mon, 09 Sep 2013 17:11:55 -0400
changeset 2017: 67c5110c60fe
parent 0: 959103a6100f
permissions: -rw-r--r--

8015322: Javac template test framework
Summary: Putback of the javac template test framework from the Lambda repository
Reviewed-by: jjg
Contributed-by: brian.goetz@oracle.com

 /*
  * Copyright (c) 2013, 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();
         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);
         }
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/lib/combo/tools/javac/combo/JavacTemplateTestBase.java@67c5110c60fe (annotated)

test/lib/combo/tools/javac/combo/JavacTemplateTestBase.java