final ImmutableMap<Long, Index> children;
        final Region stdOut;
        final Region stdErr;

        private Index(Region stdOut, Region stdErr) {
            this.children = ImmutableMap.of();
            this.stdOut = stdOut;
            this.stdErr = stdErr;
        }

        private Index(ImmutableMap<Long, Index> children, Region stdOut, Region stdErr) {

        when:
        def eclipseModel = modelBuilder.buildAll("org.gradle.tooling.model.eclipse.EclipseProject", project)

        then:
        DefaultEclipseProject eclipseChild2 = eclipseModel.children.find { it.name == 'child2' }
        eclipseChild2.projectDependencies.collect { it.path } == ['child1']
        // verify we inherit the transitive dependency

	optsSpecified := c.opts.Port.Name != "" || c.opts.Port.Protocol != "" || c.opts.Scheme != ""
	if optsSpecified && len(c.children) > 0 {
		t.Fatal("TrafficTestCase: must not specify both opts and children")
	}
	if !optsSpecified && len(c.children) == 0 {
		t.Fatal("TrafficTestCase: must specify either opts or children")
	}

	if !c.RequiresL4 {
		c.comboFilters = append(c.comboFilters, echotest.HasL7)
	}

            spec()
            children.add(childBuilder)
        }

        ProjectDescriptor build() {
            children.shuffle()
            def childDescriptors = children*.build() as Set<TestProjectDescriptor>
            def thisProject = new TestProjectDescriptor()
            thisProject.name = name
            thisProject.children = childDescriptors

        assert project.children*.path == children
        assert project.buildTreePath == buildTreePath ?: project.path
    }

    Map project(String path, Map rootProject, Map parent = null) {
        if (parent == null) {
            if (path.lastIndexOf(':') == 0) {
                return rootProject.children.find { it.path == path }
            } else {

        def ownPackageName = packageName(classNumber, subProjectNumber)
        def imports = ''
        def children = dependencyTree.getTransitiveChildClassIds(classNumber)
        (0..Math.max(propertyCount, children.size()) - 1).each {
            def propertyType
            if (it < children.size()) {
                def childNumber = children.get(it)
                propertyType = "Production${childNumber}"

        this.name = name;
        this.path = path;
        this.description = description;
        this.projectDirectory = projectDirectory;
        this.tasks = Collections.emptyList();
        this.children = Lists.newArrayList(children);
        this.classpath = Collections.emptyList();

        assert actual.children().size() == expected.children().size()
        assert actual.name == expected.name
        ModelReportParser.NODE_ATTRIBUTES.each { String display, String property ->
            if (expected.attribute(property)) {
                assert actual.attribute(property) == expected.attribute(property)
            }
        }
        expected.children().eachWithIndex { ReportNode node, int index ->

    }

    /**
     * Starts visiting the children of the most recently visited node.
     */
    public void startChildren() {
        if (seenRootChildren) {
            prefix.append(lastChild ? "     " : "|    ");
        }
        seenRootChildren = true;
    }

    /**
     * Completes visiting the children of the node which most recently started visiting children.
     */
    public void completeChildren() {

 * 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.
     *