compositeIncludedRoot()

        when:
        def model = withConnection {
            getModel(HierarchicalEclipseProject)
        }

        then:
        model.children[1].projectDependencies.size() == 1
        model.children[1].projectDependencies[0].path == 'sub-a'
    }

        return visitor.leave(this);
    }

    @Override
    public Node filter(Predicate<Node> filter) {
        List<Node> children =
                getChildren().stream().filter(filter).map(n -> n.filter(filter)).collect(Collectors.toList());
        return new WrapperNode(this, Collections.unmodifiableList(children));
    }

    @Override
    public String asString() {
        StringBuilder sb = new StringBuilder();

		p.mu.Lock()
		if p.err != nil {
			// parent has already been canceled
			child.cancel(false, p.err, p.cause)
		} else {
			if p.children == nil {
				p.children = make(map[canceler]struct{})
			}
			p.children[child] = struct{}{}
		}
		p.mu.Unlock()
		return
	}

	if a, ok := parent.(afterFuncer); ok {
		// parent implements an AfterFunc method.
		c.mu.Lock()

    }

    @Override
    public Set<ResolvedDependency> getChildren() {
        return ImmutableSet.copyOf(children);
    }

    @Override
    public Collection<? extends DependencyGraphNodeResult> getOutgoingEdges() {
        return children;
    }

    @Override
    public Set<ResolvedArtifact> getModuleArtifacts() {

                }
            }
        }

        when:
        IdeaProject project = withConnection { connection -> connection.getModel(IdeaProject.class) }
        IdeaModule module = project.children[0]
        IdeaContentRoot root = module.contentRoots[0]

        then:
        root.sourceDirectories.size() == 1
        root.sourceDirectories.first().directory == file('src/main/java')

//go:build ignore

package main

import (
	"log"
	"os"
	"runtime"
	"runtime/trace"
	"time"
)

type node struct {
	children [4]*node
	data     [128]byte
}

func makeTree(depth int) *node {
	if depth == 0 {
		return new(node)
	}
	return &node{
		children: [4]*node{
			makeTree(depth - 1),
			makeTree(depth - 1),
			makeTree(depth - 1),
			makeTree(depth - 1),
		},
	}
}

            it.details.pluginClass == "Plugin1"
        }
        p1.details.targetPath == ":a"

        def children = operations.search(p1) {
            ApplyPluginBuildOperationType.Details.isAssignableFrom(it.detailsType)
        }

        children.size() == 1
        def p2 = children.first()

        p2.details.targetPath == ":b"
        p2.details.pluginClass == "Plugin2"
    }

            }

            dependencies {
                implementation project(':a')
            }
        """

        when:
        EclipseProject project = loadToolingModel(EclipseProject).children.find { it.gradleProject.path == ':b' }

        then:
        project.projectDependencies.size() == 1
        project.projectDependencies[0].classpathAttributes.find { it.name == 'without_test_code' }.value == "true"
    }

    /**
     * {@link NodeList}の文字列表現を追加します。
     *
     * @param children
     *            子要素。{@literal null}であってはいけません
     * @param buf
     *            文字列バッファ。{@literal null}であってはいけません
     */
    public static void appendChildren(final NodeList children, final StringBuilder buf) {
        assertArgumentNotNull("children", children);
        assertArgumentNotNull("buf", buf);

	w.varint(uint64(typ.Size()))
	w.varint(uint64(typ.PtrBytes))
	w.varint(uint64(len(typName)))
	w.stringData(typName)

	// Recursively walk all child nodes.
	for i := range node.children {
		child := node.children[i].Load()
		if child == nil {
			continue
		}
		w = dumpTypesRec((*traceMapNode)(child), w)
	}
	return w