}

        List<N> children = new ArrayList<N>();
        graph.getNodeValues(node, new HashSet<Object>(), children);
        if (children.isEmpty()) {
            return;
        }
        graphRenderer.startChildren();
        for (int i = 0; i < children.size(); i++) {
            N child = children.get(i);
            renderTo(child, graphRenderer, rendered, i == children.size() - 1);
        }

type incomparable [0]func()

type node struct {
	_ incomparable

	// children is non-nil for internal nodes
	children *[256]*node

	// The following are only valid if children is nil:
	codeLen uint8 // number of bits that led to the output of sym
	sym     byte  // output symbol
}

func newInternalNode() *node {
	return &node{children: new([256]*node)}
}

var (
	buildRootOnce       sync.Once

        def suiteTestOps = operations.children(firstLevelTestOps[0], ExecuteTestBuildOperationType)
        assert suiteTestOps.size() == 1
        assert suiteTestOps*.details.testDescriptor.name == ["SimpleTest"]
        assert suiteTestOps*.details.testDescriptor.className == [null]
        assert suiteTestOps*.details.testDescriptor.composite == [true]

        def suiteTestTestOps = operations.children(suiteTestOps[0], ExecuteTestBuildOperationType)

            }
            if (classes.length > 0) {
                node.attr['class'] = classes.join(' ');
            }
            $.each(dependency.children, function(index, dependency) {
                var dependencyNode = createDependencyNode(dependency);
                node.children.push(dependencyNode);
            });
            return node;
        }

        def dep2 = new SimpleDependency("dep2")
        def dep21 = new SimpleDependency("dep2.1")
        def dep22 = new SimpleDependency("dep2.2")

        root.children.addAll(dep1, dep2)
        dep1.children.addAll(dep11)
        dep2.children.addAll(dep21, dep22)

        when:
        renderer.render([root])
        renderer.complete()

        then:
        textOutput.value.readLines() == [

        def link2 = snapshot.children[0].children[0] as DirectorySnapshot
        link2.accessType == AccessType.VIA_SYMLINK
        link2.name == "linked"

        def link3 = link2.children[1].children[0] as DirectorySnapshot
        link3.accessType == AccessType.VIA_SYMLINK
        link3.name == "linked3"

        def link4 = link3.children[0].children[0] as RegularFileSnapshot

        Map<ComponentIdentifier, RenderableDependency> children = new LinkedHashMap<>();
        for (ResolvedDependencyResult dependent : module.getDependents()) {
            InvertedRenderableModuleResult child = new InvertedRenderableModuleResult(dependent);
            if (!children.containsKey(child.getId())) {
                children.put(child.getId(), child);
            }
        }

        AbstractIncompleteFileSystemNode newChild = getNodeWithIndexOfSelectedChild(resultRoot.children) as AbstractIncompleteFileSystemNode
        then:
        resultRoot.children == childrenWithSelectedChildReplacedBy(commonPrefix, newChild)
        newChild.children == sortedChildren(
            newGrandChildPath, newGrandChild,
            selectedChildPathFromCommonPrefix, selectedChild
        )

import org.eclipse.aether.graph.DependencyNode;

class WrapperNode extends AbstractNode {
    protected final Node delegate;
    protected final List<Node> children;

    WrapperNode(Node delegate, List<Node> children) {
        this.delegate = delegate;
        this.children = children;
    }

    @Override
    DependencyNode getDependencyNode() {
        return Utils.cast(AbstractNode.class, delegate, "delegate").getDependencyNode();

                    cf.close();
                }

                int n = 0;
                try ( CloseableIterator<SmbResource> children = f.children("*.txt") ) {
                    while ( children.hasNext() ) {
                        try ( SmbResource r = children.next() ) {
                            assertTrue(r.exists());
                            n++;
                        }
                    }