dependenciesById.get(id).children = entry.getValue().collect {
                def child = dependenciesById.get(it)
                if (child == null) {
                    child = new TestResolvedDependency()
                    dependenciesById.put(it, child)
                }
                child
            } as Set
        }
        def root = dependenciesById.remove(0)

		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"))...)
		}
	}

		// If we're in the parent, we must return immediately
		// so we're not in the same stack frame as the child.
		// This can at most use the return PC, which the child
		// will not modify, and the results of
		// rawVforkSyscall, which must have been written after
		// the child was replaced.
		return
	}

	// Fork succeeded, now in child.

	// Enable the "keep capabilities" flag to set ambient capabilities later.

        thrown IllegalStateException
    }

    def "child scopes can access exported but not local"() {
        when:
        file("local/local") << "bar"
        file("export/export") << "bar"
        scope.local(classPath("local"))
        scope.export(classPath("export"))
        def child = scope.lock().createChild("child", null).lock()

        then:
        child.localClassLoader.getResource("root").text == "root"

            version = (String) appNode.attribute("version");
            for (final Node child : Cast.<List<Node>>uncheckedCast(appNode.children())) {
                String childLocalName = localNameOf(child);
                switch (childLocalName) {
                    case "application-name":

                        applicationName = child.text();

                        break;
                    case "initialize-in-order":

        buildScript '''
            @Managed
            interface Parent {
                String getName()
                void setName(String name)

                Child getChild()
            }

            @Managed
            interface Child {
                Parent getParent()
                void setParent(Parent parent)
            }

            class RulePlugin extends RuleSource {
                @Model

        ''                     | ''
    }

    def "'#relativePath' fromChild '#child' is '#result'"() {
        expect:
        VfsRelativePath.of(relativePath).pathFromChild(child).asString == result
        VfsRelativePath.of(child).pathToChild(relativePath) == result

        where:
        relativePath | child | result
        "a/b"        | "a"   | "b"
        "a/b"        | ""    | "a/b"

        createDirs("child")
        settingsFile << """
            include ':child'
        """
        buildFile << """
            apply plugin: "java"

            task wait {
                doLast {
                    sleep 2000
                }
            }

            project(':child') {
                configurations {
                    foo

	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"))...)

            children.forEach((entry, child) -> {
                if (entry.kind != VARARG) {
                    generateNormalCallChecksAndVisitSubtree(entry, child, paramIndex);
                }
            });
            if (hasParamMatchers) {
                result.endControlFlow();
            }
            children.forEach((entry, child) -> {
                if (entry.kind == VARARG) {