super(other);
        this.other = other;
    }

    public PatternSet getOther() {
        return other;
    }

    @Override
    public Spec<FileTreeElement> getAsSpec() {
        return Specs.intersect(super.getAsSpec(), other.getAsSpec());
    }

    @Override
    public Object addToAntBuilder(Object node, String childNodeName) {
        return PatternSetAntBuilderDelegate.and(node, new Action<Object>() {

        patternSet.include(includeSpecClosure)
        def excludeSpecClosure = { FileTreeElement e -> false } as Spec
        patternSet.exclude(excludeSpecClosure)
        def spec = patternSet.getAsSpec()
        def fileTreeElement = Stub(FileTreeElement) {
            isFile() >> {
                true
            }
        }
        when:
        desiredResult = true
        then:

            copyIncludesAndExcludes(intersectCopy, from);

            includes = null;
            excludes = null;
            includeSpecs = new LinkedHashSet<>();
            includeSpecs.add(intersectCopy.getAsSpec());
            excludeSpecs = null;
        } else {
            copyIncludesAndExcludes(this, from);
        }

        return this;
    }

            }
        }, owner);
    }

    @Override
    public void visit(FileVisitor visitor) {
        Spec<FileTreeElement> spec = patterns.getAsSpec();
        tree.visit(new FileVisitor() {
            @Override
            public void visitDir(FileVisitDetails dirDetails) {
                if (spec.isSatisfiedBy(dirDetails)) {

            return false;
        }

        RelativePath path = RelativePath.parse(true, file.getAbsolutePath().substring(prefix.length()));
        return tree.getPatterns().getAsSpec().isSatisfiedBy(new DefaultFileTreeElement(file, path, fileSystem, fileSystem));
    }

        Spec<FileTreeElement> spec = patternSet.getAsSpec();
        return (snapshot, relativePath) -> spec.isSatisfiedBy(new LogicalFileTreeElement(snapshot, relativePath, stat));
    }

    @Override
    public DirectoryWalkerPredicate getAsDirectoryWalkerPredicate() {
        Spec<FileTreeElement> spec = patternSet.getAsSpec();

            }
        }

        when:
        directorySnapshotter().snapshot(rootDir.absolutePath, directoryWalkerPredicate(patternSet), [:], completeSnapshotConsumer)
        then:
        1 * patternSet.getAsSpec() >> assertingSpec

        visitedWithJdk7Walker.empty
    }

    @Override
    protected List<DirectorySnapshotter> getWalkers() {
        [
            directorySnapshotter()
        ]
    }

            }
        });
        buildInputHierarchy.recordInputs(taskInputs);
        filteredFileTreeTaskInputs.forEach(fileTree -> buildInputHierarchy.recordFilteredInput(fileTree.getRoot(), fileTree.getPatterns().getAsSpec()));
    }

    private static class FilteredTree {
        private final String root;
        private final PatternSet patterns;

        private FilteredTree(String root, PatternSet patterns) {

                preserveSet.exclude(preserveSpec.getExcludes());
            }
            this.preserveSet = preserveSet;
            this.preserveSpec = preserveSet.getAsSpec();
        }

        @Override
        public void visitDir(FileVisitDetails dirDetails) {
            maybeDelete(dirDetails);
        }

        @Override

     */
    public void visitFrom(FileVisitor visitor, File fileOrDirectory, RelativePath path, AtomicBoolean stopFlag) {
        Spec<FileTreeElement> spec = patternSet.getAsSpec();
        if (fileOrDirectory.exists()) {
            if (fileOrDirectory.isFile()) {
                processSingleFile(fileOrDirectory, visitor, spec, stopFlag);
            } else {