JavaMethod.of(backedObject, Void.class, "setForceRelativeOutput", boolean.class).invoke(backedObject, true);
            }
            JavaMethod.of(backedObject, Void.class, "processArgs", String[].class).invoke(backedObject, new Object[]{argArray});
            JavaMethod.of(backedObject, Void.class, "process").invoke(backedObject);

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

Alex Semin <******@****.***> 1696261454 +0200

    def "detects no processors in broken jars"() {
        given:
        def jar = tmpDir.file("classes.jar")
        jar << "broken"
        def cp = files(jar)

        when:
        def processors = detector.detectProcessors(cp)

        then:
        processors == [:]
        1 * logger.warn({ it.contains("no annotation processors") }, { it.message.contains("Error reading Zip") })
    }

=== Example: Registering incremental annotation processors

[listing]
.processor/src/main/resources/META-INF/gradle/incremental.annotation.processors
----
include::{snippetsPath}/java/incrementalAnnotationProcessing/groovy/processor/src/main/resources/META-INF/gradle/incremental.annotation.processors[tag=registering-incremental-annotation-processors]
----

            processor = processors.get(pos);
            pos = (pos + 1) % processors.size();
        }
        processor.processTestClass(testClass);
    }

    @Override
    public void stop() {
        try {
            CompositeStoppable.stoppable(processors).add(actors).add(resultProcessorActor).stop();
        } catch (DispatchException e) {
            throw UncheckedException.throwAsUncheckedException(e.getCause());

        Map<String, AnnotationProcessorDeclaration> processors = new LinkedHashMap<>();
        for (File jarOrClassesDir : processorPath) {
            for (AnnotationProcessorDeclaration declaration : cache.get(jarOrClassesDir)) {
                String className = declaration.getClassName();
                if (!processors.containsKey(className)) {
                    processors.put(className, declaration);
                }
            }

        private final List<OperationResultPostProcessor> processors;

        public PostProcessors(List<OperationResultPostProcessor> processors) {
            this.processors = processors;
        }

        @Override
        public void started(BuildOperationDescriptor buildOperation, OperationStartEvent startEvent) {
            for (OperationResultPostProcessor processor : processors) {

                processor = decorateForTimeTracking(processor, processorResult);
                processors.add(processor);
            }
            processors.add(supportedOptionsCollectingProcessor);
        }
        delegate.setProcessors(processors);
    }

    ClassLoader createProcessorClassLoader() {
        return new URLClassLoader(

import java.util.Set;

/**
 * Collects all registered processors' supported options.
 *
 * <p>This is a workaround for https://bugs.openjdk.java.net/browse/JDK-8162455, which
 * will be triggered a lot more during incremental compilations, and can fail builds
 * when combined with {@code -Werror}.
 *
 * <p>This processor needs to be added last to make sure that all other processors