*/

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

 */

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

	record := attributeRecord(nil, fakeParams, admission.Create)
	require.ErrorContains(t,
		testContext.Plugin.Dispatch(
			testContext,
			record,
			&admission.RuntimeObjectInterfaces{},
		),
		`Denied`)

	require.NoError(t, testContext.DeleteAndWait(denyPolicy))

	require.NoError(t, testContext.Plugin.Dispatch(
		testContext,
		// Object is irrelevant/unchecked for this test. Just test that

    }

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

            return;
        }

        dispatcher = new AsynchronousLogDispatcher(execution.getConnection(), build.getParameters().getLogLevel());
        LOGGER.info("{}{}). The daemon log file: {}", DaemonMessages.STARTED_RELAYING_LOGS, diagnostics.getPid(), diagnostics.getDaemonLog());
        dispatcher.start();
        try {
            execution.proceed();
        } finally {
            dispatcher.waitForCompletion();
        }
    }

    public DaemonCancelForwarder(final Dispatch<? super Cancel> dispatch, BuildCancellationToken cancellationToken) {
        this.cancellationToken = cancellationToken;
        cancellationCallback = new Runnable() {
            @Override
            public void run() {
                LOGGER.info("Request daemon to cancel build...");
                dispatch.dispatch(new Cancel());
            }
        };
    }