*
 * A file or directory will only be visited if it matches all includes and no
 * excludes.
 */
public class DirectoryFileTree implements MinimalFileTree, PatternFilterableFileTree, RandomAccessFileCollection, LocalFileTree, DirectoryTree {
    private static final Logger LOGGER = LoggerFactory.getLogger(DirectoryFileTree.class);
    private static final DirectoryWalker DEFAULT_DIRECTORY_WALKER = new DefaultDirectoryWalker(FileSystems.getDefault());

        this.fileSystem = fileSystem;
    }

    @Override
    public DirectoryFileTree create(File directory) {
        return new DirectoryFileTree(directory, patternSetFactory.create(), fileSystem);
    }

    @Override
    public DirectoryFileTree create(File directory, PatternSet patternSet) {
        return new DirectoryFileTree(directory, patternSet, fileSystem);
    }

        and:
        def patterns = new PatternSet()
        patterns.include("**/*2")
        def filter = new PatternSet()
        filter.include("dir1/**")

        and:
        DirectoryFileTree fileTree = new DirectoryFileTree(root, patterns, TestFiles.fileSystem(), false).filter(filter)

        when:
        fileTree.visit(visitor)

        then:
        visitor.visited == [dir1, dirFile2]

        where:

import org.gradle.internal.service.scopes.ServiceScope;

import java.io.File;

@ServiceScope(Scope.Global.class)
public interface DirectoryFileTreeFactory {
    DirectoryFileTree create(File directory);

    DirectoryFileTree create(File directory, PatternSet patternSet);

        checkFileVisitDetailsEqual(visitedWithDefaultWalker, visitedWithReproducibleWalker)
    }

    private static List<FileVisitDetails> walkFiles(rootDir, isReproducible) {
        def fileTree = new DirectoryFileTree(rootDir, new PatternSet(), TestFiles.fileSystem(), false)
        def visited = []
        def visitClosure = { visited << it }

    }

    def cleanup() {
        rootDir.file('unauthorized').mode = 0777
    }

    def "excluded files' permissions should be ignored"() {
        when:
        def fileTree = new DirectoryFileTree(rootDir, new PatternSet().exclude('unauthorized'), TestFiles.fileSystem(), false)
        def visitedDirectories = []
        def fileVisitor = [visitDir: { visitedDirectories << it }] as FileVisitor

    public FileSystemMirroringFileTree getTree() {
        return tree;
    }

    public PatternSet getPatterns() {
        return patterns;
    }

    @Override
    public DirectoryFileTree getMirror() {
        DirectoryFileTree mirror = tree.getMirror();
        return mirror.filter(this.patterns);
    }

    @Override
    public MinimalFileTree filter(PatternFilterable patterns) {

 */

package org.gradle.api.internal.file.archive

import org.gradle.api.file.FileVisitor
import org.gradle.api.internal.file.FileTreeInternal
import org.gradle.api.internal.file.collections.DirectoryFileTree
import org.gradle.api.internal.file.collections.MinimalFileTree
import org.gradle.api.provider.Provider
import org.gradle.cache.internal.TestDecompressionCoordinators

        1 * visitor.visitFileTree(dir, intersectPatterns, owner)
        0 * _
    }

    def "applies filters to mirror"() {
        def sourceMirror = Mock(DirectoryFileTree)
        def filteredMirror = Mock(DirectoryFileTree)

        when:
        def mirror = tree.mirror

        then:
        mirror == filteredMirror

        1 * source.mirror >> sourceMirror

 * limitations under the License.
 */

package org.gradle.api.internal.file;

import org.gradle.api.file.FileTree;
import org.gradle.api.file.FileVisitor;
import org.gradle.api.internal.file.collections.DirectoryFileTree;
import org.gradle.api.internal.file.collections.FileSystemMirroringFileTree;
import org.gradle.api.internal.file.collections.FileTreeAdapter;
import org.gradle.api.internal.tasks.TaskDependencyFactory;