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

 * limitations under the License.
 */

package org.gradle.tooling.internal.adapter;

import javax.annotation.Nullable;
import java.lang.reflect.Type;

class MethodInvocation {
    private final Object[] parameters;
    private final Class returnType;
    private final Type genericReturnType;
    private final String name;
    private final Class<?>[] parameterTypes;

import org.gradle.internal.serialize.*;
import org.gradle.internal.dispatch.MethodInvocation;

import java.io.IOException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class MethodInvocationSerializer implements StatefulSerializer<MethodInvocation> {
    private final ClassLoader classLoader;
    private final MethodArgsSerializer methodArgsSerializer;

     * 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);

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);
        this.forwardingDispatch = forwardingDispatch;

    def "equality"() {
        def invocation = new MethodInvocation(String.class.getMethod("length"), ["param"] as Object[])
        def equalInvocation = new MethodInvocation(String.class.getMethod("length"), ["param"] as Object[])
        def differentMethod = new MethodInvocation(String.class.getMethod("getBytes"), ["param"] as Object[])
        def differentArgs = new MethodInvocation(String.class.getMethod("length"), ["a", "b"] as Object[])

        def method2 = String.class.getMethod("substring", Integer.TYPE)
        def invocation1 = new MethodInvocation(method1, [1, 2] as Object[])
        def invocation2 = new MethodInvocation(method2, [3] as Object[])
        def invocation3 = new MethodInvocation(method1, [4, 5] as Object[])

        when:
        def serialized = serialize(invocation1, invocation2, invocation3)

            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;