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 {

        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);

            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);

        Optional<RESULT> invalidatedChild = handler.handleAsDescendantOfChild(pathInChild, child);
        return invalidatedChild
            .map(this::withReplacedChild)
            .orElseGet(this::withRemovedChild);
    }

    @Override
    public ChildMap<RESULT> handleAsAncestorOfChild(String childPath, T child) {
        handler.handleAsAncestorOfChild(childPath, child);

	}
	if pvSpec.PhotonPersistentDisk != nil {
		warnings = append(warnings, fmt.Sprintf("%s: deprecated in v1.11, non-functional in v1.16+", fieldPath.Child("spec", "photonPersistentDisk")))
	}
	if pvSpec.ScaleIO != nil {
		warnings = append(warnings, fmt.Sprintf("%s: deprecated in v1.16, non-functional in v1.22+", fieldPath.Child("spec", "scaleIO")))
	}

	// status is set and is an accepted value
	if !validConditionStatuses.Has(string(condition.Status)) {
		allErrs = append(allErrs, field.NotSupported(fldPath.Child("status"), condition.Status, validConditionStatuses.List()))
	}

	if condition.LastUpdateTime.IsZero() {
		allErrs = append(allErrs, field.Required(fldPath.Child("lastTransitionTime"), "must be set"))
	}

        def index = SnapshotUtil.indexByAbsolutePath(relocated)

        then:
        index.keySet() == [
            targetDir.absolutePath,
            targetDir.file("child").absolutePath,
            targetDir.file("child/child.txt").absolutePath,
            targetDir.file("parent.txt").absolutePath,
        ] as Set

        index.values()*.name as Set == [
            targetDir.name,
            childDir.name,

        assertEquals("http://server.org/child", normalize("http://server.org/parent/../child"));
        assertEquals("http://server.org/child", normalize("http://server.org/grand/parent/../../child"));

        assertEquals("http://server.org//child", normalize("http://server.org/parent/..//child"));
        assertEquals("http://server.org/child", normalize("http://server.org/parent//../child"));
    }

    @Test

    def "produces reasonable error message when nested buildFile evaluation fails"() {
        createDirs("child")
        settingsFile << """
include 'child'
"""
        buildFile << """
    evaluationDependsOn 'child'
    task t
"""
        final childBuildFile = file("child/build.gradle")
        childBuildFile << """
    def broken = { ->
        throw new RuntimeException('failure')
    }