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

/**
 * The strategy for isolating annotation processors.
 *
 * @see IsolatingProcessor
 */
class IsolatingProcessingStrategy extends IncrementalProcessingStrategy {

    IsolatingProcessingStrategy(AnnotationProcessorResult result) {
        super(result);
        result.setType(ISOLATING);
    }

    @Override

        }
    }

    /**
     * Contains the types generated by isolating annotation processors, grouped by the type they were generated from.
     */
    public Map<String, Set<String>> getGeneratedTypesWithIsolatedOrigin() {
        return generatedTypesByOrigin;
    }

    /**
     * Contains the resources generated by isolating annotation processors, grouped by the type they were generated from.
     */

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

import static org.gradle.api.internal.tasks.compile.incremental.processing.IncrementalAnnotationProcessorType.AGGREGATING
import static org.gradle.api.internal.tasks.compile.incremental.processing.IncrementalAnnotationProcessorType.ISOLATING
import static org.gradle.api.internal.tasks.compile.incremental.processing.IncrementalAnnotationProcessorType.UNKNOWN

class DynamicProcessorTest extends Specification {

    Processor delegate = Stub(Processor)

    }

    def "reports isolating processor in build operation"() {
        java "class Irrelevant {}"

        when:
        succeeds "compileJava"

        then:
        with(operations[':compileJava'].result.annotationProcessorDetails as List<Object>) {
            size() == 1
            first().className == 'HelperProcessor'
            first().type == ISOLATING.name()
        }
    }

    /**

    String generatedAnnotation = 'Service'
    boolean generateClassFile = false

    AnnotatedGeneratedClassProcessorFixture() {
        super("Bean")
        declaredType = IncrementalAnnotationProcessorType.ISOLATING
    }

    @Override
    String getDependenciesBlock() {
        if (generateClassFile) {
            """
                implementation 'org.ow2.asm:asm:9.0'
            """
        } else {

import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.element.TypeElement;
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()}.
 */

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