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

    public DefaultIdeaProject setChildren(Collection<? extends DefaultIdeaModule> children) {
        this.children.clear();
        this.children.addAll(children);
        return this;
    }

    public Collection<DefaultIdeaModule> getChildren() {
        return children;
    }

    public Collection<DefaultIdeaModule> getModules() {
        return 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"],

        project.children.size() == 1
        GradleProject a = project.children[0]
        a.name == 'a'
        a.path == ':a'
        a.description == 'A rocks!'

        a.children.size() == 2
        a.children.find { it.name == 'b' && it.path == ':a:b' }
        a.children.find { it.name == 'c' && it.path == ':a:c' }
        
        a.children.find { it.name == 'c'}.children[0].name == 'd'
    }

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

    }

    @Override
    public Set<ResourceFilterMatcher> getChildren() {
        return children;
    }

    public void setChildren(Set<ResourceFilterMatcher> children) {
        if (children == null) {
            throw new InvalidUserDataException("children must not be null");
        }
        this.children = children;
    }

                }

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

    /**

    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;
    }

 *
 * This implementation combines the hashes of the children of a directory into a single hash for the directory.
 * For the hash to be reproducible, the children must be sorted in a consistent order.
 * The implementation uses {@link FileSystemLocationSnapshot#BY_NAME} ordering.
 * If you already provide the children in sorted order, use {@link #noSortingRequired()} to avoid the overhead of sorting again.
 */