* calling {@link Dispatch#dispatch(Object)} on the actor, or using the proxy object
 * returned by {@link #getProxy(Class)}. Methods are delivered to the target object in the order they are called on the
 * actor, but are delivered to the target object by a single thread at a time. In this way, the target object does not need
 * to perform any synchronisation.</p>
 *
 * <p>An actor uses one of two modes to deliver method calls to the target object:</p>
 *

        TestClassProcessor asyncProcessor2 = Mock()
        Actor actor1 = Mock()
        Actor actor2 = Mock()

        startProcessor()

        when:
        processor.processTestClass(test)

        then:
        1 * factory.create() >> processor1
        1 * actorFactory.createActor(processor1) >> actor1
        1 * actor1.getProxy(TestClassProcessor) >> asyncProcessor1

        def actor1 = factory.createActor(target)
        def actor2 = factory.createActor(actor1)

        then:
        actor2.is(actor1)
    }

    def nonBlockingActorAndProxyAreBothMarkedAsThreadSafe() {
        when:
        def actor = factory.createActor(target)

        then:
        actor instanceof ThreadSafe
        actor.getProxy(Runnable) instanceof ThreadSafe
    }

            }
            NonBlockingActor actor = nonBlockingActors.get(target);
            if (actor == null) {
                actor = new NonBlockingActor(target);
                nonBlockingActors.put(target, actor);
            }
            return actor;
        }
    }

    @Override

 * limitations under the License.
 */

package org.gradle.internal.actor;

public interface ActorFactory {
    /**
     * Creates an asynchronous actor for the given target object.
     *
     * @param target The target object.
     * @return The actor.
     */
    Actor createActor(Object target);

    /**
     * Creates a synchronous actor for the given target object.
     *
     * @param target The target object.

        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);
        } else {

import org.gradle.api.internal.tasks.testing.TestClassRunInfo;
import org.gradle.api.internal.tasks.testing.TestResultProcessor;
import org.gradle.internal.actor.Actor;
import org.gradle.internal.actor.ActorFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public abstract class AbstractJUnitTestClassProcessor implements TestClassProcessor {

		return err
	}
	return rows.Close()
}

type Actor struct {
	ActorID   uint16
	FirstName string
	LastName  string
}

type ActorRepository struct {
	r Repository[Actor]
}

func (ActorRepository) scan(s Scanner, a *Actor) error {
	return s.Scan(&a.ActorID, &a.FirstName, &a.LastName)
}

func (r *ActorRepository) SelectAll(c Collection[*Actor]) error {

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) {

import org.gradle.api.Action;
import org.gradle.api.internal.tasks.testing.TestResultProcessor;
import org.gradle.api.internal.tasks.testing.results.AttachParentTestResultProcessor;
import org.gradle.internal.actor.Actor;
import org.gradle.internal.actor.ActorFactory;
import org.gradle.internal.id.IdGenerator;
import org.gradle.internal.time.Clock;

public class JUnitTestClassProcessor extends AbstractJUnitTestClassProcessor {