import spock.lang.Issue

import java.time.Duration

import static org.gradle.tooling.events.task.java.JavaCompileTaskOperationResult.AnnotationProcessorResult.Type.ISOLATING

@TargetGradleVersion('>=4.6')
class JavaCompileTaskOperationResultCrossVersionTest extends ToolingApiSpecification {

    def setup() {
        settingsFile << """
            include 'processor'
        """

class SamplesJavaIncrementalAnnotationProcessingIntegrationTest extends AbstractIntegrationSpec {

    @Rule public final Sample processing = new Sample(temporaryFolder, 'java/incrementalAnnotationProcessing')

    def "isolating annotation processors are incremental"() {
        given:
        CompilationOutputsFixture outputs = new CompilationOutputsFixture(processing.dir.file("groovy/user/build/classes"))
        outputs.snapshot { compile() }

         */
        Duration getDuration();

        /**
         * Type of annotation processor.
         *
         * @since 5.1
         */
        enum Type {
            ISOLATING,
            AGGREGATING,
            UNKNOWN
        }
    }

 * See the user guide chapter on incremental annotation processing for more information.
 */
public enum IncrementalAnnotationProcessorType {
    ISOLATING,
    AGGREGATING,
    DYNAMIC,
    UNKNOWN;

    public String getProcessorOption() {
        return "org.gradle.annotation.processing." + name().toLowerCase(Locale.ROOT);
    }

        when:
        new IsolatingProcessor(Stub(Processor), processorResult)
        then:
        processorResult.type == IncrementalAnnotationProcessorType.ISOLATING
    }

    @Nullable
    List<InternalAnnotationProcessorResult> getAnnotationProcessorResults();

    interface InternalAnnotationProcessorResult extends InternalProtocolInterface {

        String TYPE_ISOLATING = "ISOLATING";
        String TYPE_AGGREGATING = "AGGREGATING";
        String TYPE_UNKNOWN = "UNKNOWN";

        String getClassName();

        String getType();

        Duration getDuration();

    }

import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.element.TypeElement;
import java.util.Set;

/**
 * An isolating processor must provide exactly one originating element
 * for each file it generates.
 */
public class IsolatingProcessor extends DelegatingProcessor {

    private final IsolatingProcessingStrategy strategy;

			// and gets ignored
		}
	}
}

// Bracket pairs within an isolating run sequence are processed as units so
// that both the opening and the closing paired bracket in a pair resolve to
// the same direction.
//
// N0. Process bracket pairs in an isolating run sequence sequentially in
// the logical order of the text positions of the opening paired brackets

    }

    public void updateFromOptions(Set<String> supportedOptions) {
        if (supportedOptions.contains(IncrementalAnnotationProcessorType.ISOLATING.getProcessorOption())) {
            delegate = new IsolatingProcessingStrategy(result);
        } else if (supportedOptions.contains(IncrementalAnnotationProcessorType.AGGREGATING.getProcessorOption())) {

            /**
             * Type of annotation processor.
             *
             * @see IncrementalAnnotationProcessorType
             */
            enum Type {
                ISOLATING, AGGREGATING, UNKNOWN
            }

        }

    }