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

        where:
        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)

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

        _ * protocolProject.getName() >> 'name'

        expect:
        def model = adapter.adapt(TestModel.class, protocolModel)
        model.childMap.size() == 1
        model.childMap[model.project] == model.project
    }

    def adaptsEnum() {
        TestProtocolModel protocolModel = Mock()
        _ * protocolModel.getTestEnum() >> TestEnum.FIRST

        expect: