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

        then:
        1 * dispatch.dispatch(new MethodInvocation(ProxyTest.class.getMethod('doStuff', String.class), ['param'] as Object[]))
    }

    def proxyIsEqualWhenItHasTheSameTypeAndDispatch() {

        when:
        operation.doStuff {
            operation.doStuff.end
        }

        then:
        IllegalStateException e = thrown()
        e.message == "Operation 'doStuff' has not completed yet."
    }

    def "cannot query operation duration while it is running"() {
        when:
        operation.doStuff {
            operation.doStuff.duration
        }

        then:

        then:
        result.method == method
        result.arguments == [1, 2] as Object[]
    }

    interface Thing {
        String doStuff(Thing[] things)
    }

    def "serializes a method invocation with array type parameters"() {
        def method = Thing.class.getMethod("doStuff", Thing[].class)
        def invocation = new MethodInvocation(method, [[] as Thing[]] as Object[])

        when:

        server.expectGet('/external.gradle', script)

        script << """
            task doStuff
            assert buildscript.sourceFile == null
            assert "${server.uri}/external.gradle" == buildscript.sourceURI as String
"""

        buildFile << """
            apply from: '$server.uri/external.gradle'
            defaultTasks 'doStuff'
"""

        when:

} finally {
    if (initscript.classLoader instanceof Closeable) {
        initscript.classLoader.close()
    }
}
"""

        and:
        buildFile << 'task doStuff'

        when:
        result = executer.usingInitScript(initScript).withTasks('doStuff').run()

        then:
        outputContains('quiet message')
        result.assertHasErrorOutput('error message')
    }

            class GeneratorTask extends DefaultTask {
                @Output${kind}
                final ${type.name} output = project.objects.${factory}()

                @TaskAction
                void doStuff() {
                    output${generatorAction}
                }
            }

            task generator(type: GeneratorTask) {
                output.set(project.layout.buildDirectory.${lookup}('output'))

            task build(type: GradleBuild) {
                dir = 'other'
                tasks = ['dostuff']
            }
'''

        and:
        file('other/settings.gradle') << "rootProject.name = 'other'"
        file('other/build.gradle') << '''
            assert gradle.parent != null
            task dostuff {
                doLast {
                    assert gradle.parent != null
                }
            }

package org.gradle.groovy.compile.GroovyCompilerIntegrationSpec.canUseBuiltInAstTransform.src.test.groovy

class TestDelegate {
    def doStuff(String value) {
        return "[$value]"
    }

try {
    buildscript.classLoader.loadClass('${implClassName}')
    assert false: 'should fail'
} catch (ClassNotFoundException e) {
    // expected
}

            task doStuff
"""

        ExecutionResult result = inTestDirectory().withTasks('doStuff').run()
        result.assertOutputContains('quiet message')
        result.assertHasErrorOutput('error message')
    }

    @Test

            }
            assert defaultTask.doStuff() == 'method'
            assert javaTask.doStuff() == 'method'
            assert groovyTask.doStuff() == 'method'
            assert configurations.test.doStuff() == 'method'
            configurations.test.dependencies.each {
                assert it.doStuff() == 'method'
            }
            assert repositories.doStuff() == 'method'
            repositories {