def createsABlockingActorForATargetObject() {
        when:
        def actor = factory.createBlockingActor(target)

        then:
        actor != null
    }

    def cachesTheBlockingActorForATargetObject() {
        when:
        def actor1 = factory.createBlockingActor(target)
        def actor2 = factory.createBlockingActor(target)

        then:
        actor1.is(actor2)
    }

    Actor createActor(Object target);

    /**
     * Creates a synchronous actor for the given target object.
     *
     * @param target The target object.
     * @return The actor.
     */
    Actor createBlockingActor(Object target);

public class TestActorFactory implements ActorFactory {
    @Override
    public Actor createActor(Object target) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Actor createBlockingActor(final Object target) {
        return new Actor() {
            @Override
            public <T> T getProxy(Class<T> type) {

        // Wrap the result processor chain up in a blocking actor, to make the whole thing thread-safe
        resultProcessorActor = actorFactory.createBlockingActor(resultProcessorChain);
        executor = createTestExecutor(resultProcessorActor);
    }

    protected abstract TestResultProcessor createResultProcessorChain(TestResultProcessor resultProcessor);

                actor = new NonBlockingActor(target);
                nonBlockingActors.put(target, actor);
            }
            return actor;
        }
    }

    @Override
    public Actor createBlockingActor(Object target) {
        synchronized (lock) {
            if (nonBlockingActors.containsKey(target)) {

    }

    @Override
    public void startProcessing(TestResultProcessor resultProcessor) {
        // Wrap the processor in an actor, to make it thread-safe
        resultProcessorActor = actorFactory.createBlockingActor(resultProcessor);
        this.resultProcessor = resultProcessorActor.getProxy(TestResultProcessor.class);
        applicationClassLoader = Thread.currentThread().getContextClassLoader();
        if (spec.isDryRun()) {