when:
        dispatch.dispatchFailed("message", failure)
        dispatch.stop()

        then:
        def e = thrown(DispatchException)
        e.cause == failure
        0 * logger._
    }

    def logsAnySubsequentFailures() {
        RuntimeException failure1 = new RuntimeException()
        RuntimeException failure2 = new RuntimeException('broken2')

        when:

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

 */

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.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

        }

        then:
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested1 }
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested2 }
    }

    def "read bytes returns when stream is closed"() {
        def dispatch = Mock(OutputEventListener)
        def stream = new StdInStream(dispatch)

        when:
        async {
            start {

import java.util.Map;

import org.sonatype.plexus.components.cipher.PlexusCipher;
import org.sonatype.plexus.components.sec.dispatcher.DefaultSecDispatcher;
import org.sonatype.plexus.components.sec.dispatcher.PasswordDecryptor;
import org.sonatype.plexus.components.sec.dispatcher.SecDispatcher;

@Named("maven")
@Singleton
public final class MavenSecDispatcherProvider implements Provider<SecDispatcher> {

    }

    public void cleanup() {
        Thread.currentThread().contextClassLoader = original
    }

    def 'sets ContextClassLoader during dispatch'() {
        when:
        dispatch.dispatch('message')

        then:
        1 * target.dispatch('message') >> {
            assertContextClassloaderIs(appClassLoader)
        }
        0 * _._

        assertContextClassloaderIs(original)
    }