StatefulSerializer<InterHubMessage> serializer = new InterHubMessageSerializer(
            new TypeSafeSerializer<MethodInvocation>(MethodInvocation.class,
                new MethodInvocationSerializer(
                    methodParamClassLoader,
                    argsSerializer)));

        connection = completion.create(serializer);

        then:
        0 * _._
    }

    def 'can use dispatch to receive notifications'() {
        given:
        Dispatch<MethodInvocation> dispatch1 = Mock()
        Dispatch<MethodInvocation> dispatch2 = Mock()
        def invocation = new MethodInvocation(TestListener.getMethod("event1", String.class), "param")

        broadcast.add(dispatch1)
        broadcast.add(dispatch2)

        when:

    }

    private static class DispatchingInvocationHandler implements InvocationHandler {
        private final Class<?> type;
        private final Dispatch<? super MethodInvocation> dispatch;

        private DispatchingInvocationHandler(Class<?> type, Dispatch<? super MethodInvocation> dispatch) {
            this.type = type;
            this.dispatch = dispatch;
        }

        @Override

        //         at org.junit.platform.commons.util.ReflectionUtils.invokeMethod(ReflectionUtils.java:675)
        //         at org.junit.jupiter.engine.execution.MethodInvocation.proceed(MethodInvocation.java:60)
        //         at org.junit.jupiter.engine.execution.InvocationInterceptorChain$ValidatingInvocation.proceed(InvocationInterceptorChain.java:125)

import org.gradle.api.Action
import org.spockframework.runtime.SpockAssertionError
import org.spockframework.runtime.SpockTimeoutError
import org.spockframework.runtime.extension.IMethodInvocation
import org.spockframework.runtime.extension.MethodInvocation
import org.spockframework.runtime.extension.builtin.TimeoutInterceptor
import org.spockframework.runtime.model.MethodInfo

import java.util.concurrent.TimeUnit

@CompileStatic

 * limitations under the License.
 */

package org.gradle.internal.remote.internal.hub

import org.gradle.api.GradleException
import org.gradle.internal.dispatch.MethodInvocation
import org.gradle.internal.dispatch.StreamCompletion
import org.gradle.internal.remote.internal.ConnectCompletion
import org.gradle.internal.remote.internal.TestConnection

 * limitations under the License.
 */

package org.gradle.internal.event;

import org.gradle.api.Action;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.MethodInvocation;
import org.gradle.internal.dispatch.ProxyDispatchAdapter;

import java.util.Collection;

/**
 * <p>Manages a set of listeners of type T. Provides an implementation of T which can be used to broadcast to all

            BuildScriptBuilder.Expression testImplementation = buildScriptBuilder.containerElementExpression("configurations", "testImplementation");
            buildScriptBuilder.methodInvocation(null, functionalTestImplementation, "extendsFrom", testImplementation);

import java.lang.reflect.Method;

public class ReflectionDispatch implements Dispatch<MethodInvocation> {
    private final Object target;

    public ReflectionDispatch(Object target) {
        this.target = target;
    }

    @Override
    public void dispatch(MethodInvocation message) {
        try {
            Method method = message.getMethod();
            method.setAccessible(true);

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

    def proxyForwardsToDispatch() {
        when:
        adapter.getSource().doStuff('param')

        then: