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

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

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

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

            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

    /**
     * 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

    protected abstract Action<String> createTestExecutor(Actor resultProcessorActor);

    @Override
    public void processTestClass(TestClassRunInfo testClass) {
        LOGGER.debug("Executing test class {}", testClass.getTestClassName());
        executor.execute(testClass.getTestClassName());
    }

    @Override
    public void stop() {

        process(clazz*.name)
    }

    void process(Iterable<String> classNames) {
        classProcessor.startProcessing(processor)
        for (String c : classNames) {
            classProcessor.processTestClass(new DefaultTestClassRunInfo(c))
        }
        classProcessor.stop()
    }

    void "executes the test class"() {
        when: process(ATestNGClass)

        if (spec.isDryRun()) {
            System.setProperty("testng.mode.dryrun", "true");
        }
    }

    @Override
    public void processTestClass(TestClassRunInfo testClass) {
        // TODO - do this inside some 'testng' suite, so that failures and logging are attached to 'testng' rather than some 'test worker'
        try {