this.methodName = methodName;
        this.closure = closure;
    }

    @Override
    public void dispatch(MethodInvocation message) {
        if (message.getMethodName().equals(methodName)) {
            Object[] parameters = message.getArguments();
            if (closure.getMaximumNumberOfParameters() < parameters.length) {

            Class<? extends I> itemType = uncheckedCast(args[0]);
            Closure<? super I> closure = uncheckedCast(args[1]);
            create(name, itemType, closure);
        } else if (args.length == 1 && args[0] instanceof Closure<?>) {
            Closure<? super I> closure = uncheckedCast(args[0]);
            named(name, closure);
        } else {

    void removeTaskExecutionListener(TaskExecutionListener listener);

    /**
     * <p>Adds a closure to be called when this graph has been populated. This graph is passed to the closure as a
     * parameter.</p>
     *
     * @param closure The closure to execute when this graph has been populated.
     */
    void whenReady(Closure closure);

    /**

    /**
     * Adds a closure to be called when an object is added to this collection. The newly added object is passed to the
     * closure as the parameter.
     *
     * @param action The closure to be called
     * @see #whenObjectAdded(Action)
     */
    void whenObjectAdded(Closure action);

    /**

        delegate.removeProjectEvaluationListener(listener)

    override fun beforeSettings(closure: Closure<*>) =
        delegate.beforeSettings(closure)

    override fun beforeSettings(action: Action<in Settings>) =
        delegate.beforeSettings(action)

    override fun beforeProject(closure: Closure<Any>) =
        delegate.beforeProject(closure)

    override fun beforeProject(action: Action<in Project>) =

    /**
     * Applies given closure for each dependency.
     * An instance of {@link DependencyResult} is passed as parameter to the closure.
     *
     * @param closure - closure that is applied for each dependency
     */
    void allDependencies(@DelegatesTo(DependencyResult.class) Closure closure);

    /**

        type      | implementation
        "Closure" | { it }
        "Action"  |  new Action<String>() { @Override void execute(String s) {} }
    }

    def "correct implementation for closure wrapped in Action is tracked"() {
        given:
        def closure = { it }

        expect:
        ScriptSourceAwareImplementationResolver.unwrapBean(ConfigureUtil.configureUsing(closure)) == closure

        and:

     * @param expectation
     */
    void withModuleMetadata(@DelegatesTo(value = SingleArtifactResolutionResultSpec, strategy = Closure.DELEGATE_FIRST) Closure<?> expectation) {
        expectation.resolveStrategy = Closure.DELEGATE_FIRST
        expectation.delegate = withModuleMetadataSpec
        expectation()
    }

    /**
     * Setup expectation when resolving without module metadata

        when: 'a closure throwing an exception is called'
        transformedThrowingClosure()

        then: 'the exception is thrown, but despite that, the closure must have been removed from the closure control flow tracker, which is checked below'
        thrown(RuntimeException)

    }

    /**
     * Adds a closure to be called when the file has been created.
     * The {@link Properties} are passed to the closure as a parameter.
     * The closure can modify the Properties before they are written to the output file.
     * <p>
     * For examples see docs for {@link org.gradle.plugins.ide.eclipse.model.EclipseJdt} and others.
     *
     * @param closure The closure to execute when the Properties have been created.