task.options.generatedSourceOutputDirectory.asFile.orNull == new File(project.buildDir, 'generated/sources/annotationProcessor/java/main')
        task.options.annotationProcessorGeneratedSourcesDirectory == task.options.generatedSourceOutputDirectory.asFile.orNull
        task.options.headerOutputDirectory.asFile.orNull == new File(project.buildDir, 'generated/sources/headers/java/main')

                def root = layout.projectDirectory.asFile
                fc.filter { File f ->
                    f.isDirectory()
                }.elements.map {
                    it.collect { fileSystemLocation ->
                        projectDir.dir(fileSystemLocation.asFile.absolutePath)
                    }
                }
            }

            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

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

            }
        }
    }

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

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

// === Gradle Build ===
performanceTest.registerTestProject("gradleBuildCurrent", RemoteProject) {
    remoteUri = repoRoot(project).asFile.absolutePath
    ref = getBuildCommitId(project)
}

performanceTest.registerTestProject("gradleBuildBaseline", RemoteProject) {
    remoteUri = repoRoot(project).asFile.absolutePath
    // Remember to update accordingly when rebasing/squashing

                @get:OutputFile
                abstract val outputFile: RegularFileProperty
                @TaskAction
                fun printString() {
                    outputFile.get().asFile.writeText("absent")
                }
            }
            val producer = tasks.register<ProduceString>("produceString") {
                outputFile.set(layout.buildDirectory.file("output.txt"))
            }

            def copy1 = tasks.register("copy1", Copy) {
                destinationDir = layout.buildDirectory.dir("copy1").get().asFile
                from file("copy1source.txt")
            }

            def copy2 = tasks.register("copy2", Copy) {
                destinationDir = layout.buildDirectory.dir("copy2").get().asFile
                from file("copy2source.txt")
            }

            tasks.register("reader") {

                        dep.buildDependencies(sourceJar, javadocJar)
                        dep.publicationSourcePath = cp.fileReference(sourceJar.archiveFile.get().asFile)
                        dep.publicationJavadocPath = cp.fileReference(javadocJar.archiveFile.get().asFile)
                    }
                }
            }
        """
        }

                abstract ProjectLayout getLayout()

                @TaskAction
                void generate() {
                    layout.buildDirectory.dir("some-dir").get().asFile.mkdirs()
                    layout.buildDirectory.file("some-dir/output.txt").get().asFile.text = "output"
                }
            }

            task pluralOutputs(type: PluralOutputs)
        """
        when: