RunPreviousFailedFirstTestClassProcessor processor

    def 'previous failed test classes should be passed to delegate first'() {
        given:
        processor = new RunPreviousFailedFirstTestClassProcessor(['Class3'] as Set, delegate)

        when:
        processor.startProcessing(testResultProcessor)
        ['Class1', 'Class2', 'Class3'].each { processor.processTestClass(new DefaultTestClassRunInfo(it)) }

import org.gradle.api.tasks.testing.TestOutputEvent;
import org.gradle.internal.scan.UsedByScanPlugin;

/**
 * A processor for test results. Implementations are not required to be thread-safe.
 */
@UsedByScanPlugin("test-distribution, test-retry")
public interface TestResultProcessor {
    /**
     * Notifies this processor that a test has started execution.
     */
    @UsedByScanPlugin("test-distribution")

import org.gradle.internal.instrumentation.processor.extensibility.ClassLevelAnnotationsContributor;
import org.gradle.internal.instrumentation.processor.extensibility.CodeGeneratorContributor;
import org.gradle.internal.instrumentation.processor.extensibility.InstrumentationProcessorExtension;
import org.gradle.internal.instrumentation.processor.extensibility.RequestPostProcessorExtension;

        this.clock = clock;
    }

    @Override
    public void startProcessing(TestResultProcessor testResultProcessor) {
        try {
            resultProcessor = new AttachParentTestResultProcessor(new CaptureTestOutputTestResultProcessor(testResultProcessor, new JULRedirector()));
            resultProcessor.started(suiteDescriptor, new TestStartEvent(clock.getCurrentTime()));

    /**
     * The results of an annotation processor used during compilation.
     *
     * @since 5.1
     */
    interface AnnotationProcessorResult {

        /**
         * Returns the fully-qualified class name of this annotation processor.
         */
        String getClassName();

        /**
         * Returns the type of this annotation processor.
         *

        when:
        handler.executeScripts(gradle)

        then:
        1 * processor.process({ TextResourceScriptSource source -> source.resource.file == script1 }, gradle)
        1 * processor.process({ TextResourceScriptSource source -> source.resource.file == script2 }, gradle)
        0 * executor._
        0 * processor._
    }

        spec.setEffectiveAnnotationProcessors(annotationProcessors);
        return delegate.execute(spec);
    }

    /**
     * Scans the processor path for processor declarations. Filters them if the explicit <code>-processor</code> argument is given.
     * Treats explicit processors that didn't have a matching declaration on the path as non-incremental.
     */

 */
public class InitScriptHandler {
    private final InitScriptProcessor processor;
    private final BuildOperationRunner buildOperationRunner;
    private final TextFileResourceLoader resourceLoader;

    public InitScriptHandler(InitScriptProcessor processor, BuildOperationRunner buildOperationRunner, TextFileResourceLoader resourceLoader) {
        this.processor = processor;
        this.buildOperationRunner = buildOperationRunner;

                thread.block()
                instant.stopped
                worker.stop()
            }
        }
        1 * processor.startProcessing(_)
        1 * processor.processTestClass(test)
        1 * processor.stop()
    }

    private final Runnable detector;
    private final TestClassProcessor processor;
    private final TestResultProcessor resultProcessor;
    private final WorkerLeaseService workerLeaseService;
    private final Clock clock;
    private final Object rootTestSuiteId;
    private final String displayName;