return TimeTrackingProcessor.super.getSupportedAnnotationTypes();
            }
        });
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return track(new Factory<SourceVersion>() {
            @Override
            public SourceVersion create() {
                return TimeTrackingProcessor.super.getSupportedSourceVersion();
            }
        });
    }

    @Override

import java.util.Collections;
import java.util.Set;

@SupportedAnnotationTypes("Entity")
public class EntityProcessor extends AbstractProcessor {

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

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

    }

    def "tracks time for getSupportedSourceVersion()"() {
        when:
        def sourceVersion = tracker.getSupportedSourceVersion()

        then:
        1 * delegate.getSupportedSourceVersion() >> {
            simulateWorkWithDuration(3)
            SourceVersion.RELEASE_8
        }
        sourceVersion == SourceVersion.RELEASE_8
        result.executionTimeInMillis == 3
    }

    def "tracks time for init()"() {

    protected void store(Properties properties) {
        String sourceVersion = EclipseJavaVersionMapper.toEclipseJavaVersion(sourceCompatibility);
        String targetVersion = EclipseJavaVersionMapper.toEclipseJavaVersion(targetCompatibility);

        properties.put("org.eclipse.jdt.core.compiler.compliance", sourceVersion);
        properties.put("org.eclipse.jdt.core.compiler.source", sourceVersion);

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

    // tag::options-of-dynamic-processor[]
    @Override
    public Set<String> getSupportedOptions() {
        return Collections.singleton("org.gradle.annotation.processing.aggregating");
    }
    // end::options-of-dynamic-processor[]

    @Override

            supportedOptions.addAll(processor.getSupportedOptions());
        }
        return supportedOptions;
    }

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

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        return false;
    }

package org.gradle.api.internal.tasks.compile.processing;

import javax.annotation.processing.Filer;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import java.util.Locale;
import java.util.Map;

/**
 * A decorator for the {@link ProcessingEnvironment} provided by the Java compiler,

import javax.annotation.processing.Completion;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import java.util.Set;

/**

                }

                ${supportedOptionsBlock}

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

                @Override
                public synchronized void init(ProcessingEnvironment processingEnv) {

import javax.lang.model.SourceVersion;
import java.util.Arrays;
import java.util.Collection;

import static org.gradle.internal.instrumentation.processor.AddGeneratedClassNameFlagFromClassLevelAnnotation.ifHasAnnotation;
import static org.gradle.internal.instrumentation.processor.AddGeneratedClassNameFlagFromClassLevelAnnotation.ifHasExtraOfType;

@SupportedSourceVersion(SourceVersion.RELEASE_8)