def b1 = file("b/1.txt") << "b/1"
        def fileResolver = TestFiles.fileCollectionFactory(testDirectory)

        when:
        def a = fileResolver.resolving(["a"]).asFileTree
        def b = fileResolver.resolving(["b"]).asFileTree
        def composite = newCompositeFileTree([a, b])

        then:
        composite.files == [a1, b1].toSet()
    }

    def "can visit all files"() {
        given:

            'matching(patternSet)',
            'matching(patternSet).filter { it.file }',
            'matching(patternSet).asFileTree.filter { it.file }',
            'filter { it.path.endsWith "ok" }.asFileTree',
            'filter { it.file }.asFileTree.matching(patternSet)',
        ]
    }

     */
    @get:InputFiles
    @get:PathSensitive(PathSensitivity.RELATIVE)
    val staticContent: FileCollection
        get() = gradleHomeDir.asFileTree.matching {
            exclude("lib/**")
            exclude("src/**")
            exclude("docs/**")
            exclude("README")
            exclude("getting-started.html")
        }

    @get:Classpath

        def dir2 = baseDir.createDir("dir2")
        def file3 = dir2.createFile("other/file3")

        expect:
        def tree1 = baseDirectory.asFileTree
        tree1.files == [file1, file2, file3] as Set

        and:
        def tree2 = baseDirectory.dir("dir2").get().asFileTree
        tree2.files == [file3] as Set
    }

    def "can view relative paths as a file collection"() {
        given:

    doLast {
        repoDir.get().asFileTree.matching { include("**/maven-metadata.xml") }.forEach {
            it.writeText(it.readText().replace("\\Q<lastUpdated>\\E\\d+\\Q</lastUpdated>\\E".toRegex(), "<lastUpdated>${Year.now().value}0101000000</lastUpdated>"))
        }
        repoDir.get().asFileTree.matching { include("**/*.module") }.forEach {
            val content = it.readText()

        set.toString() == '<display-name>'
    }

    void viewsHaveSameDisplayNameAsSet() {
        expect:
        set.sourceDirectories.toString() == '<display-name>'
        set.asFileTree.toString() == '<display-name>'
        set.matching {}.toString() == '<display-name>'
    }

    void isEmptyWhenNoSourceDirectoriesSpecified() {
        expect:
        set.empty
        set.files.empty

        then:
        1 * targetDir.dir("app/src/main/java") >> mainSourceDirectory
        1 * targetDir.dir("app/src/test/java") >> testSourceDirectory
        1 * mainSourceDirectory.asFileTree >> mainSourceFileTree
        1 * testSourceDirectory.asFileTree >> testSourceFileTree
        1 * mainSourceFileTree.empty >> noMainSources
        _ * testSourceFileTree.empty >> noTestSources
        delegateInvocation * delegate.generate()

                false
            }
            fileCollection is FilteredFileTree -> {
                when {
                    // Optimize a common case, where fileCollection.asFileTree.matching(emptyPatterns) is used,
                    // e.g. in SourceTask and in CopySpec.
                    // Skip applying the filters to the tree
                    fileCollection.patterns.isEmpty -> {

    @Internal
    val localRepo = project.objects.fileCollection()

    @get:Classpath
    val jars: SortedSet<File>
        get() = localRepo.asFileTree.matching {
            include("**/*.jar")
            exclude("**/*-javadoc.jar")
        }.files.toSortedSet()

    /**

    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].
 */