// If telemetryChildVar is set to "1" in the environment, this is the telemetry
// child.
//
// If telemetryChildVar is set to "2", this is a child of the child, and no
// further forking should occur.
const telemetryChildVar = "GO_TELEMETRY_CHILD"

// If telemetryUploadVar is set to "1" in the environment, the upload token has been
// acquired by the parent, and the child should attempt an upload.
const telemetryUploadVar = "GO_TELEMETRY_CHILD_UPLOAD"

		allErrs = append(allErrs, ValidateToken(d.TLSBootstrapToken, fldPath.Child("tlsBootstrapToken"))...)
	}

	if d.File != nil {
		allErrs = append(allErrs, ValidateDiscoveryFile(d.File, fldPath.Child("file"))...)
		if len(d.TLSBootstrapToken) != 0 {
			allErrs = append(allErrs, ValidateToken(d.TLSBootstrapToken, fldPath.Child("tlsBootstrapToken"))...)
		}
	}

	allErrs = append(allErrs, validatePodInfoOnMount(spec.PodInfoOnMount, fldPath.Child("podInfoOnMount"))...)
	allErrs = append(allErrs, validateStorageCapacity(spec.StorageCapacity, fldPath.Child("storageCapacity"))...)
	allErrs = append(allErrs, validateFSGroupPolicy(spec.FSGroupPolicy, fldPath.Child("fsGroupPolicy"))...)

                    files = compile.getFiles { true }

                    assert files.collect { it.name } == ['hiphop-1.0.jar', 'child.jar', 'rock-1.0.jar']

                    def artifacts = compile.artifacts

                    assert artifacts.size() == 3
                    assert artifacts.collect { it.file.name } == ['hiphop-1.0.jar', 'child.jar', 'rock-1.0.jar']

        def child = nextNode()
        def edge1 = edge(parent1, false, null, child)
        def edge2 = edge(parent2, false, null, child)
        parent1.collectAncestorsStrictVersions([parent1Edge])
        parent2.collectAncestorsStrictVersions([parent2Edge])
        child.collectAncestorsStrictVersions([edge1, edge2])

        then:

	//
	// In principle, what we are doing is:
	// 1. Creating a new PTY parent/child FD pair.
	// 2. Create a child that is in the foreground process group of the PTY, and read() from that process.
	// 3. Stop the child with ^Z.
	// 4. Take over as foreground process group of the PTY from the parent.
	// 5. Make the child foreground process group again.
	// 6. Continue the child.
	//
	// On Darwin, step 4 results in the read() returning EINTR once the

            });
        }
        for (ProjectState child : project.getChildProjects()) {
            ProjectState previous = candidates.put(child.getIdentityPath().getName(), child);
            if (previous != null) {
                throw new IllegalStateException("Duplicate child project names for " + project.getDisplayName());
            }
        }
        ProjectState child = candidates.get(childName);
        if (child != null) {

                }
            }
            ${buildFinishedCall('root-build-finished')}
        """
        createDirs("child/a", "child/b")
        file("child/settings.gradle") << """
            include 'a', 'b'
        """
        file("child/build.gradle") << """
            ${server.callFromBuild('child-build-script')}
            task hello {
                dependsOn {
                    // call during task graph calculation

        }

        Operation child(Spec<String> displayNameSpec) {
            def child = children.find { displayNameSpec.isSatisfiedBy(it.descriptor.displayName) }
            if (child == null) {
                throw new AssertionFailedError("No operation matching display name found in children of '$descriptor.displayName':\n${describeList(children)}")
            }
            return child
        }

        manager.useLogger(listener1)
        def child = manager.createChild(Scope.Build)
        def broadcaster = child.getBroadcaster(BuildScopeListener.class)
        child.useLogger(listener2)

        when:
        broadcaster.foo("param")

        then:
        1 * listener2.foo("param")
        0 * _

        when:
        child.useLogger(listener3)
        broadcaster.foo("param2")