import org.gradle.util.internal.CollectionUtils;

import java.lang.reflect.Method;
import java.util.Arrays;

public class MethodInvocation {
    private static final Object[] ZERO_ARGS = new Object[0];
    private final Method method;
    private final Object[] arguments;

    public MethodInvocation(Method method, Object[] args) {
        this.method = method;
        arguments = args == null ? ZERO_ARGS : args;
    }

     * Dispatch an invocation to multiple handlers.
     */
    private void dispatch(MethodInvocation invocation, Iterator<? extends Dispatch<MethodInvocation>> handlers) {
        // Defer creation of failures list, assume dispatch will succeed
        List<Throwable> failures = null;
        while (handlers.hasNext()) {
            Dispatch<MethodInvocation> handler = handlers.next();
            try {
                handler.dispatch(invocation);

        private final ReentrantLock broadcasterLock = new ReentrantLock();
        private ListenerDetails logger;
        private Dispatch<MethodInvocation> parentDispatch;
        private List<Dispatch<MethodInvocation>> allWithLogger = Collections.emptyList();
        private List<Dispatch<MethodInvocation>> allWithNoLogger = Collections.emptyList();
        private boolean notified;

        EventBroadcast(Class<T> type) {

        }

        @Override
        public void dispatch(MethodInvocation message) {
        }
    }

    private static class SingletonDispatch<T> extends BroadcastDispatch<T> {
        private final Object handler;
        private final Dispatch<MethodInvocation> dispatch;

        SingletonDispatch(Class<T> type, Object handler, Dispatch<MethodInvocation> dispatch) {
            super(type);

            dispatch = new AsyncDispatch<MethodInvocation>(executor,
                    new FailureHandlingDispatch<MethodInvocation>(
                            new ReflectionDispatch(targetObject),
                            failureHandler), Integer.MAX_VALUE);
        }

        @Override
        public <T> T getProxy(Class<T> type) {

public class ListenerNotificationException extends DefaultMultiCauseException {
    private final MethodInvocation event;

    public ListenerNotificationException(@Nullable MethodInvocation event, String message, Iterable<? extends Throwable> causes) {
        super(message, causes);
        this.event = event;
    }

    @Nullable
    public MethodInvocation getEvent() {
        return event;
    }

 */

package org.gradle.listener;

import groovy.lang.Closure;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.MethodInvocation;

import java.util.Arrays;

public class ClosureBackedMethodInvocationDispatch implements Dispatch<MethodInvocation> {
    private final String methodName;
    private final Closure closure;

    }

    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

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

        }

        @Override
        public void invoke(MethodInvocation invocation) throws Throwable {
            next.invoke(invocation);
            if (invocation.found() || invocation.getParameterTypes().length != 1 || !invocation.isIsOrGet()) {
                return;
            }