['Class1', 'Class2', 'Class3'].each { processor.processTestClass(new DefaultTestClassRunInfo(it)) }
        processor.stop()

        then:
        1 * delegate.startProcessing(testResultProcessor)
        then:
        1 * delegate.processTestClass(new DefaultTestClassRunInfo('Class3'))
        then:
        1 * delegate.processTestClass(new DefaultTestClassRunInfo('Class1'))
        then:

        processor.processTestClass(test1)
        processor.processTestClass(test2)

        then:
        1 * factory.create() >> delegate
        1 * delegate.startProcessing(resultProcessor)
        then:
        1 * delegate.processTestClass(test1)
        then:
        1 * delegate.processTestClass(test2)
        then:
        1 * delegate.stop()
        0 * _._
    }

        1 * asyncProcessor2.processTestClass(test)

        when:
        processor.processTestClass(test)

        then:
        1 * asyncProcessor1.processTestClass(test)

        when:
        processor.processTestClass(test)

        then:
        1 * asyncProcessor2.processTestClass(test)
    }

        }
    }

    @Override
    public void stop() {
        for (TestClassRunInfo test : prioritizedTestClasses) {
            delegate.processTestClass(test);
        }
        for (TestClassRunInfo test : otherTestClasses) {
            delegate.processTestClass(test);
        }
        delegate.stop();
    }

    @Override
    public void stopNow() {
        delegate.stopNow();
    }

        def processor = newProcessor()

        when:
        processor.processTestClass(test1)
        processor.processTestClass(test2)

        then:
        1 * workerLeaseRegistry.startWorker()
        1 * remoteProcessor.processTestClass(test1)
        1 * remoteProcessor.processTestClass(test2)
        1 * remoteProcessor.startProcessing()
        0 * remoteProcessor._
    }

        } finally {
            IoActions.closeQuietly(classStream);
        }
    }

    @Override
    public boolean processTestClass(final RelativeFile testClassFile) {
        return processTestClass(testClassFile.getFile(), false, new Factory<String>() {
            @Override
            public String create() {

    }

    @Override
    public void processTestClass(TestClassRunInfo testClass) {
        if (stoppedNow) {
            return;
        }

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

        delegate.startProcessing(resultProcessor);
    }

    @Override
    public void processTestClass(TestClassRunInfo testClass) {
        if (testClassSelectionMatcher.mayIncludeClass(testClass.getTestClassName())) {
            delegate.processTestClass(testClass);
        }
    }

    @Override
    public void stop() {
        delegate.stop();
    }

    @Override

        resultProcessorActor = actorFactory.createActor(resultProcessor);
        this.resultProcessor = resultProcessorActor.getProxy(TestResultProcessor.class);
    }

    @Override
    public void processTestClass(TestClassRunInfo testClass) {
        if (stoppedNow) {
            return;
        }

        TestClassProcessor processor;
        if (processors.size() < maxProcessors) {

            assert visitor
            visitor.visitFile(class1)
            visitor.visitFile(class2)
        }
        then:
        1 * detector.processTestClass({ it.file.is(class1.file) && it.relativePath.is(class1.relativePath) })
        then:
        1 * detector.processTestClass({ it.file.is(class2.file) && it.relativePath.is(class2.relativePath) })

        0 * _._
    }

    void skipAnonymousClass() {
        when: