@TaskAction
    def transform() {
        logging.captureStandardOutput(LogLevel.INFO)
        logging.captureStandardError(LogLevel.INFO)

        def destDir = destinationDirectory.get().asFile
        fs.delete {
            delete(destDir, temporaryDir)
        }

        def xslClasspath = classpath.plus(objects.fileCollection().from(ClasspathUtil.getClasspathForClass(XslTransformer)))

        fs.copy {

        convention.distsDirName == 'distributions'
        convention.distsDirectory.getAsFile().get() == project.layout.buildDirectory.dir('distributions').get().asFile
        convention.libsDirName == 'libs'
        convention.libsDirectory.getAsFile().get() == project.layout.buildDirectory.dir('libs').get().asFile
    }

    def "dirs relative to build dir"() {
        when:
        project.buildDir = project.file('mybuild')

            }
        }
    }

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

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

                doLast {
                    assert junitXmlOutputLocation.flatMap { it.asFile }.get() == expectedJunitXmlOutputLocation
                    assert htmlOutputLocation.flatMap { it.asFile }.get() == expectedHtmlOutputLocation
                    assert binaryResultsDirectory.flatMap { it.asFile }.get() == expectedBinaryResultsDirectory
                }
            }
        """

        expect:

            url layout.buildDirectory.dir('repo')
        }
    }
}

// tag::generate[]
generateDescriptorFileForIvyCustomPublication {
    destination = layout.buildDirectory.file('generated-ivy.xml').get().asFile
}

val process = tasks.register("process") {
    val outputFile = layout.buildDirectory.file("processed.log")
    outputs.files(outputFile) // <1>

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

tasks.register("postProcess") {

        val unixScriptFile = startScriptsDir.file("gradle").get().asFile
        generator.generateUnixScript(unixScriptFile)
        unixScriptFile.injectAgentOptions(TextUtil.getUnixLineSeparator())

        val windowsScriptFile = startScriptsDir.file("gradle.bat").get().asFile
        generator.generateWindowsScript(windowsScriptFile)

            if (moduleBaseDir.exists()) {
                // Make sure artifacts do not pile up locally
                moduleBaseDir.deleteRecursively()
            }
        }

        doLast {
            localRepository.get().file("org/gradle/${baseName.get()}/maven-metadata.xml").asFile.apply {

    @TaskAction
    void doDownloadGradle() {
        URL downloadUrl = new URL(gradleDownloadBase.get() + "/" + downloadFileName.get())
        destinationFile.get().asFile.withOutputStream { it << downloadUrl.newInputStream() }
    }

    @Internal
    Provider<String> getDistributionNameBase() {
        return gradleVersion.map { "gradle-" + it }
    }

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

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

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