* when combined with {@code -Werror}.
 *
 * <p>This processor needs to be added last to make sure that all other processors
 * have been {@linkplain Processor#init(ProcessingEnvironment) initialized} when
 * {@link #getSupportedOptions()} is called.
 */
public class SupportedOptionsCollectingProcessor extends AbstractProcessor {
    private final List<Processor> processors = new ArrayList<Processor>();

    public void addProcessor(Processor processor) {

    }

    def "stopNow does nothing when no remote processor"() {
        given:
        def processor = newProcessor()

        when:
        processor.stopNow()

        then:
        0 * _
    }

    def "stopNow propagates to worker process"() {
        given:
        def processor = newProcessor()

        when:
        processor.processTestClass(Mock(TestClassRunInfo))

    private final TestResultProcessor processor;
    private final TestOutputRedirector outputRedirector;
    private Object rootId;
    private Map<Object, Object> parents = new ConcurrentHashMap<Object, Object>();

    public CaptureTestOutputTestResultProcessor(TestResultProcessor processor, StandardOutputRedirector outputRedirector) {
        this(processor, new TestOutputRedirector(processor, outputRedirector));
    }

        }
        out
    }

    def "explicit -processor option overrides automatic detection"() {
        buildFile << """
            compileJava.options.compilerArgs << "-processor" << "unknown.Processor"
        """
        java "class A {}"

        expect:
        fails("compileJava")
        failure.assertHasCause("Annotation processor 'unknown.Processor' not found")
    }

        TestDescriptorInternal other = suite('suite1')
        TestDescriptorInternal test = test('test')

        processor.started(root, new TestStartEvent(100L))
        processor.completed('root', new TestCompleteEvent(200L))
        processor.started(other, new TestStartEvent(200L))

        when:
        processor.started(test, new TestStartEvent(200L))

        then:
        1 * target.started(test, { it.parentId == 'suite1' })

        then:
        1 * processor.startProcessing(!null)
        then:
        1 * detector.run()
        then:
        1 * workerLeaseService.blocking(_) >> { Runnable runnable -> runnable.run() }
        1 * processor.stop() >> { throw failure }
        then:
        1 * resultProcessor.completed(!null, !null)

        0 * resultProcessor._
        0 * detector._
        0 * processor._

        }

        if (processor == null) {
            processor = factory.create();
            processor.startProcessing(resultProcessor);
        }
        processor.processTestClass(testClass);
        testCount++;
        if (testCount == restartEvery) {
            endBatch();
        }
    }

    @Override
    public void stop() {
        if (processor != null) {
            endBatch();
        }

    Processor delegate = Stub(Processor)
    AnnotationProcessorResult result = new AnnotationProcessorResult(null, "")
    DynamicProcessor processor = new DynamicProcessor(delegate, result)

    def "sets initial processor type"() {
        expect:
        result.type == UNKNOWN
    }

    def "updates processor type from options for #type processor"() {
        given:

    @Issue("gradle/gradle#1471")
    def "fails when -processor is the last compiler arg"() {
        given:
        spec.compileOptions.compilerArgs = ["-Xthing", "-processor"]

        when:
        compiler.execute(spec)

        then:
        def e = thrown(InvalidUserDataException)
        e.message == 'No processor specified for compiler argument -processor in requested compiler args: -Xthing -processor'
    }

        }

        TestClassProcessor processor;
        if (processors.size() < maxProcessors) {
            processor = factory.create();
            rawProcessors.add(processor);
            Actor actor = actorFactory.createActor(processor);
            processor = actor.getProxy(TestClassProcessor.class);
            actors.add(actor);
            processors.add(processor);
            processor.startProcessing(resultProcessor);