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

 * methods willed be called sequentially in the following order:
 *
 * - {@link RemoteTestClassProcessor#startProcessing()}
 * - 0 or more calls to {@link RemoteTestClassProcessor#processTestClass(TestClassRunInfo)}
 * - {@link RemoteTestClassProcessor#stop()}
 *
 * Commands are received on communication threads and then processed sequentially on the main thread.  Although concurrent calls to

        candidateClassFiles.visit(new ClassFileVisitor() {
            @Override
            public void visitClassFile(FileVisitDetails fileDetails) {
                testFrameworkDetector.processTestClass(new RelativeFile(fileDetails.getFile(), fileDetails.getRelativePath()));
            }
        });
    }

    private void filenameScan() {
        candidateClassFiles.visit(new ClassFileVisitor() {

 */
public interface RemoteTestClassProcessor {
    /**
     * Does not block.
     */
    void startProcessing();

    /**
     * Does not block.
     */
    void processTestClass(TestClassRunInfo testClass);

    /**
     * Does not block.
     */
    void stop();

            for (String includedTests : testSelection.getIncludedTests()) {
                TestClassRunInfo testClass = new DefaultTestClassRunInfo(includedTests);
                testClassProcessor.processTestClass(testClass);
            }
        }
    }

    static class XCTestProcessor implements TestClassProcessor {
        private TestResultProcessor resultProcessor;
        private ExecHandle execHandle;

            resultProcessor.failure(suiteDescriptor.getId(), TestFailure.fromTestFrameworkFailure(rawFailure));
        }
    }

    @Override
    public void processTestClass(TestClassRunInfo testClass) {
        try {
            processor.processTestClass(testClass);
        } catch (Throwable t) {

    }

    @Override
    public void startProcessing(TestResultProcessor resultProcessor) {
        this.resultProcessor = resultProcessor;
    }

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

            if (remoteProcessor == null) {

        RuntimeException failure = new RuntimeException()
        processor.startProcessing(resultProcessor)

        when:
        processor.processTestClass(testClass)

        then:
        1 * targetProcessor.processTestClass(testClass) >> { throw failure }
        1 * resultProcessor.failure('id', !null) >> { args ->
            def e = args[1]
            assert e instanceof DefaultTestFailure

import java.io.File;
import java.util.List;

public interface TestFrameworkDetector {
    void startDetection(TestClassProcessor testClassProcessor);

    boolean processTestClass(RelativeFile testClassFile);

    void setTestClasses(List<File> testClasses);

    void setTestClasspath(List<File> classpath);

    /**
     * Accepts the given test class for processing. May execute synchronously, asynchronously, or defer execution for
     * later.
     *
     * @param testClass The test class.
     */
    void processTestClass(TestClassRunInfo testClass);

    /**
     * Completes any pending or asynchronous processing. Blocks until all processing is complete. The processor should