given:
        def jar = tmpDir.file("classes.jar")
        jar << JarUtils.jarWithContents((INCREMENTAL_PROCESSOR_DECLARATION): "InJar,ISOLATING")
        def dir = tmpDir.file("classes")
        dir.file(INCREMENTAL_PROCESSOR_DECLARATION) << "InDir,ISOLATING"
        def cp = files(jar, dir)

        expect:
        detector.detectProcessors(cp) == [:]
    }

# tag::registering-incremental-annotation-processors[]
org.gradle.EntityProcessor,isolating
org.gradle.ServiceRegistryProcessor,dynamic

            return false;
        }

        // tag::isolating-annotation-processor[]
        Set<? extends Element> entities = roundEnv.getElementsAnnotatedWith(entityAnnotation);
        for (Element entity : entities) {
            createRepository((TypeElement) entity);
        }
        // end::isolating-annotation-processor[]
        return true;
    }

                    return AnnotationProcessorDetails.Type.AGGREGATING;
                }
                if (type == IncrementalAnnotationProcessorType.ISOLATING) {
                    return AnnotationProcessorDetails.Type.ISOLATING;
                }
                return AnnotationProcessorDetails.Type.UNKNOWN;
            }
        });
    }

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
        }
    }

    @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 org.gradle.api.attributes.Attribute;
import org.gradle.internal.hash.ClassLoaderHierarchyHasher;
import org.gradle.internal.hash.HashCode;
import org.gradle.internal.isolation.Isolatable;
import org.gradle.internal.isolation.IsolatableFactory;
import org.gradle.internal.state.Managed;
import org.gradle.internal.state.ManagedFactoryRegistry;

import javax.annotation.Nullable;
import java.io.File;

    }

    private Processor decorateForIncrementalProcessing(Processor processor, IncrementalAnnotationProcessorType type, AnnotationProcessorResult processorResult) {
        switch (type) {
            case ISOLATING:
                return new IsolatingProcessor(processor, processorResult);
            case AGGREGATING:
                return new AggregatingProcessor(processor, processorResult);
            case DYNAMIC: