get() = get().isEmpty


/**
 * See [Configuration.getAsFileTree].
 */
@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().asFileTree"), level = DeprecationLevel.HIDDEN)
val <T : Configuration> NamedDomainObjectProvider<T>.asFileTree: FileTree
    get() = get().asFileTree


/**
 * See [Configuration.getResolutionStrategy].
 */

                .replaceAll("[^a-zA-Z0-9\\-]", "_")
                .toLowerCase(Locale.ROOT) + ".2";
    }

    private File unpack(File jdkArchive) {
        final FileTree fileTree = asFileTree(jdkArchive);
        String unpackFolderName = getNameWithoutExtension(jdkArchive);
        final File unpackFolder = temporaryFileProvider.createTemporaryDirectory(unpackFolderName, null, "jdks");

                    inputs.dir sources skipWhenEmpty()
                    outputs.dir "${outputDir}"
                    def outputDir = file("${outputDir}")
                    def sourceTree = files(sources).asFileTree
                    doLast {
                        outputDir.mkdirs()
                        sourceTree.visit { details ->
                            if (!details.directory) {

            task incomingDependencies { dependsOn configurations.compile.incoming.dependencies }
            task copy { inputs.files configurations.compile.copy() }
            task filteredTree { inputs.files configurations.compile.asFileTree.matching { true } }
'''

        when:

                            ${server.callFromBuild("zipFileSnapshottingStarted")}
                        }
                        countResolved++
                        it.asFileTree.matching {
                            include "src/**"
                            include "build.gradle"
                        }
                    })
                }

                @TaskAction

docsPath.description = "Resolves to the complete Gradle documentation - automatically adds dependency to the :docs project"

// Gradle API Sources
val gradleApiSources = sourcesPath.incoming.artifactView { lenient(true) }.files.asFileTree.matching {
    include(PublicApi.includes)
    exclude(PublicApi.excludes)
}

// Tasks to generate metadata about the distribution that is required at runtime

            myExt.artifactDir = producer.flatMap { it.output }

            tasks.register("consumer", Consumer) {
               fileNames = myExt.artifactDir.map {
                  it.asFileTree.collect { it.absolutePath }
               }.orElse([ "else" ])
            }
        """

        when:
        run 'consumer'

        then:
        executedAndNotSkipped(":producer", ":consumer")

        expectReindentedValidationMessage()
        buildScript """
            task myTask {
                inputs.file file('input.txt')
                outputs.files(files('build/output.txt').asFileTree).withPropertyName('output')
                doLast {
                    file('build/output.txt').text = new File('input.txt').text
                }
            }
        """.stripIndent()

            tasks.register("compileCustomJava", JavaCompile) {
                destinationDirectory.set(new File(buildDir, "classes/java-custom-path/main"))
                source = files("src/main/java-custom-path").asFileTree
                options.sourcepath = files("src/main/java") + files("src/main/java-custom-path")
                classpath = files()
            }
        """