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

    /**
     * Stores information to the virtual file system that we have learned about.
     *
     * Complete information, like {@link FileSystemLocationSnapshot}s, are not touched nor replaced.
     */
    @CheckReturnValue

    }

    public PartialDirectoryNode(ChildMap<? extends FileSystemNode> children) {
        super(children);
    }

    @Override
    protected FileSystemNode withIncompleteChildren(ChildMap<? extends FileSystemNode> newChildren) {
        return new PartialDirectoryNode(newChildren);
    }

    @Override
    protected Optional<FileSystemNode> withAllChildrenRemoved() {

public abstract class AbstractIncompleteFileSystemNode implements FileSystemNode {
    protected final ChildMap<FileSystemNode> children;

    @SuppressWarnings("unchecked")
    public AbstractIncompleteFileSystemNode(ChildMap<? extends FileSystemNode> children) {
        this.children = (ChildMap<FileSystemNode>) children;
    }

    @Override
    public Optional<FileSystemNode> getNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity) {

    public UnknownFileSystemNode(ChildMap<? extends FileSystemNode> children) {
        super(children);
        assert !children.isEmpty();
    }

    @Override
    public Optional<MetadataSnapshot> getSnapshot() {
        return Optional.empty();
    }

    @Override
    protected FileSystemNode withIncompleteChildren(ChildMap<? extends FileSystemNode> merged) {
        return new UnknownFileSystemNode(merged);
    }

     */
    interface NodeDiffListener {
        NodeDiffListener NOOP = new NodeDiffListener() {
            @Override
            public void nodeRemoved(FileSystemNode node) {
            }

            @Override
            public void nodeAdded(FileSystemNode node) {
            }
        };

        /**
         * Called when a node is removed during the update.
         *

abstract class AbstractFileSystemNodeWithChildrenTest<NODE extends FileSystemNode, CHILD extends FileSystemNode> extends Specification {
    NODE initialRoot
    ChildMap<CHILD> children
    VfsRelativePath searchedPath

    List<FileSystemNode> removedNodes = []
    List<FileSystemNode> addedNodes = []

    SnapshotHierarchy.NodeDiffListener diffListener = new SnapshotHierarchy.NodeDiffListener() {

    private final CaseSensitivity caseSensitivity;
    @VisibleForTesting
    final FileSystemNode rootNode;

    public static SnapshotHierarchy from(FileSystemNode rootNode, CaseSensitivity caseSensitivity) {
        return new DefaultSnapshotHierarchy(rootNode, caseSensitivity);
    }

    private DefaultSnapshotHierarchy(FileSystemNode rootNode, CaseSensitivity caseSensitivity) {
        this.caseSensitivity = caseSensitivity;

            }
        });
    }

    public static <T extends FileSystemNode> Optional<FileSystemNode> getChild(ChildMap<T> children, VfsRelativePath targetPath, CaseSensitivity caseSensitivity) {
        return children.withNode(targetPath, caseSensitivity, new ChildMap.NodeHandler<T, Optional<FileSystemNode>>() {
            @Override
            public Optional<FileSystemNode> handleAsDescendantOfChild(VfsRelativePath pathInChild, T child) {

    List<FileSystemNode> removedSnapshots = []
    List<FileSystemNode> addedSnapshots = []

    SnapshotHierarchy.NodeDiffListener changeListener = new SnapshotHierarchy.NodeDiffListener() {
        @Override
        void nodeRemoved(FileSystemNode node) {
            removedSnapshots.add(node)
        }

        @Override
        void nodeAdded(FileSystemNode node) {
            addedSnapshots.add(node)

        vfsSpec << CHILD_IS_PREFIX
    }

    static ChildMap<FileSystemNode> sortedChildren(String path1, FileSystemNode child1, String path2, FileSystemNode child2) {
        def compared = PathUtil.getPathComparator(CASE_SENSITIVE).compare(path1, path2)
        def entry1 = new ChildMap.Entry<FileSystemNode>(path1, child1)
        def entry2 = new ChildMap.Entry<FileSystemNode>(path2, child2)