java类javax.annotation.processing.AbstractProcessor的实例源码

private void compile(Class<? extends AbstractProcessor> processorClass, List<String> classes) throws IOException {
        List<String> options = new ArrayList<String>();
        options.add("-s");
        options.add("src/test/java");
        options.add("-proc:only");
        options.add("-processor");
        options.add(processorClass.getName());
        options.add("-sourcepath");
        options.add("src/test/java");
        options.addAll(getAPTOptions());
        options.addAll(classes);

        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ByteArrayOutputStream err = new ByteArrayOutputStream();
        int compilationResult = compiler.run(null, out, err, options.toArray(new String[options.size()]));

//        Processor.elementCache.clear();
        if (compilationResult != 0) {
            Assert.fail("Compilation Failed:\n " + new String(err.toByteArray(), "UTF-8"));
        }
    }

/**
 * Test that the ijar tool preserves EnclosingMethod attributes and doesn't
 * prevent annotation processors from accessing all the elements in a package.
 */
@Test
public void testEnclosingMethod() throws IOException {
  JavaCompiler.CompilationTask task = makeCompilationTask("third_party/ijar/test/package-info.java");
  task.setProcessors(Arrays.asList(new AbstractProcessor() {
    @Override
    public Set<String> getSupportedAnnotationTypes() {
      return Collections.singleton("*");
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
      roundEnv.getElementsAnnotatedWith(java.lang.Override.class);
      return true;
    }
  }));
  if (!task.call()) {
    fail(getFailedCompilationMessage());
  }
}

public boolean generateInfoClasses(AbstractProcessor processor, List<Class<?>> sourceClasses)
        throws Exception {
    ImmutableSet<? extends AbstractProcessor> processors = ImmutableSet.of(processor);

    List<Diagnostic<? extends JavaFileObject>> diagnostics = compileWithProcessors(
            sourceClasses,
            processors
    );

    boolean failed = false;
    for (Diagnostic<?> diagnostic : diagnostics) {
        failed = failed | (diagnostic.getKind().equals(Kind.ERROR));
        System.out.println(String.format("[%s] %s [%s,%s]",
                diagnostic.getKind(), diagnostic.getMessage(Locale.getDefault()),
                diagnostic.getLineNumber(), diagnostic.getColumnNumber()
        ));
    }
    return failed;
}

@Test
public void testModelInfoClassGeneration() throws Exception {
    AbstractProcessor fieldNameProcessor = createFieldNameProcessor(outputClasses);

    // TODO hacky - can this be avoided?
    MetaApiInfoClassGenerator.addPath("./src/test/java/");
    boolean hasFailed = generator.generateInfoClasses(fieldNameProcessor, sourceClasses);

    assertFalse("generation of model info classes failed", hasFailed);

    File file;
    for (Class<?> outputClass : outputClasses) {
        file = new File(filePathFrom(outputClass));
        assertTrue("file "
                + outputClass.getSimpleName()
                + "Info.java should exist but does not", file.exists());
    }
}

private AbstractProcessor createFieldNameProcessor(Iterable<Class<?>> classesToOutput) {
    SourceGenerator<ModelTypeInfo, ModelMethodInfo> classGenerator = new ModelClassInfoSourceGenerator();
    HierarchyExtractor hierarchyExtractor = new ReflectionBasedHierarchyExtractor();
    SourceFileWriter<ModelTypeInfo> writer = new JavaxSourceFileWriter<>();
    TypeParser<ModelTypeInfo, ModelMethodInfo> typeParser = new ModelTypeParser(
            javadocParser,
            classesToOutput
    );

    return new FieldNameProcessor(
            classGenerator,
            hierarchyExtractor,
            writer,
            typeParser,
            classesToOutput
    );
}

@Test
public void testModelInfoClassGeneration() throws Exception {
    AbstractProcessor fieldNameProcessor = createFieldNameProcessor(sourceClasses);

    // TODO hacky - can this be avoided?
    MetaApiInfoClassGenerator.addPath("./src/test/java/");
    boolean hasFailed = generator.generateInfoClasses(fieldNameProcessor, sourceClasses);

    assertFalse("generation of model info classes failed", hasFailed);

    File file;
    for (Class<?> outputClass : sourceClasses) {
        file = new File(filePathFrom(outputClass));
        assertTrue("file "
                + outputClass.getSimpleName()
                + "EndpointInfo.java should exist but does not", file.exists());
    }
}

protected void check() throws Exception {
    String[] options = {
        "--should-stop:at=ATTR",
        "--debug:verboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}

protected void check() throws Exception {
    String[] options = {
        "-XDshouldStopPolicy=ATTR",
        "-XDverboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}

private static AbstractProcessor createWrappedInstance() {
    ClassLoader cl = Main.createShadowClassLoader();
    try {
        Class<?> mc = cl.loadClass("lombok.core.AnnotationProcessor");
        return (AbstractProcessor) mc.newInstance();
    } catch (Throwable t) {
        if (t instanceof Error) throw (Error) t;
        if (t instanceof RuntimeException) throw (RuntimeException) t;
        throw new RuntimeException(t);
    }
}

protected void check() throws Exception {
    String[] options = {
        "-XDshouldStopPolicy=ATTR",
        "-XDverboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}

protected void check() throws Exception {
    String[] options = {
        "-XDshouldStopPolicy=ATTR",
        "-XDverboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}

private static AbstractProcessor createWrappedInstance() {
    ClassLoader cl = Main.createShadowClassLoader();
    try {
        Class<?> mc = cl.loadClass("lombok.core.AnnotationProcessor");
        return (AbstractProcessor) mc.newInstance();
    } catch (Throwable t) {
        if (t instanceof Error) throw (Error) t;
        if (t instanceof RuntimeException) throw (RuntimeException) t;
        throw new RuntimeException(t);
    }
}

protected void check() throws Exception {
    String[] options = {
        "-XDshouldStopPolicy=ATTR",
        "-XDverboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}

protected void check() throws Exception {
    String[] options = {
        "-XDshouldStopPolicy=ATTR",
        "-XDverboseResolution=success,failure,applicable,inapplicable,deferred-inference,predef"
    };

    AbstractProcessor[] processors = { new ResolveCandidateFinder(), null };

    @SuppressWarnings("unchecked")
    DiagnosticListener<? super JavaFileObject>[] diagListeners =
            new DiagnosticListener[] { new DiagnosticHandler(false), new DiagnosticHandler(true) };

    for (int i = 0 ; i < options.length ; i ++) {
        JavacTask ct = (JavacTask)comp.getTask(null, fm, diagListeners[i],
                Arrays.asList(options[i]), null, Arrays.asList(jfo));
        if (processors[i] != null) {
            ct.setProcessors(Collections.singleton(processors[i]));
        }
        ct.analyze();
    }

    //check diags
    for (Diagnostic<? extends JavaFileObject> diag : diags) {
        for (DiagnosticProcessor proc : diagProcessors) {
            if (proc.matches(diag)) {
                proc.process(diag);
                break;
            }
        }
    }
    //check all candidates have been used up
    for (Map.Entry<ElementKey, Candidate> entry : candidatesMap.entrySet()) {
        if (!seenCandidates.contains(entry.getKey())) {
            error("Redundant @Candidate annotation on method " + entry.getKey().elem + " sig = " + entry.getKey().elem.asType());
        }
    }
}

static void assertProcess(BiConsumer<ProcessingEnvironment, RoundEnvironment> test) {
  File f = null;
  try {
    f = Files.createTempFile("test", ".java").toFile();
    try (PrintWriter writer = new PrintWriter(f)) {
      writer.print("class Empty {}");
    }
  } catch (IOException e) {
    throw new AssertionError(e);
  }
  JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
  StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, Locale.getDefault(), Charset.defaultCharset());
  JavaCompiler.CompilationTask task = compiler.getTask(new PrintWriter(System.out),
      fileManager,
      diagnostics,
      Collections.singletonList("-proc:only"),
      Collections.emptyList(),
      fileManager.getJavaFileObjectsFromFiles(Collections.singletonList(f)));
  task.setLocale(Locale.getDefault());
  task.setProcessors(Collections.singleton(new AbstractProcessor() {
    @Override
    public Set<String> getSupportedAnnotationTypes() {
      return Collections.singleton("*");
    }
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
      test.accept(processingEnv, roundEnv);
      return true;
    }
  }));
  assertTrue(task.call());
}

@Test
public void testGen() throws Exception {

  AtomicInteger count = new AtomicInteger();
  AbstractProcessor proc = new AbstractProcessor() {
    @Override
    public Set<String> getSupportedAnnotationTypes() {
      return Collections.singleton("*");
    }
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
      if  (count.getAndIncrement() == 0) {
        try {
          Filer filer = processingEnv.getFiler();
          Element elt = processingEnv.getElementUtils().getTypeElement("gen.GeneratedClass");
          JavaFileObject src = filer.createSourceFile("io.vertx.test.gen.GeneratedClass", elt);
          try (Writer writer = src.openWriter()) {
            writer.append("package io.vertx.test.gen;\npublic class GeneratedClass {\n}");
          }
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
      return true;
    }
  };

  Compiler<TestGenProcessor> compiler = buildCompiler(new TestGenProcessor(),  "io.vertx.test.gen");
  compiler.addProcessor(proc);
  compiler.assertCompile();
  assertEquals(3, count.get());

}

@Test
public void testCallbackIssuedAfterEnterWithAPs() throws IOException {
  // We add an unrelated source file here to make the compiler do something
  compiler.addSourceFileContents("Bar.java", "class Bar { }");
  compiler.setProcessors(
      ImmutableList.of(
          new AbstractProcessor() {
            @Override
            public Set<String> getSupportedAnnotationTypes() {
              return Collections.singleton("*");
            }

            @Override
            public boolean process(
                Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
              if (roundEnv.processingOver()) {
                Filer filer = processingEnv.getFiler();
                // We wait until the last possible momemt to generate Foo; if the callback is able to
                // get an element for it, that means it ran after the enter phase
                try (OutputStream outputStream =
                    filer.createSourceFile("Foo").openOutputStream()) {
                  outputStream.write("class Foo { }".getBytes());
                } catch (IOException e) {
                  throw new AssertionError(e);
                }
              }
              return false;
            }
          }));
  addCallback("callback");
  compiler.compile();

  assertThat(callbacksIssued, Matchers.contains("callback: Bar, Foo"));
}

private List<Diagnostic<? extends JavaFileObject>> compileWithProcessors(
        Iterable<Class<?>> classes,
        ImmutableSet<? extends AbstractProcessor> processors) throws Exception {

    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

    DiagnosticCollector<JavaFileObject> diagnosticCollector = new DiagnosticCollector<JavaFileObject>();

    StandardJavaFileManager fileManager = compiler.getStandardFileManager(
            diagnosticCollector,
            DEFAULT_LOCALE,
            DEFAULT_CHARSET
    );

    Iterable<? extends JavaFileObject> sourceCompilationUnits = transformToCompilationUnits(
            classes,
            fileManager
    );

    CompilationTask task = compiler.getTask(new OutputStreamWriter(System.out),
            fileManager, diagnosticCollector,
            Arrays.asList(
                    "-proc:only",
                    "-s", "./src/main/java"
            ),
            null,
            sourceCompilationUnits
    );

    task.setProcessors(processors);
    task.call();

    try {
        fileManager.close();
    } catch (IOException ioe) {
        throw new RuntimeException(ioe);
    }

    return diagnosticCollector.getDiagnostics();
}

private AbstractProcessor createFieldNameProcessor(Iterable<Class<?>> classesToOutput) {
    SourceGenerator<EndpointTypeInfo, EndpointMethodInfo> classGenerator = new EndpointClassInfoSourceGenerator();
    SourceFileWriter<EndpointTypeInfo> writer = new JavaxSourceFileWriter<>();
    TypeParser<EndpointTypeInfo, EndpointMethodInfo> typeParser = new EndpointTypeParser(
            javadocParser);

    return new ControllerAnnotationProcessor(
            classGenerator,
            writer,
            typeParser,
            classesToOutput
    );
}

private JavaCompiler.CompilationTask processAnnotations(String[] testSourceFileNames, ElasticSearchDocumentAnnotationProcessor annotationProcessor) throws URISyntaxException {
    // Get an instance of java compiler
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

    // Get a new instance of the standard file manager implementation
    StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);

    // Get the list of java file objects, in this case we have only
    // one file, TestClass.java
    // http://stackoverflow.com/a/676102/693752
    List<File> listSourceFiles = new ArrayList<>();
    for (String sourceFileName : testSourceFileNames) {
        URL filename = ClassLoader.getSystemResource(sourceFileName);
        listSourceFiles.add(new File(filename.toURI()));
    }
    Iterable<? extends JavaFileObject> compilationUnits1 = fileManager.getJavaFileObjectsFromFiles(listSourceFiles);

    // Create the compilation task
    List<String> options = new ArrayList<>(Arrays.asList("-d", sandBoxDir.getAbsolutePath()));
    JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, options, null, compilationUnits1);

    if (annotationProcessor != null) {
        // Create a list to hold annotation processors
        LinkedList<AbstractProcessor> processors = new LinkedList<AbstractProcessor>();

        // Add an annotation processor to the list
        processors.add(annotationProcessor);
        // Set the annotation processor to the compiler task
        task.setProcessors(processors);
    }

    return task;
}

private JavaCompiler.CompilationTask processAnnotations(String[] testSourceFileNames, ElasticSearchTypeAnnotationProcessor annotationProcessor) throws URISyntaxException {
    // Get an instance of java compiler
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

    // Get a new instance of the standard file manager implementation
    StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);

    // Get the list of java file objects, in this case we have only
    // one file, TestClass.java
    // http://stackoverflow.com/a/676102/693752
    List<File> listSourceFiles = new ArrayList<>();
    for (String sourceFileName : testSourceFileNames) {
        URL filename = ClassLoader.getSystemResource(sourceFileName);
        listSourceFiles.add(new File(filename.toURI()));
    }
    Iterable<? extends JavaFileObject> compilationUnits1 = fileManager.getJavaFileObjectsFromFiles(listSourceFiles);

    // Create the compilation task
    List<String> options = new ArrayList<>(Arrays.asList("-d", sandBoxDir.getAbsolutePath()));
    JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, options, null, compilationUnits1);

    if (annotationProcessor != null) {
        // Create a list to hold annotation processors
        LinkedList<AbstractProcessor> processors = new LinkedList<AbstractProcessor>();

        // Add an annotation processor to the list
        processors.add(annotationProcessor);
        // Set the annotation processor to the compiler task
        task.setProcessors(processors);
    }

    return task;
}

@Test
public void testWrappedInitCall() {

    AbstractProcessor processorSpy = Mockito.spy(AbstractProcessor.class);

    Messager messager = Mockito.spy(Messager.class);
    ProcessingEnvironment processingEnvironment = Mockito.spy(ProcessingEnvironment.class);
    Mockito.when(processingEnvironment.getMessager()).thenReturn(messager);

    Processor unit = AnnotationProcessorWrapper.wrapProcessor(processorSpy);
    unit.init(processingEnvironment);

    Mockito.verify(processorSpy).init(processingEnvironment);


}

@Test
public void testWrappedProcessCall() {

    AbstractProcessor processorSpy = Mockito.spy(AbstractProcessor.class);

    Messager messager = Mockito.spy(Messager.class);
    ProcessingEnvironment processingEnvironment = Mockito.spy(ProcessingEnvironment.class);
    Mockito.when(processingEnvironment.getMessager()).thenReturn(messager);

    Processor unit = AnnotationProcessorWrapper.wrapProcessor(processorSpy);
    unit.init(processingEnvironment);


    Set<? extends TypeElement> set = new HashSet<TypeElement>();
    RoundEnvironment roundEnvironment = Mockito.mock(RoundEnvironment.class);


    unit.process(set, roundEnvironment);

    Mockito.verify(messager).printMessage(Diagnostic.Kind.NOTE, AbstractAnnotationProcessorTest.TEST_EXECUTION_MESSAGE);
    Mockito.verify(processorSpy).process(set, roundEnvironment);

}

@Test
public void testWrappedCompletionsCall() {

    AbstractProcessor processorSpy = Mockito.spy(AbstractProcessor.class);

    Element element = Mockito.mock(Element.class);
    AnnotationMirror annotationMirror = Mockito.mock(AnnotationMirror.class);
    ExecutableElement executableElement = Mockito.mock(ExecutableElement.class);
    String str = "XX";


    Processor unit = AnnotationProcessorWrapper.wrapProcessor(processorSpy);
    unit.getCompletions(element, annotationMirror, executableElement, str);

    Mockito.verify(processorSpy).getCompletions(element, annotationMirror, executableElement, str);


}

public DataClassBuilderHandler(AbstractProcessor processor, ProcessingEnvironment processingEnvironment) {
    super(processor, processingEnvironment, DataClassBuilder.class, ElementKind.INTERFACE, ElementKind.CLASS);
}

public BaseAnnotationHandler(AbstractProcessor processor, ProcessingEnvironment processingEnvironment, Class<T> handledAnnotation, ElementKind... handledKinds) {
    this.processor = processor;
    this.env = processingEnvironment;
    this.handledAnnotation = handledAnnotation;
    this.handledKinds = handledKinds;
}

@Override
public Statement apply(final Statement base, Description description)
{
    return new Statement()
    {
        @Override
        public void evaluate()
                throws Throwable
        {
            final AtomicReference<Throwable> thrown = new AtomicReference<Throwable>();
            boolean successful = compile(ImmutableList.of(new AbstractProcessor()
            {
                @Override
                public SourceVersion getSupportedSourceVersion()
                {
                    return SourceVersion.latest();
                }

                @Override
                public Set<String> getSupportedAnnotationTypes()
                {
                    return ImmutableSet.of("*");
                }

                @Override
                public synchronized void init(ProcessingEnvironment processingEnv)
                {
                    super.init(processingEnv);
                    elements = processingEnv.getElementUtils();
                    types = processingEnv.getTypeUtils();
                }

                @Override
                public boolean process(Set<? extends TypeElement> annotations,
                        RoundEnvironment roundEnv)
                {
                    // just run the test on the last round after compilation is over
                    if (roundEnv.processingOver()) {
                        try {
                            base.evaluate();
                        }
                        catch (Throwable e) {
                            thrown.set(e);
                        }
                    }
                    return false;
                }
            }));
            checkState(successful);
            Throwable t = thrown.get();
            if (t != null) {
                throw t;
            }
        }
    };
}

public ParameterizedCheckerTest(File testFile,
        Class<? extends AbstractProcessor> checker, String checkerDir, String... checkerOptions) {
    super(checker, checkerDir, checkerOptions);
    this.testFile = testFile;
}

private void runTest(TestRunnable r) throws Exception {
  testCompiler.addSourceFile(getSourceFile("Foo.java"));
  if (testMode == WITH_DEPS) {
    testCompiler.addClasspathSourceFile(getSourceFile("Dependency.java"));
    testCompiler.addClasspathSourceFile(getSourceFile("DependencyException.java"));
    testCompiler.addClasspathSourceFile(getSourceFile("DependencyInterface.java"));
  } else {
    testCompiler.useFrontendOnlyJavacTask();
  }

  testCompiler.setProcessors(
      Collections.singletonList(
          new AbstractProcessor() {
            @Override
            public Set<String> getSupportedOptions() {
              return Collections.emptySet();
            }

            @Override
            public Set<String> getSupportedAnnotationTypes() {
              return Collections.singleton("*");
            }

            @Override
            public SourceVersion getSupportedSourceVersion() {
              return SourceVersion.RELEASE_8;
            }

            @Override
            public boolean process(
                Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
              if (roundEnv.processingOver()) {
                try {
                  r.run();
                } catch (Exception e) {
                  throw new AssertionError(e);
                }
              }
              return false;
            }
          }));

  elements = testCompiler.getElements();
  testCompiler.enter();
}

@Test
public void testAnnotationProcessorGetsNewElementsEachRound() throws Exception {
  final AtomicBoolean processorRan = new AtomicBoolean(false);

  initCompiler(ImmutableMap.of("Foo.java", "public class Foo { }"));

  testCompiler.setProcessors(
      ImmutableList.of(
          new AbstractProcessor() {
            private Elements elementsFromEnvironment;
            private TypeElement element;

            @Override
            public Set<String> getSupportedAnnotationTypes() {
              return Collections.singleton("*");
            }

            @Override
            public synchronized void init(ProcessingEnvironment processingEnv) {
              super.init(processingEnv);
              elementsFromEnvironment = processingEnv.getElementUtils();
            }

            @Override
            public boolean process(
                Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
              TypeElement newElement = elementsFromEnvironment.getTypeElement("Foo");
              assertNotNull(newElement);
              assertNotSame(newElement, element);
              element = newElement;

              processorRan.set(roundEnv.processingOver());

              return false;
            }
          }));

  testCompiler.compile();

  assertTrue(processorRan.get());
}