}

func insertChildrenRecursive(componentName name.ComponentName, tree ComponentTree, children componentNameToListMap) {
	tree[componentName] = make(ComponentTree)
	for _, child := range children[componentName] {
		insertChildrenRecursive(child, tree[componentName].(ComponentTree), children)
	}
}

// InstallTreeString returns a string representation of the dependency tree.
func InstallTreeString() string {

 * We know everything about this snapshot, including children and Merkle hash.
 *
 * The snapshot can be a snapshot of a regular file or of a whole directory tree.
 * The file at the location is not required to exist (see {@link MissingFileSnapshot}).
 */
public interface FileSystemLocationSnapshot extends FileSystemSnapshot, FileSystemNode, MetadataSnapshot {

    /**
     * The comparator of direct children of a file system location.
     *

                false // error?
            // no children of secondary constructs are used.
            is KtSecondaryConstructor ->
                false

            // KtClass, KtObjectDeclaration, KtTypeAlias has no expression children
            is KtClassLikeDeclaration ->
                false // has no expression children

            // Simple names do not have expression children

        DefaultGradleProject model = buildWithoutChildren(project, isolatedModel);
        Collection<Project> children = getChildProjectsForInternalUse(project);
        List<IsolatedGradleProjectInternal> isolatedChildrenModels = getIsolatedModels(root, children, parameter);
        model.setChildren(buildChildren(root, model, parameter, children, isolatedChildrenModels));
        return model;
    }

    private List<DefaultGradleProject> buildChildren(

        def child21 = new DefaultGradleProject().setProjectIdentifier(new DefaultProjectIdentifier(new File("."), ":child2:child21"))

        root.children = [child1, child2]
        child1.children = [child11, child12]
        child2.children = [child21]

        expect:
        root.findByPath(':') == root
        root.findByPath('') == null
        root.findByPath('blah blah') == null

    TF_StringStream* children = TF_GetChildren(dirpath.c_str(), s);
    ASSERT_TF_OK(s) << "TF_GetChildren failed for " << dirpath;
    const char* childpath;
    ASSERT_TRUE(TF_StringStreamNext(children, &childpath));
    ASSERT_EQ(::tensorflow::string(childpath), "somefile.txt");
    // There should only be one file in this directory.
    ASSERT_FALSE(TF_StringStreamNext(children, &childpath));
    ASSERT_EQ(childpath, nullptr);

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

type node[T any] struct {
	items    items[T]
	children items[*node[T]]
}

func (n *node[T]) f(i int, j int) bool {
	if len(n.children[i].items) < j {
		return false
	}
	return true
}

type items[T any] []T

func main() {
	_ = node[int]{}
	_ = f[int]
}

type s[T, U any] struct {

        def children = daemonProcess.getChildProcesses()
        // Sends a kill -9 to the daemon process only
        daemons.daemon.killDaemonOnly()

        then:
        children.length == 0

        cleanup:
        // In the event this fails, clean up any orphaned children
        children.each { child ->
            new ProcessFixture(child as Long).kill(true)

    private final Set<RenderableDependency> children = new LinkedHashSet<>();

    public RequestedVersion(ComponentSelector requested, ComponentIdentifier actual, boolean resolvable) {
        this.requested = requested;
        this.actual = actual;
        this.resolvable = resolvable;
    }

    public void addChild(DependencyEdge child) {
        children.addAll(child.getChildren());
    }

    @Override

        when:
        DefaultCopySpec child1 = spec.addFirst()

        then:
        child1
        spec.children == [child1]

        when:
        DefaultCopySpec child2 = spec.addFirst()

        then:
        child2
        spec.children == [child2, child1]
    }

    def 'add Spec in between two child Specs if given child exists'() {
        when: