this.caseSensitivity = caseSensitivity;
        this.stat = stat;
        outputHierarchy = new ExecutionNodeAccessHierarchy(caseSensitivity, stat);
        destroyableHierarchy = new ExecutionNodeAccessHierarchy(caseSensitivity, stat);
    }

    @Override
    public void discardAll() {
        outputHierarchy.clear();
        destroyableHierarchy.clear();
    }

    /**

    public <R> R withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, R> handler) {
        return entry.withNode(targetPath, caseSensitivity, handler);
    }

    @Override
    public <RESULT> ChildMap<RESULT> invalidate(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, InvalidationHandler<T, RESULT> handler) {

            return handleAncestorDescendantOrExactMatch(targetPath, caseSensitivity, handler)
                .orElseGet(handler::handleUnrelatedToAnyChild);
        }

        public <RESULT> Optional<RESULT> handleAncestorDescendantOrExactMatch(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, RESULT> handler) {

    public boolean hasPrefix(String prefix, CaseSensitivity caseSensitivity) {
        return isPrefix(prefix, 0, absolutePath, offset, caseSensitivity);
    }

    /**
     * Checks whether this path is a prefix of another path.
     */
    public boolean isPrefixOf(String otherPath, CaseSensitivity caseSensitivity) {
        return isPrefix(absolutePath, offset, otherPath, 0, caseSensitivity);
    }

    }

    @Override
    public Optional<FileSystemNode> getNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity) {
        return SnapshotUtil.getChild(children, targetPath, caseSensitivity);
    }

    @Override
    public Optional<FileSystemNode> invalidate(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, SnapshotHierarchy.NodeDiffListener diffListener) {

    }

    @Override
    public <RESULT> RESULT withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, RESULT> handler) {
        for (Entry<T> entry : entries) {
            Optional<RESULT> ancestorDescendantOrExactMatchResult = entry.handleAncestorDescendantOrExactMatch(targetPath, caseSensitivity, handler);
            if (ancestorDescendantOrExactMatchResult.isPresent()) {

     */
    Optional<MetadataSnapshot> getSnapshot(VfsRelativePath relativePath, CaseSensitivity caseSensitivity);

    Optional<FileSystemNode> getNode(VfsRelativePath relativePath, CaseSensitivity caseSensitivity);

    /**
     * Stores information to the virtual file system that we have learned about.
     *

            absolutePath,
            accessType
        )
    }

    static SnapshotHierarchy buildHierarchy(CaseSensitivity caseSensitivity = CaseSensitivity.CASE_INSENSITIVE, List<FileSystemLocationSnapshot> snapshots) {
        SnapshotHierarchy root = DefaultSnapshotHierarchy.empty(caseSensitivity)
        snapshots.each { snapshot -> root = root.store(snapshot.absolutePath, snapshot, SnapshotHierarchy.NodeDiffListener.NOOP)}

abstract class AbstractCaseVfsRelativePathTest extends Specification {

    abstract CaseSensitivity getCaseSensitivity()

    def "length of common prefix of #prefix and #absolutePath is #result"() {
        expect:
        VfsRelativePath.of(absolutePath).lengthOfCommonPrefix(prefix, caseSensitivity) == result

        where:
        prefix      | absolutePath  | result
        'root'      | '/'           | 0

    private final CaseSensitivity caseSensitivity;
    private final ChildMap.StoreHandler<T> handler;

    public AbstractStorePathRelationshipHandler(CaseSensitivity caseSensitivity, ChildMap.StoreHandler<T> handler) {
        this.caseSensitivity = caseSensitivity;
        this.handler = handler;
    }