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

        for (ClassNode child : classNode.getChildren()) {
            writeLibraryAccessorClass(child, deprecated);
            writeLibrarySubClasses(child, deprecated);
        }
    }

    private void writeVersionSubClasses(ClassNode classNode) throws IOException {
        for (ClassNode child : classNode.getChildren()) {
            writeVersionAccessorClass(child);
            writeVersionSubClasses(child);

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

        configureRoot.parent == null
        configureRoot.child("Configure project :a")
        configureRoot.child("Download ${modules.projectB.pom.uri}").assertIsDownload(modules.projectB.pom)
        configureRoot.child("Download ${modules.projectB.artifact.uri}").assertIsDownload(modules.projectB.artifact)
        configureRoot.child("Download ${modules.projectC.rootMetaData.uri}").assertIsDownload(modules.projectC.rootMetaData)

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

	allErrs := field.ErrorList{}
	if transport == nil {
		allErrs = append(allErrs, field.Required(
			fldPath.Child("transport"),
			"transport must be set for HTTPConnect"))
		return allErrs
	}

	if transport.TCP != nil && transport.UDS != nil {
		allErrs = append(allErrs, field.Invalid(
			fldPath.Child("tcp"),
			transport.TCP,
			"TCP and UDS cannot both be set"))

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

			name: "cluster-scoped bad child, namespaced good child, missing parent",
			steps: []step{
				// setup
				createObjectInClient("", "v1", "pods", "ns1", makeMetadataObj(pod2ns1, pod1ns1)),     // good child
				createObjectInClient("", "v1", "nodes", "", makeMetadataObj(node1, pod1nonamespace)), // bad child

				// 2,3: observe bad child
				processEvent(makeAddEvent(node1, pod1nonamespace)),