childPaths.findAll { it.contains('/') } collectMany { childPath ->
            parentPaths(childPath).collect { parentPath ->
                new VirtualFileSystemTestSpec(childPaths, parentPath, findPathWithParent(childPaths, parentPath))
            }
        }
    }

    /**
     * The queried/updated path is one of the initial children of the node under test.
     *

        int nextIndex = 0;
        if (parentPath != null) {
            System.arraycopy(parentPath.segments, 0, newSegments, 0, parentPath.segments.length);
            nextIndex = parentPath.segments.length;
        }
        for (String segment : childSegments) {
            if (segment.equals(".")) {
                continue;
            }
            if (segment.equals("..")) {

		return
	}

	pathLen := len(c.parentPath)
	c.pushKey(field)
	errPath := strings.Join(c.parentPath, "")
	c.parentPath = c.parentPath[:pathLen]
	c.unknownFieldErrors = append(c.unknownFieldErrors, fmt.Errorf(`unknown field "%s"`, errPath))
}

func (c *fromUnstructuredContext) pushIndex(index int) {
	if !c.returnUnknownFields {
		return
	}

	c.parentPath = append(c.parentPath, "[", strconv.Itoa(index), "]")

        def project = projects.find {it.name == name}
        assert project != null :  "No project with name $name found"
        assertProject(project, rootDir, path, name, parentPath, childPaths)
     }

    private static void assertProject(def project, File rootDir, String path, String name, String parentPath, List<String> childPaths) {

                        while (outputFileParent != null) {
                            String parentPath = outputFileParent.getPath();
                            if (outputFiles.getIfPresent(parentPath) != null) {
                                break;
                            }
                            outputFiles.put(parentPath, OutputKind.PARENT_OF_OUTPUT);
                            outputFileParent = outputFileParent.getParentFile();

        return delegate.findTask(path).also { task ->
            if (task == null) {
                // check whether the path refers to a different project
                val parentPath = path?.let(Path::path)?.parent?.path
                if (parentPath != referrerProject.path) {
                    // even though the task was not found, the current project is coupled with the other project:

            return null;
        }
        if (segments.length == 1) {
            return absolute ? ROOT : null;
        }
        String[] parentPath = new String[segments.length - 1];
        System.arraycopy(segments, 0, parentPath, 0, parentPath.length);
        return new Path(parentPath, absolute);
    }

    /**
     * Returns the base name of this path, or null if this path is the root path.
     *

	// ReturnUnknownFieldPaths will return the paths to fields that are not
	// recognized as part of the schema.
	ReturnUnknownFieldPaths bool
	// ParentPath provides the current path up to the given ObjectMeta.
	// If nil, the metadata is assumed to be at the root of the object.
	ParentPath *field.Path
}

// GetObjectMetaWithOptions  does conversion of JSON to ObjectMeta.
// It first tries json.Unmarshal into a metav1.ObjectMeta

        String parentPath = extractPath(parent);
        String childPath = path.startsWith("/") ? path.substring(1) : path;
        if (childPath.length() == 0) {
            return parentPath;
        } else if (parentPath.endsWith("/")) {
            return parentPath + childPath;
        } else {
            return parentPath + "/" + childPath;
        }
    }

            RelativePath parentPath;
            if (parentResolver == null) {
                parentPath = new RelativePath(false);
            } else {
                parentPath = parentResolver.getDestPath();
            }

            String path = DefaultCopySpec.this.getDestPath();
            if (path == null) {
                return parentPath;
            }