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

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

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

        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

        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:

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

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

        file('settings.gradle') << 'include "a", "b"'
        file('a/build.gradle') << '''
configurations { compile }
dependencies { compile project(path: ':b', configuration: 'archives') }

task doStuff(type: InputTask) {
    src = configurations.compile + fileTree('src/java')
}

class InputTask extends DefaultTask {
    @InputFiles
    def FileCollection src
}
'''