"""
        file("child1/build.gradle") << """
println "child: " + doSomething(11)
println "child: " + doSomethingElse(11)
"""

        expect:
        // Invoke twice to exercise script caching
        succeeds()
        outputContains("root: {10}")
        outputContains("root: [10]")
        outputContains("child: {11}")
        outputContains("child: [11]")

        and:
        succeeds()

	allErrs = append(allErrs, ValidateAnnotations(meta.GetAnnotations(), fldPath.Child("annotations"))...)
	allErrs = append(allErrs, ValidateOwnerReferences(meta.GetOwnerReferences(), fldPath.Child("ownerReferences"))...)
	allErrs = append(allErrs, ValidateFinalizers(meta.GetFinalizers(), fldPath.Child("finalizers"))...)

					allErrs = append(allErrs, field.Invalid(pth.Child("default"), s.Default.Object, "must not have unknown fields"))
				}
			}

			// check ObjectMeta/TypeMeta and everything else
			if err := schemaobjectmeta.Coerce(pth.Child("default"), s.Default.Object, s, s.XEmbeddedResource, false); err != nil {
				allErrs = append(allErrs, err)

        T newChild = handler.handleAsDescendantOfChild(targetPath.pathFromChild(childPath), child);
        return withReplacedChild(newChild);
    }

    @Override
    public ChildMap<T> handleAsAncestorOfChild(VfsRelativePath targetPath, String childPath, T child) {
        T newChild = handler.handleAsAncestorOfChild(childPath, child);

        expect:
        assertNodesAccessing("/some", ancestor, child, grandChild)
        assertNodesAccessing("/some/location", ancestor, child, grandChild)
        assertNodesAccessing("/some/location/child/within", ancestor, child, grandChild)
        assertNodesAccessing("/some/location/child/other", ancestor)
    }

    def "ancestor accesses location"() {

class NestedModelRuleDescriptor extends AbstractModelRuleDescriptor {

    private final ModelRuleDescriptor parent;
    private final ModelRuleDescriptor child;

    public NestedModelRuleDescriptor(ModelRuleDescriptor parent, ModelRuleDescriptor child) {
        this.parent = parent;
        this.child = child;
    }

    @Override
    public void describeTo(Appendable appendable) {
        parent.describeTo(appendable);
        try {

        def outerBuild = new BuildTestFile(testDirectory, "root")
        def childBuild = new BuildTestFile(testDirectory.file("child"), "child")

        outerBuild.settingsFile << """
            includeBuild 'child'
        """
        outerBuild.file('buildSrc/src/main/java/Thing.java') << """
            class Thing {
                Thing() { System.out.println("outer thing"); }

//	NewRootObjectFunc().Index().Child("foo") == [{"foo": x}]
//	NewRootObjectFunc().Index().Child("foo").Child("bar") == [{"foo": {"bar":x}}]
//	NewRootObjectFunc().Index().Child("foo").Child("bar").Index() == [{"foo": {"bar":[x]}}]
//
// and:
//
//	NewRootObjectFunc(), then acc(x) == x
//	NewRootObjectFunc().Index(), then acc([x]) == x
//	NewRootObjectFunc().Index().Child("foo"), then acc([{"foo": x}]) == x

            addedNodes.add(node)
        }
    }

    String selectedChildPath
    /**
     * The child, if any, which has a common prefix with the selected path.
     */
    FileSystemNode selectedChild

    abstract protected NODE createInitialRootNode(ChildMap<CHILD> children);

    abstract protected CHILD mockChild()

    void setupTest(VirtualFileSystemTestSpec spec) {

            RESULT handleAsAncestorOfChild(VfsRelativePath targetPath, String childPath, T child);
            RESULT handleExactMatchWithChild(VfsRelativePath targetPath, String childPath, T child);
            RESULT handleSiblingOfChild(VfsRelativePath targetPath, String childPath, T child, int commonPrefixLength);