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._

    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:

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

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

        }

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

import (
	"internal/cpu"
)

var useAVXmemmove bool

func init() {
	// Let's remove stepping and reserved fields
	processor := processorVersionInfo & 0x0FFF3FF0

	isIntelBridgeFamily := isIntel &&
		processor == 0x206A0 ||
		processor == 0x206D0 ||
		processor == 0x306A0 ||
		processor == 0x306E0

	useAVXmemmove = cpu.X86.HasAVX && !isIntelBridgeFamily

    @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);

    def firesSuiteStartEventOnStartProcessing() {
        when:
        processor.startProcessing(resultProcessor)

        then:
        1 * resultProcessor.started(suiteDescriptor, !null)
        1 * targetProcessor.startProcessing(!null) >> { args ->
            def processor = args[0]
            processor instanceof AttachParentTestResultProcessor && args[0].processor == resultProcessor
        }
    }

    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