task.options.generatedSourceOutputDirectory.asFile.orNull == new File(project.buildDir, 'generated/sources/annotationProcessor/java/main')
        task.options.annotationProcessorGeneratedSourcesDirectory == task.options.generatedSourceOutputDirectory.asFile.orNull
        task.options.headerOutputDirectory.asFile.orNull == new File(project.buildDir, 'generated/sources/headers/java/main')

        // Wait for all asynchronous work submitted to this queue to complete before continuing
        workQueue.await()
        logger.lifecycle("Created ${outputDir.get().asFile.listFiles().size} reversed files in ${outputDir.get().asFile.toRelativeString(projectLayout.projectDirectory.asFile)}")
        // end::wait-for-completion[]
    }
}

tasks.register<ReverseFiles>("reverseFiles") {
    outputDir = layout.buildDirectory.dir("reversed")

    @get:Inject
    abstract val projectLayout: ProjectLayout

    @TaskAction
    fun run() {
        val bundleFile = projectLayout.buildDirectory.file("bundle.js").get().asFile
        val scriptsFiles = projectLayout.projectDirectory.dir("scripts").asFile.listFiles()

        bundleFile.outputStream().use { stream ->
            scriptsFiles.sorted().forEach {
                stream.write(it.readBytes())
            }
        }

        task instanceof Zip
        task.archiveFile.get().asFile == project.file("build/distributions/test-project-custom.zip")
    }

    def "adds distTar task for main distribution"() {
        when:
        project.pluginManager.apply(DistributionPlugin)

        then:
        def task = project.tasks.distTar
        task instanceof Tar
        task.archiveFile.get().asFile == project.file("build/distributions/test-project.tar")
    }

                @Inject abstract ArchiveOperations getArchives()
                @TaskAction def action() {
                    def outFile = outputFile.get().asFile
                    outFile.parentFile.mkdirs()
                    outFile.text = archives.${archiveType}(inputFile.get().asFile).read().text
                }
            }

            tasks.register("myTask", MyTask) {

    abstract val optionalProjects: ListProperty<String>

    @get:Internal
    abstract val projectDependencies: ConfigurableFileCollection

    @Input
    val runtime = externalDependencies.elements.map { it.map { it.asFile.name }.sorted() }

    @get:Internal
    abstract val externalDependencies: ConfigurableFileCollection

    @Input
    val projects = projectDependencies.elements.map { it.map { it.toGradleModuleName() }.sorted() }

        val classGraph = JarAnalyzer(parameters.shadowPackage.get(), parameters.keepPackages.get(), parameters.unshadedPackages.get(), parameters.ignoredPackages.get()).analyze(input.get().asFile, classesDir, manifestFile, buildReceiptFile)

        outputDirectory.resolve(classTreeFileName).bufferedWriter().use {
            Gson().toJson(classGraph.getDependencies(), it)
        }

def rpmArtifact = artifacts.add("conf", rpmFile.get().asFile) {
    type "rpm"
    builtBy "rpm"
}
// end::custom-artifact[]

tasks.register('rpm') {
    outputs.file rpmFile
    def rpmFileLocation = rpmFile
    doLast {
        // produce real RPM here
        rpmFileLocation.get().asFile << "file contents"
    }
}

// tag::custom-artifact[]
publishing {

        where:
        wiring << [
            //"fsOps.permissions(producer.flatMap { it.outputFile.asFile }.map { it.readText() }).map { it.toUnixNumeric() }", //TODO: https://github.com/gradle/gradle/issues/19252
            "fsOps.permissions(producer.flatMap { it.outputFile }.map { it.asFile.readText() }).map { it.toUnixNumeric() }"
        ]
    }

        new JarTestFixture(war.archiveFile.get().asFile).assertContainsFile('WEB-INF/file.txt')
    }

    def "configures destinationDirectory for war tasks"() {
        when:
        project.pluginManager.apply(JavaBasePlugin)
        project.version = '1.0'

        then:
        def someWar = project.tasks.create('someWar', War)
        someWar.destinationDirectory.get().asFile == project.libsDirectory.get().asFile
    }