}
        types == ['AnnotationType'] as Set
        result.executionTimeInMillis == 13
    }

    def "tracks time for getSupportedOptions()"() {
        when:
        def options = tracker.getSupportedOptions()

        then:
        1 * delegate.getSupportedOptions() >> {
            simulateWorkWithDuration(17)
            ['Option']
        }
        options == ['Option'] as Set

        return Collections.singleton("*");
    }

    @Override
    public Set<String> getSupportedOptions() {
        Set<String> supportedOptions = new HashSet<String>();
        for (Processor processor : processors) {
            supportedOptions.addAll(processor.getSupportedOptions());
        }
        return supportedOptions;
    }

    @Override

    private final Processor delegate;

    DelegatingProcessor(Processor delegate) {
        this.delegate = delegate;
    }

    @Override
    public Set<String> getSupportedOptions() {
        return delegate.getSupportedOptions();
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        return delegate.getSupportedAnnotationTypes();
    }

    @Override

import java.util.Set;

/**
 * An annotation processor which can decide whether it is isolating, aggregating or non-incremental at runtime.
 * It needs to return its type through the {@link #getSupportedOptions()} method in the format defined by
 * {@link IncrementalAnnotationProcessorType#getProcessorOption()}.
 */
public class DynamicProcessor extends DelegatingProcessor {
    private final DynamicProcessingStrategy strategy;

    def "sets initial processor type"() {
        expect:
        result.type == UNKNOWN
    }

    def "updates processor type from options for #type processor"() {
        given:
        delegate.getSupportedOptions() >> [type.processorOption]
        when:
        processor.init(Stub(ProcessingEnvironment))
        then:
        result.type == type
        where:
        type << [AGGREGATING, ISOLATING]
    }

        this.stopwatch = Stopwatch.createUnstarted(ticker);
    }

    @Override
    public Set<String> getSupportedOptions() {
        return track(new Factory<Set<String>>() {
            @Override
            public Set<String> create() {
                return TimeTrackingProcessor.super.getSupportedOptions();
            }
        });
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {

            """
            @Override
            public Set<String> getSupportedOptions() {
                return new HashSet<String>(Arrays.asList("message", "${IncrementalAnnotationProcessorType.ISOLATING.processorOption}"));
            }
            """
        } else {
            """
            @Override
            public Set<String> getSupportedOptions() {
                return Collections.singleton("message");

    @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

        }
    }
"""
    }

    @Override
    protected String getSupportedOptionsBlock() {
        """
            @Override
            public Set<String> getSupportedOptions() {
                return new HashSet<String>(Arrays.asList("${IncrementalAnnotationProcessorType.ISOLATING.processorOption}"));
            }
        """
    }

                        return false;
                    }

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

        private void writeMetaInfService() {