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

            abstract class GoodTask extends DefaultTask {
                @OutputFile

        when:
        factory.fromSourceTemplate("someTemplate/SomeClazz.somelang.template", sourceSet)

        then:
        1 * targetDir.file(target) >> targetFile
        1 * targetFile.asFile >> targetAsFile
        1 * templateOperationFactory.newTemplateOperation() >> templateOperationBuilder
        1 * templateOperationBuilder.withTemplate("someTemplate/SomeClazz.somelang.template") >> templateOperationBuilder

        def notation = Stub(RegularFile)
        notation.asFile >> testFile
        when:
        def object = parse(notation)
        then:
        object == testFile
    }

    def "with Directory returns the File it represents"() {
        setup:
        def testFile = folder.createFile("test1")
        def notation = Stub(Directory)
        notation.asFile >> testFile
        when:
        def object = parse(notation)

val makeFile = tasks.register("makeFile") {
    val sharedFile = layout.buildDirectory.file("some-subdir/shared-file.txt")
    outputs.file(sharedFile)
    doFirst {
        sharedFile.get().asFile.writeText("This file is shared across Gradle subprojects.")
    }
}

val sharedConfiguration by configurations.creating {
    isCanBeResolved = false
}

artifacts {
    add(sharedConfiguration.name, makeFile)

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

    }

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

            println("##teamcity[importData type='junit' path='$outputXmlPath/TEST-*.xml' verbose='true']")
        }
    }
}

if (isTeamCityParallelTestsEnabled) {
    val gradleRootDir = repoRoot().asFile.toPath()
    project.gradle.taskGraph.whenReady {