return read_status;
  }
}

absl::StatusOr<std::vector<std::string>> ListDirectory(
    absl::string_view directory) {
  std::vector<std::string> children;
  TF_RETURN_IF_ERROR(
      tsl::Env::Default()->GetChildren(std::string(directory), &children));
  return children;
}

        files.each { file ->
            assert file.size % 16 == 0
        }
    }
}

model {
    root(DirectoryItem) {
        children {
            dir(DirectoryItem) {
                children {
                    file1(FileItem)
                    file2(FileItem) { size = 2048 }
                }
            }
            file3(FileItem)
        }
    }

}
"""

        when:
        EclipseProject rootProject = loadToolingModel(EclipseProject)
        EclipseProject aProject = rootProject.children.find { it.name == 'a'}
        EclipseProject bProject = rootProject.children.find { it.name == 'b'}
        EclipseProject cProject = rootProject.children.find { it.name == 'c'}
        then:
        aProject.classpath.find { it.file.name == "someArtifact-17.0.jar" }

        });
        return index;
    }

    public static <T extends FileSystemNode> Optional<MetadataSnapshot> getMetadataFromChildren(ChildMap<T> children, VfsRelativePath targetPath, CaseSensitivity caseSensitivity, Supplier<Optional<MetadataSnapshot>> noChildFoundResult) {
        return children.withNode(targetPath, caseSensitivity, new ChildMap.NodeHandler<T, Optional<MetadataSnapshot>>() {
            @Override

    }

    def "children with same name are equivalent"() {
        def child1 = root.child(root.name)
        def child2 = root.child(root.name)
        def grandChild1 = child1.child(root.name)
        def grandChild2 = child2.child(root.name)

        expect:
        equivalent(child1, child2)
        equivalent(grandChild1, grandChild2)
    }

            collectorField.setAccessible(true);
            Target target = (Target) collectorField.get(this);
            Field childrenField = Target.class.getDeclaredField("children");
            childrenField.setAccessible(true);
            children = (List) childrenField.get(target);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    private void wrapContentInContainer(Document document) {
        // Wrap the page in a text container to get the margins
        Elements bodyContent = document.body().children().remove();
        document.body().prepend("<div class='container'/>");
        document.body().children().get(0).html(bodyContent.outerHtml());
    }

    private void addTOC(Document document) {

        when:
        EclipseProject rootProject = loadToolingModel(EclipseProject)
        EclipseProject javaProject = rootProject.children.find{ it.name == 'java-project' }
        EclipseProject groovyProject = rootProject.children.find{ it.name == 'groovy-project' }
        EclipseProject scalaProject = rootProject.children.find{ it.name == 'scala-project' }

        then:
        rootProject.projectNatures.collect{ it.id } == []

        if (leafInCurrent != null) {
            returnTrueIfNoArgumentsLeft(paramIndex, leafInCurrent);
        }
        Map<ParameterMatchEntry, SignatureTree> children = current.getChildrenByMatchEntry();
        if (!children.isEmpty()) {
            boolean hasParamMatchers = children.keySet().stream().anyMatch(it -> it.kind == PARAMETER);
            if (hasParamMatchers) { // is not the receiver or vararg

        if (leafInCurrent != null) {
            generateInvocationWhenArgsMatched(leafInCurrent, paramIndex);
        }
        Map<ParameterMatchEntry, SignatureTree> children = current.getChildrenByMatchEntry();
        if (!children.isEmpty()) {
            boolean hasParamMatchers = children.keySet().stream().anyMatch(it -> it.kind == PARAMETER);
            if (hasParamMatchers) { // is not the receiver or vararg