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

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

                BadTask() {
                    println("creating bad task")
                }
                @TaskAction
                void printIt() {
                    def outputFile = getOutputFile().get().asFile
                    outputFile.text = "bad"
                }
            }

            abstract class GoodTask extends DefaultTask {
                @OutputFile

    }

    def "toolchain service dependencies are satisfied"() {
        expect:
        project.extensions.getByType(JavaToolchainService).launcherFor(Actions.doNothing()).get().executablePath.asFile.isFile()
    }

                @OutputFile
                abstract RegularFileProperty getMainClassFile()

                @TaskAction
                def computeMainClass() {
                    mainClassFile.get().asFile.text = mainClassFromBootExtension.orNull
                        ?: mainClassFromJavaApplication.orNull
                        ?: resolveMainClassName()
                }

                def resolveMainClassName() {

}

val ruleStoreDir = layout.projectDirectory.dir("src/changes/archunit-store")

tasks {
    val reorderRuleStore by registering(ReorderArchUnitRulesTask::class) {
        ruleFile = ruleStoreDir.file("stored.rules").asFile
    }

    test {
        // Looks like loading all the classes requires more than the default 512M
        maxHeapSize = "1g"

        // Only use one fork, so freezing doesn't have concurrency issues

                doLast {
                    destinationDirectory.file("output.txt").get().asFile << "From compile task A"
                }
            }

            task compileB(type: JavaCompile) {
                destinationDirectory = file("build/compile-b")
                doLast {
                    destinationDirectory.file("output.txt").get().asFile << "From compile task B"
                }
            }

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

apply plugin: 'cpp'
apply plugin: 'c'

<% if (overlapWithOutput) { %>
    if (project != rootProject) {
       buildDir = rootProject.layout.buildDirectory.dir(project.name).get().asFile
    }
<% } %>

model {
    buildTypes {
        debug
        release
    }

    platforms {
        windows32 {
            architecture "x86"
            operatingSystem "windows"
        }

        windows64 {