*/
    public PatternSet getPatterns() {
        return patternSupplier.get();
    }

    @Override
    protected void visitChildren(Consumer<FileCollectionInternal> visitor) {
        // For backwards compatibility, need to calculate the patterns on each query
        PatternFilterable patterns = getPatterns();

                }
            }
        });
        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) {

                public Object doCall(Object ignore) {
                    return tree.getPatterns().addToAntBuilder(node, null);
                }
            });
        }
        return null;
    }

        return baseDir;
    }

    @Override
    public PatternSet getPatterns() {
        return new PatternSet().include(includePattern).exclude(excludeSpec);
    }

    @Override
    public void visitStructure(MinimalFileTreeStructureVisitor visitor, FileTreeInternal owner) {
        visitor.visitFileTree(baseDir, getPatterns(), owner);
    }

    @Override
    public void visit(FileVisitor visitor) {

            if (id.equals(i.next())) {
                matched = true;
            }
        }
        return matched;
    }

    public List<String> getPatterns() {
        return new ArrayList<>(patterns);
    }

    @Override
    public int hashCode() {
        int hash = 17;
        hash = hash * 31 + patterns.hashCode();

        return hash;
    }

     */
    File getDir();

    /**
     * Returns the patterns which select the files under the base directory.
     *
     * @return The patterns, never returns null.
     */
    PatternSet getPatterns();

 *
 * @since 7.6
 */
public interface InternalTestSpec extends InternalTaskSpec {
    List<String> getPackages();
    List<String> getClasses();
    Map<String, List<String>> getMethods();
    List<String> getPatterns();

        if (!file.getAbsolutePath().startsWith(prefix)) {
            return false;
        }

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

                        public Object doCall(Object ignore) {
                            dynamicObject.invokeMethod("gradleBaseDirSelector", Collections.singletonMap("baseDir", fileTree.getDir()));
                            fileTree.getPatterns().addToAntBuilder(node, null);
                            return null;
                        }
                    });
                }
                return null;
            }
        });

    @Override
    public String getDisplayName() {
        return tree.getDisplayName();
    }

    public FileSystemMirroringFileTree getTree() {
        return tree;
    }

    public PatternSet getPatterns() {
        return patterns;
    }

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