buildFile << """
            task producer(type: FileProducer) {
                output = layout.buildDir.file("text.out")
            }
            def prop = producer.output.map { it.asFile.file ? it.asFile.text : "(null)" }
            println("prop = " + prop.get())
        """

        when:
        fails("producer")

        then:

                    def input = inputArtifact.get().asFile
                    println "processing \${input.name} using \${parameters.someFile.get().asFile.name}"
                    def output = outputs.file(input.name + ".green")
                    output.text = input.text + parameters.someFile.get().asFile.text + ".green"
                }
            }
        """

        when:

            args(repoRoot().file(".teamcity/performance-test-durations.json").asFile.absolutePath)
            doNotTrackState("Reads data from the database")
        }

        val performanceScenarioJson = repoRoot().file(".teamcity/performance-tests-ci.json").asFile
        val tmpPerformanceScenarioJson = project.layout.buildDirectory.file("performance-tests-ci.json").get().asFile

        // clear the target directory to remove renamed files and reset the README file
        target.asFile.deleteRecursively()

        val groovyDslSettings = InitSettings(projectName, false, descriptor.componentType.defaultProjectNames, modularization, BuildInitDsl.GROOVY, packageName, testFramework, target.dir("groovy"))

    @Input
    final Property<String> entryName = project.objects.property(String).convention("thing.class")

    @TaskAction
    def go() {
        def file = output.get().asFile
        file.withOutputStream {
            println "write \${entryName.get()} with timestamp \${timestamp.get()} and content \${content.get()}"
            def jarFile = new JarOutputStream(it)
            try {

        def test = project.task('customTest', type: Test.class)
        test.workingDir == project.projectDir
        test.reports.junitXml.outputLocation.get().asFile == new File(project.testResultsDir, 'customTest')
        test.reports.html.outputLocation.get().asFile == new File(project.testReportDir, 'customTest')
        test.reports.junitXml.required.get()
        test.reports.html.required.get()

                @TaskAction
                void doAction() {
                    layout.buildDirectory.file("output.txt").get().asFile.text = "Hello"
                    layout.buildDirectory.file("build.log").get().asFile << "Produced at \${new Date()}\\n"
                }
            }

            task customTask(type: CustomTask) {
                outputFiles = fileTree(file("build")) {

            tasks.register("consumer", Consumer) {
                def layout = layout
                def filtered = files(producer.map { it.output }).elements.map {
                    it.collect { it.asFile }
                        .findAll { it.isFile() }
                        .collect { layout.projectDirectory.file(it.absolutePath) }
                }
                inputFiles.set(filtered)
            }
        """

        val projectBuildDirPath = projectBuildDir.asFile.get().toPath()

        reports.filter { it.isDirectory }.forEach {
            val destFile = rootBuildDir.resolve("report$projectPathName-${it.name}.zip")
            zip(destFile, it)
        }

        // Zip all files in project build directory into a single zip file to avoid publishing too many tiny files
        reports.filter { it.isFile && it.toPath().startsWith(projectBuildDirPath) }

            }
        }
    }

    private
    fun recreateTaskDirectories() {
        recreate(temporaryDir)
        recreate(sourceCodeOutputDir.get().asFile)
        recreate(metadataOutputDir.get().asFile)
    }

    private
    fun IO.generateTypeSafeAccessorsFor(projectScriptPlugins: List<PrecompiledScriptPlugin>) {
        resolvePluginGraphOf(projectScriptPlugins)
            .groupBy(