childPaths.collect { childPath ->
            def firstSlash = childPath.indexOf('/')
            String newChildPath = firstSlash > -1
                ? "${childPath.substring(0, firstSlash)}0${childPath.substring(firstSlash)}"
                : "${childPath}0"
            new VirtualFileSystemTestSpec(childPaths, newChildPath, null)

            RESULT handleAsDescendantOfChild(VfsRelativePath targetPath, String childPath, T child);
            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);

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

    public void appendPath() {
        RelativePath childPath = new RelativePath(false, "one", "two").append(new RelativePath(true, "three", "four"));
        assertPathContains(childPath, true, "one", "two", "three", "four");

        childPath = new RelativePath(false, "one", "two").append(new RelativePath(true));
        assertPathContains(childPath, true, "one", "two");

            this.spec = spec;
        }

        @Override
        public boolean contains(VfsRelativePath childPath) {
            return matcher.elementWithRelativePathMatches(spec, new File(childPath.getAbsolutePath()), childPath.getAsString());
        }
    }

        ""           | ""    | ""
    }

    def "'#relativePath / #offset' #verb a prefix of '#childPath'"() {
        expect:
        VfsRelativePath.of(relativePath, offset).isPrefixOf(childPath, CASE_SENSITIVE) == result

        where:
        relativePath | offset         | childPath | result
        "a/b"        | "a/".length()  | "a"       | false
        "a/b"        | "a/b".length() | "c"       | true

        ModelPath childPath = modelNode.getPath().child(property.getName());
        if (propertySchema instanceof ManagedImplSchema) {
            if (!property.isWritable() || propertySchema instanceof ScalarCollectionSchema) {
                ModelRegistrations.Builder builder = managedRegistrationBuilder(childPath, property, nodeInitializerRegistry, publicType);

    ASSERT_TF_OK(s) << "TF_GetChildren failed for " << dirpath;
    const char* childpath;
    ASSERT_TRUE(TF_StringStreamNext(children, &childpath));
    ASSERT_EQ(::tensorflow::string(childpath), "somefile.txt");
    // There should only be one file in this directory.
    ASSERT_FALSE(TF_StringStreamNext(children, &childpath));
    ASSERT_EQ(childpath, nullptr);
    TF_StringStreamDone(children);

    TF_FileStatistics stats;

        ModelPath childPath = child.getPath();
        if (!getPath().isDirectChild(childPath)) {
            throw new IllegalArgumentException(String.format("Element registration has a path (%s) which is not a child of this node (%s).", childPath, getPath()));
        }

        ModelNodeInternal currentChild = links == null ? null : links.get(childPath.getName());
        if (currentChild != null) {

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

    private static boolean isFileOnHost(URI uri) {