for _, child := range summary.Children {
			gotChildren[child.ID] = struct{}{}
		}
		for _, wantChild := range want.children {
			if _, ok := gotChildren[wantChild]; ok {
				delete(gotChildren, wantChild)
			} else {
				t.Errorf("expected child task %d for task %d not found", wantChild, id)
			}
		}
		if len(gotChildren) != 0 {
			for child := range gotChildren {

                dir = "main"
                tasks = ['log']
            }
        """
        file('main/settings.gradle') << """
            ${barrier.callFromBuild("child-build-started")}
            ${barrier.callFromBuild("child-build-finished")}
        """
        file('main/build.gradle') << """
            assert gradle.parent.rootProject.name == 'root'
            task log { }
        """

        org.apache.maven.project.ProjectBuilder projectBuilder =
                getContainer().lookup(org.apache.maven.project.ProjectBuilder.class);
        File child = new File(tempDir.toFile(), "child/pom.xml");
        // build project once
        projectBuilder.build(child, configuration);
        // modify parent
        File parent = new File(tempDir.toFile(), "pom.xml");

					badName: "hello world",
				}
				return parameters
			}(),
		},

		"empty-model": {
			wantFailures: field.ErrorList{field.Required(field.NewPath("driverRequests").Index(0).Child("requests").Index(0), "exactly one structured model field must be set")},
			parameters: func() *resource.ResourceClaimParameters {
				parameters := testResourceClaimParameters(goodName, goodName, goodRequests)

		}
	}

	// Allocate child status pipe close on exec.
	e := cexecPipe(p[:])

	if e != nil {
		return 0, e
	}

	// Kick off child.
	pid, err = forkAndExecInChild(argv0p, argvp, envvParsed, dir, attr, p[1], sys.Rfork)

	if err != nil {
		if p[0] >= 0 {
			Close(p[0])
			Close(p[1])
		}
		return 0, err
	}

	// Read child error status from pipe.
	Close(p[1])

        given:
        def conf = dependencyScope("conf")
        def child = resolvable("child", [conf])

        conf.exclude([group: "group1", module: "module1"])
        child.exclude([group: "group2", module: "module2"])

        expect:
        def config = state.getConfiguration("child").metadata
        def excludes = config.excludes

                }
            } else {
                for (ModelNodeInternal child : node.getLinks()) {
                    if (!child.isAtLeast(targetState)) {
                        dependencies.add(graph.nodeAtState(new NodeAtState(child.getPath(), targetState)));
                    }
                }
            }
            return true;
        }

        } else {
            listener.executionStarted(testIdentifier);

            for (TestIdentifier child : testPlan.getChildren(testIdentifier)) {
                dryRun(child, testPlan, listener);
            }
            listener.executionFinished(testIdentifier, TestExecutionResult.successful());
        }
    }

    /**

            .publish()

        ivyRepo.module('ivy.configuration', 'projectB', '1.5')
            .configuration('child')
            .configuration('private', visibility: 'private')
            .artifact()
            .artifact([name: 'projectB', conf: 'runtime'])
            .artifact([name: 'projectB-child', conf: 'child'])
            .artifact([name: 'projectB-private', conf: 'private'])

        DefaultResolvedDependency child = new DefaultResolvedDependency("someChildConfiguration", newId("someGroup", "someChild", "someVersion"), buildOperationProcessor)
        resolvedDependency.addChild(child)

        Set<ResolvedArtifact> childParent1SpecificArtifacts = newHashSet(createArtifact("childParent1Specific"))
        createAndAddParent("childParent1", child, childParent1SpecificArtifacts)