@TaskAction
    fun mergeInstrumentedSuperTypes() {
        val instrumentedClasses = findInstrumentedClasses()
        if (instrumentedClasses.isEmpty()) {
            instrumentedSuperTypes.asFile.get().delete()
            return
        }

        // Merge and find all transitive super types
        val superTypes = mergeSuperTypes()

@DisableCachingByDefault(because = "Not worth caching")
abstract class GenerateSubprojectsInfo : SubprojectsInfo() {

    @TaskAction
    fun generateSubprojectsInfo() {
        subprojectsJson.asFile.writeText(generateSubprojectsJson())
    }

    companion object {
        internal
        const val TASK_NAME = "generateSubprojectsInfo"
    }

            </thead>
            <tr>
                <td>asString</td>
            </tr>
            <tr>
                <td>asReader</td>
            </tr>
            <tr>
                <td>asFile</td>
            </tr>
        </table>
    </section>

fun Directory.parentOrRoot(): Directory = if (this.file("version.txt").asFile.exists()) {
    this
} else {
    val parent = dir("..")
    when {
        parent.file("version.txt").asFile.exists() -> parent
        this == parent -> throw IllegalStateException("Cannot find 'version.txt' file in root of repository")
        else -> parent.parentOrRoot()

        then:
        task instanceof GroovyCompile
        task.classpath.files as List == [
            mainSourceSet.java.destinationDirectory.get().asFile,
            mainSourceSet.groovy.destinationDirectory.get().asFile,
            mainSourceSet.output.resourcesDir
        ]
        not(dependsOn(JvmConstants.COMPILE_TEST_JAVA_TASK_NAME, JvmConstants.CLASSES_TASK_NAME)).matches(task)
    }

                @Internal abstract RegularFileProperty getBar()

                @TaskAction
                void useIt() {
                    assert foo.asFile.get().name == "foo"
                    assert bar.asFile.get().name == "bar"
                }
            }
            tasks.register("mytask", MyTask) {
                def layout = project.layout

@DisableCachingByDefault(because = "Not worth caching")
abstract class CheckSubprojectsInfo : SubprojectsInfo() {

    @TaskAction
    fun checkSubprojectsInfo() {
        if (subprojectsJson.asFile.readText() != generateSubprojectsJson()) {
            throw GradleException(
                "New project(s) added without updating subproject JSON. Please run `:${GenerateSubprojectsInfo.TASK_NAME}` task."
            )

                @get:OutputFile
                abstract val fileOutput: RegularFileProperty

                @TaskAction
                fun taskAction() {
                    fileOutput.asFile.get().writeText(input.get())
                }
            }

            tasks.register<MyTask>("myTask") {
                file("src").mkdirs()
                input = null
                input = "Hello world"

    @get:OutputDirectory
    abstract val outputDir: DirectoryProperty

    protected
    abstract fun File.writeFiles()

    @Suppress("unused")
    @TaskAction
    fun run() {
        outputDir.get().asFile.apply {
            recreate()
            writeFiles()
        }
    }

    protected
    fun File.writeFile(relativePath: String, text: String) {
        resolve(relativePath).apply {

// tag::verification-failure[]
tasks.register("process") {
    def outputFile = layout.buildDirectory.file("processed.log")
    outputs.files(outputFile) // <1>

    doLast {
        def logFile = outputFile.get().asFile
        logFile << "Step 1 Complete." // <2>
        throw new VerificationException("Process failed!") // <3>
        logFile << "Step 2 Complete." // <4>
    }
}

tasks.register("postProcess") {