@Override
        @TaskAction
        public void doStuff(InputChanges changes) {
            action.execute(changes);
        }
    }

    public static class TaskWithMultipleInputChangesActions extends DefaultTask {

        @TaskAction
        public void doStuff(InputChanges changes) {
        }

        @TaskAction
        public void doStuff2(InputChanges changes) {
        }
    }

        when:
        server.outgoingService1.doStuff("1")
        server.outgoingService1.doStuff("2")
        server.outgoingService1.doStuff("3")
        server.outgoingService1.doStuff("4")
        thread.blockUntil.received
        server.stop()
        client.stop()

        then:
        1 * service.doStuff("1")
        1 * service.doStuff("2")
        1 * service.doStuff("3")

        given:
        target.doStuff('param') >> {
            thread.block()
            instant.param1
        }
        target.doStuff('param2') >> {
            instant.param2
        }

        when:
        operation.dispatchAndStop {
            proxy.doStuff('param')
            proxy.doStuff('param2')
            actor.stop()
        }

        then:

println 'error message'
new BuildSrcClass()
assert 'doStuff' == name
assert buildscript.classLoader == getClass().classLoader.parent
assert buildscript.classLoader == Thread.currentThread().contextClassLoader
ext.someProp = 'value'
'''
        testFile('build.gradle') << '''
task doStuff
apply {
    to doStuff
    from 'external.gradle'
}
assert 'value' == doStuff.someProp
'''

    def "produces reasonable error message when task execution fails"() {
        externalScript << '''
task doStuff {
    doLast {
        throw new RuntimeException('fail')
    }
}
'''
        when:
        fails 'doStuff'

        then:
        failure.assertHasDescription('Execution failed for task \':doStuff\'.')
                .assertHasCause('fail')
                .assertHasFileName("Script '${externalScript}'")

 *
 * <pre>
 *  when:
 *  // runs the given closure and defines operation 'doStuff'
 *  operation.doStuff {
 *      // do some test action
 *  }
 *
 *  then:
 *  // query
 *  operation.doStuff.end > operation.doStuff.start
 *  instant.doStuff == operation.doStuff.end
 * </pre>
 */
class Operations {
    private final InstantFactory instantFactory

        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'
"""

        then:
        succeeds()
    }

        daemon.becomesIdle()

        when:
        sourceFile.text = "public class MyClass { private void doStuff() {} }"
        waitForChangesToBePickedUp()
        sourceFile.text = "public class MyClass { private void doStuff1() {} }"
        waitForChangesToBePickedUp()
        then:
        // On Windows, it may take some extra time until the event occurs

package main

import "runtime"

type Outer interface{ Inner }

type impl struct{}

func New() Outer { return &impl{} }

type Inner interface {
	DoStuff() error
}

func (a *impl) DoStuff() error {
	return newError()
}

func newError() error {
	stack := make([]uintptr, 50)
	runtime.Callers(2, stack[:])

	return nil
}

func main() {
	funcs := listFuncs(New())

        when:
        connectionBuilder.addIncoming(Worker, worker)
        connectionBuilder.connect()
        connection.stop()
        connectionBuilder.stop()

        then:
        1 * worker.doStuff("param 1")
        0 * worker._

        cleanup:
        connection?.stop()