MetadataTreeNode parent; // papa

    /** default # of children. Used for tree creation optimization only */
    int nChildren = 8;

    MetadataTreeNode[] children; // of cause

    public int getNChildren() {
        return nChildren;
    }

    public void setNChildren(int children) {
        nChildren = children;
    }

        children << CHILDREN_LISTS
    }

    def "children names #children are sorted the same with path sensitive and name only comparison"() {
        def nameSorted = children.toSorted(PathUtil.&compareFileNames)
        def caseSensitiveSorted = children.toSorted(getPathComparator(CASE_SENSITIVE))

        expect:
        nameSorted == caseSensitiveSorted

        where:
        children << [
            ["bAdA", "BaDb"],

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

        children.collectMany { child ->
            def childIndex = children.indexOf(child)
            [
                new CaseSensitivityTestSpec(children, child, childIndex),
                new CaseSensitivityTestSpec(children, "$child/a/something", childIndex),
                new CaseSensitivityTestSpec(children, "$child/A/something", childIndex),

     */
    FileSystemNode selectedChild

    abstract protected NODE createInitialRootNode(ChildMap<CHILD> children);

    abstract protected CHILD mockChild()

    void setupTest(VirtualFileSystemTestSpec spec) {
        this.children = createChildren(spec.childPaths)
        this.initialRoot = createInitialRootNode(children)
        this.searchedPath = spec.searchedPath
        this.selectedChildPath = spec.selectedChildPath

    private final ChildMap<FileSystemLocationSnapshot> children;
    private final HashCode contentHash;

    public DirectorySnapshot(String absolutePath, String name, AccessType accessType, HashCode contentHash, List<FileSystemLocationSnapshot> children) {
        this(absolutePath, name, accessType, contentHash, childMapFromSorted(children.stream()
            .map(it -> new ChildMap.Entry<>(it.getName(), it))

//		if ... should visit children ... {
//			ir.DoChildren(x, do)
//			... processing AFTER visiting children ...
//		}
//		if ... should stop parent DoChildren call from visiting siblings ... {
//			return true
//		}
//		return false
//	}
//	do(root)
//
// Since DoChildren does not return true itself, if the do function
// never wants to stop the traversal, it can assume that DoChildren

                }

                children.add(new ResolutionNode(a, remoteRepositories, this));
            }
            children = Collections.unmodifiableList(children);
        } else {
            children = Collections.emptyList();
        }
        trail = null;
    }

    /**

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

    /**
     * Queries the version for the hierarchy at relative path.
     *
     * The version for the hierarchy is the maximum version of all the locations in the hierarchy.
     */

    private final List<T> children;

    public CompositeOperation(Iterable<? extends T> children) {
        this.children = Lists.newArrayList(children);
    }

    public List<T> getOperations() {
        return children;
    }

    @Override
    public Iterator<T> iterator() {
        return children.iterator();
    }

    @Override
    long getElapsedTime() {