public class AttachParentTestResultProcessor implements TestResultProcessor {
    private Object rootId;
    private final TestResultProcessor processor;

    public AttachParentTestResultProcessor(TestResultProcessor processor) {
        this.processor = processor;
    }

    @Override
    public void started(TestDescriptorInternal test, TestStartEvent event) {
        if (rootId == null) {

    static class Forwarder implements StandardOutputRedirector.OutputListener {
        final TestResultProcessor processor;
        final TestOutputEvent.Destination dest;
        Object outputOwner;

        public Forwarder(TestResultProcessor processor, TestOutputEvent.Destination dest) {
            this.processor = processor;
            this.dest = dest;
        }

        @Override

import org.gradle.internal.concurrent.Stoppable;

/**
 * A processor for executing tests. Implementations are not required to be thread-safe.
 */
public interface TestClassProcessor extends Stoppable {
    /**
     * Performs any initialisation which this processor needs to perform.
     *
     * @param resultProcessor The processor to send results to during test execution.
     */

    private StringBuilder textBuilder = new StringBuilder();

    XCTestScraper(TestOutputEvent.Destination destination, TestResultProcessor processor, IdGenerator<?> idGenerator, Clock clock, String rootTestSuiteId, Deque<XCTestDescriptor> testDescriptors) {
        this.processor = processor;
        this.destination = destination;
        this.idGenerator = idGenerator;
        this.clock = clock;

    override fun processDeclaredConstructors(processor: (FirConstructorSymbol) -> Unit) {
        delegate.processDeclaredConstructors(processor)
    }

    override fun getClassifierNames(): Set<Name> = delegate.getClassifierNames()

    override fun processClassifiersByNameWithSubstitution(name: Name, processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit) {

/**
 * Base class for all annotation processor test fixtures. Each processor listens to a single annotation.
 * It provides the basic scaffolding, like fields for the filer, element utils and messager as well as
 * finding the annotated elements. Subclasses only need to provide the processing logic given those elements.
 *
 * The declared type of the processor can be overwritten to test various error cases, e.g. a processor that

        skipped(':compileJava')
        executedAndNotSkipped(':compileScala')
        new File(testDirectory, 'generated.txt').exists()
    }

    def "processes annotation for Java class with processor option if annotation processor is available on processor path"() {
        when:
        AnnotationProcessorPublisher annotationProcessorPublisher = new AnnotationProcessorPublisher()
        annotationProcessorPublisher.writeSourceFiles()

    AnnotationProcessorResult processorResult = new AnnotationProcessorResult(result, "")
    Processor delegate = Stub(Processor)
    AggregatingProcessor processor = new AggregatingProcessor(delegate, processorResult)

    def "sets processor type"() {
        expect:
        processorResult.type == IncrementalAnnotationProcessorType.AGGREGATING
    }

        /**
         * Details about an annotation processor used during compilation.
         */
        interface AnnotationProcessorDetails {

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

            /**
             * Returns the type of this annotation processor.
             */
            Type getType();

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