case 1:
                dispatch(invocation, dispatchers.get(0));
                break;
            default:
                dispatch(invocation, dispatchers.iterator());
                break;
        }
    }

    /**
     * Dispatch an invocation to multiple handlers.
     */
    private void dispatch(MethodInvocation invocation, Iterator<? extends Dispatch<MethodInvocation>> handlers) {

/**
 * An {@link EventBus} that takes the Executor of your choice and uses it to dispatch events,
 * allowing dispatch to occur asynchronously.
 *
 * @author Cliff Biffle
 * @since 10.0
 */
@ElementTypesAreNonnullByDefault
public class AsyncEventBus extends EventBus {

  /**
   * Creates a new AsyncEventBus that will use {@code executor} to dispatch events. Assigns {@code
   * identifier} as the bus's name for logging purposes.
   *

                    dispatchMessages(dispatch);
                } finally {
                    onDispatchThreadExit(dispatch);
                }
            }
        });
        onDispatchThreadStart(dispatch, dispatcher);
        executor.execute(CurrentBuildOperationPreservingRunnable.wrapIfNeeded(dispatcher));
    }

    private void dispatchMessages(Dispatch<? super T> dispatch) {
        while (true) {

 */

package org.gradle.internal.dispatch

import spock.lang.Specification

import static org.gradle.util.Matchers.strictlyEquals

class ProxyDispatchAdapterTest extends Specification {
    private final Dispatch<MethodInvocation> dispatch = Mock()
    private final ProxyDispatchAdapter<ProxyTest> adapter = new ProxyDispatchAdapter<ProxyTest>(dispatch, ProxyTest.class)

    def proxyForwardsToDispatch() {

import org.gradle.internal.concurrent.ThreadSafe;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.DispatchException;
import org.gradle.internal.dispatch.MethodInvocation;

/**
 * <p>An {@code Actor} dispatches method calls to a target object in a thread-safe manner. Methods are called either by
 * calling {@link Dispatch#dispatch(Object)} on the actor, or using the proxy object

        out == message
        0 * staleAddressDetector._
    }

    def "treats failure to dispatch before receiving as a stale address"() {
        def message = Stub(Message)
        def failure = new FooException()

        given:
        delegate.dispatch(message) >> { throw failure }

        when:
        connection.dispatch(message)

        then:
        def ex = thrown(StaleDaemonAddressException)

import org.gradle.internal.dispatch.Dispatch
import org.gradle.util.ConcurrentSpecification

import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.TimeUnit

class DaemonCancelForwarderTest extends ConcurrentSpecification {

    def cancellationToken = new DefaultBuildCancellationToken()

    def received = new LinkedBlockingQueue()
    def dispatch = { received << it } as Dispatch

 */

package org.gradle.internal.event;

import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.MethodInvocation;

public class AnonymousListenerBroadcast<T> extends ListenerBroadcast<T> {
    private final Dispatch<MethodInvocation> forwardingDispatch;

    public AnonymousListenerBroadcast(Class<T> type, Dispatch<MethodInvocation> forwardingDispatch) {
        super(type);

                return otherHandler.type.equals(type) && otherHandler.dispatch == dispatch;
            }

            if (method.getName().equals("hashCode")) {
                return dispatch.hashCode();
            }
            if (method.getName().equals("toString")) {
                return type.getSimpleName() + " broadcast";
            }
            dispatch.dispatch(new MethodInvocation(method, parameters));
            return null;

 */
package org.gradle.internal.dispatch;

public class FailureHandlingDispatch<T> implements Dispatch<T> {
    private final Dispatch<? super T> dispatch;
    private final DispatchFailureHandler<? super T> handler;

    public FailureHandlingDispatch(Dispatch<? super T> dispatch, DispatchFailureHandler<? super T> handler) {
        this.dispatch = dispatch;
        this.handler = handler;
    }

    @Override