*/
    public static VfsRelativePath of(String absolutePath) {
        String normalizedRoot = normalizeRoot(absolutePath);
        return VfsRelativePath.of(normalizedRoot, determineOffset(normalizedRoot));
    }

    @VisibleForTesting
    static VfsRelativePath of(String absolutePath, int offset) {
        return new VfsRelativePath(absolutePath, offset);
    }

     */
    public synchronized void recordNodeAccessingLocations(Node node, Iterable<String> accessedLocations) {
        for (String location : accessedLocations) {
            VfsRelativePath relativePath = VfsRelativePath.of(location);
            root = root.recordValue(relativePath, new DefaultNodeAccess(node));
        }
    }

    /**
     * Records that a node accesses the fileTreeRoot with a filter.
     *

                throw new AssertionError("Unknown case sensitivity: " + caseSensitivity);
        }
    }

    @Override
    public Optional<MetadataSnapshot> findMetadata(String absolutePath) {
        VfsRelativePath relativePath = VfsRelativePath.of(absolutePath);
        if (relativePath.isEmpty()) {
            return rootNode.getSnapshot();
        }
        return rootNode.getSnapshot(relativePath, caseSensitivity);
    }

    @Override

     * Version updates happen via {@link #updateVersion(String)}.
     */
    public long getVersion(String location) {
        VfsRelativePath relativePath = VfsRelativePath.of(location);
        return relativePath.isEmpty()
            ? rootNode.getMaxVersionInHierarchy()
            : rootNode.getVersion(relativePath, caseSensitivity);
    }

    /**

            RESULT handleAsDescendantOfChild(VfsRelativePath targetPath, String childPath, T child);
            RESULT handleAsAncestorOfChild(VfsRelativePath targetPath, String childPath, T child);
            RESULT handleExactMatchWithChild(VfsRelativePath targetPath, String childPath, T child);
            RESULT handleSiblingOfChild(VfsRelativePath targetPath, String childPath, T child, int commonPrefixLength);

        '/a/b/c/'              | 'a/b/c'
        ''                     | ''
    }

    def "'#relativePath' fromChild '#child' is '#result'"() {
        expect:
        VfsRelativePath.of(relativePath).pathFromChild(child).asString == result
        VfsRelativePath.of(child).pathToChild(relativePath) == result

        where:
        relativePath | child | result
        "a/b"        | "a"   | "b"
        "a/b"        | ""    | "a/b"

        def hierarchy = emptyHierarchy()
        hierarchy = hierarchy.recordValue(VfsRelativePath.of("some/location"), 1)
        hierarchy = hierarchy.recordValue(VfsRelativePath.of("some/other/location"), 2)
        hierarchy = hierarchy.recordValue(VfsRelativePath.of("some/location/intermediate/child/sub1/leaf1"), 5)
        hierarchy = hierarchy.recordValue(VfsRelativePath.of("some/location/intermediate/child/sub1/leaf2"), 6)

    }

    /**
     * Visits the values which are attached to ancestors and children of the given location.
     */
    public void visitValues(String location, ValueVisitor<T> visitor) {
        VfsRelativePath relativePath = VfsRelativePath.of(location);
        if (relativePath.isEmpty()) {
            visitAllValues(visitor);
        } else {
            visitValuesRelatedTo(relativePath, visitor);
        }
    }

    /**

        return Optional.of(this);
    }

    @Override
    public Optional<MetadataSnapshot> getSnapshot(VfsRelativePath relativePath, CaseSensitivity caseSensitivity) {
        return getChildSnapshot(relativePath, caseSensitivity);
    }

    protected Optional<MetadataSnapshot> getChildSnapshot(VfsRelativePath relativePath, CaseSensitivity caseSensitivity) {

    @Override
    public ChildMap<T> handleAsDescendantOfChild(VfsRelativePath targetPath, String childPath, T child) {
        T newChild = handler.handleAsDescendantOfChild(targetPath.pathFromChild(childPath), child);
        return withReplacedChild(newChild);
    }

    @Override
    public ChildMap<T> handleAsAncestorOfChild(VfsRelativePath targetPath, String childPath, T child) {