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

    val matcher = Regex("""generatePomFileFor(\w+)Publication""").matchEntire(name)
    val publicationName = matcher?.let { it.groupValues[1] }
    destination = layout.buildDirectory.file("poms/${publicationName}-pom.xml").get().asFile
}
// end::configure-generate-task[]

dependencies {
    implementation(enforcedPlatform("org.junit:junit-bom:5.7.1"))
}

// tag::disable_validation[]
tasks.withType<GenerateModuleMetadata> {

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

    property("excludes", PublicApi.excludes.joinToString(":"))
    destinationFile = apiDeclarationPropertiesFile
}

sourceSets.main {
    output.dir(mapOf("builtBy" to apiDeclaration), apiDeclarationPropertiesFile.map { it.asFile.parentFile })
}

fun generatedPropertiesFileFor(name: String) =

    group = "build"
    with(allDistributionSpec())
    into(installDirectory)
}

fun validateInstallDir(installDir: Directory) = installDir.also { dir ->
    val dirFile = dir.asFile
    if (dirFile.isFile) {
        throw RuntimeException("Install directory $dir is not valid: it is actually a file")
    }
    if (dirFile.list()?.isEmpty() != false) {
        return@also
    }

}

tasks.jar.configure {
    val classpath = resolveManifestClasspath.flatMap { configuration ->
        configuration.elements.map { classpathDependency ->
            classpathDependency.joinToString(" ") { it.asFile.name }
        }
    }
    manifest.attributes("Class-Path" to classpath)
    if (app.mainClassName.isPresent) {
        manifest.attributes("Main-Class" to app.mainClassName)
    }

        def resolvedOutput = tmpDir.file("report.dir")

        expect:
        !report.outputLocation.isPresent()

        report.conventionMapping.map("destination") { output }

        report.outputLocation.asFile.get() == resolvedOutput
    }

// === 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

    @InputArtifact
    abstract Provider<FileSystemLocation> getArtifact()

    @Override
    void transform(TransformOutputs outputs) {
        File artifactFile = artifact.get().asFile
        if (artifactFile.name == 'gradle-dependencies') {
            (artifactFile.listFiles() as List<File>).sort { it.name }.each {
                outputs.file(it)
            }
        }
    }

abstract class ReverseFile @Inject constructor(val fileSystemOperations: FileSystemOperations) : WorkAction<ReverseParameters> {
    override fun execute() {
        val fileToReverse = parameters.fileToReverse.asFile.get()
        fileSystemOperations.copy {
            from(fileToReverse)
            into(parameters.destinationDir)
            filter { line: String -> line.reversed() }
        }