private final long maxVersionInHierarchy;
    private final ChildMap<VersionHierarchy> children;

    public static VersionHierarchy empty(long version) {
        return new VersionHierarchy(EmptyChildMap.getInstance(), version, version);
    }

    private VersionHierarchy(ChildMap<VersionHierarchy> children, long version, long maxVersionInHierarchy) {
        this.children = children;

        return new PartialDirectoryNode(EmptyChildMap.getInstance());
    }

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

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

    @Override

        return handler.handleUnrelatedToAnyChild();
    }

    @Override
    public <RESULT> ChildMap<RESULT> invalidate(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, InvalidationHandler<T, RESULT> handler) {
        handler.handleUnrelatedToAnyChild();
        return getInstance();
    }

    @Override
    public ChildMap<T> store(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, StoreHandler<T> storeHandler) {

        return index;
    }

    public static <T extends FileSystemNode> Optional<MetadataSnapshot> getMetadataFromChildren(ChildMap<T> children, VfsRelativePath targetPath, CaseSensitivity caseSensitivity, Supplier<Optional<MetadataSnapshot>> noChildFoundResult) {
        return children.withNode(targetPath, caseSensitivity, new ChildMap.NodeHandler<T, Optional<MetadataSnapshot>>() {
            @Override

class DirectoryNodeTest extends AbstractFileSystemNodeWithChildrenTest<FileSystemNode, FileSystemLocationSnapshot> {
    @Override
    protected FileSystemNode createInitialRootNode(ChildMap<FileSystemLocationSnapshot> children) {
        return new DirectorySnapshot("/root/some/path", PathUtil.getFileName("path"), AccessType.DIRECT, TestHashCodes.hashCodeFrom(1234), children).asFileSystemNode()
    }

    @Override

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

class PartialDirectoryNodeTest extends AbstractIncompleteFileSystemNodeTest<PartialDirectoryNode> {

    @Override
    protected PartialDirectoryNode createInitialRootNode(ChildMap<FileSystemNode> children) {
        return new PartialDirectoryNode(children)
    }

    @Override
    protected boolean isSameNodeType(FileSystemNode node) {
        node instanceof PartialDirectoryNode
    }

class UnknownFileSystemNodeTest extends AbstractIncompleteFileSystemNodeTest<UnknownFileSystemNode> {

    @Override
    protected UnknownFileSystemNode createInitialRootNode(ChildMap<FileSystemNode> children) {
        return new UnknownFileSystemNode(children)
    }

    @Override
    protected boolean isSameNodeType(FileSystemNode node) {
        return node instanceof UnknownFileSystemNode