assertNotNull(result);
        List<Dependency> deps = new ArrayList<>(result.getDependencies().keySet());
        List<Dependency> deps2 = result.getNodes().stream()
                .map(Node::getDependency)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        assertEquals(deps, deps2);
        for (Dependency dep : deps2) {

	client.pools = make([]int, len(p))
	copy(client.pools, p)
}

// newPeerS3Clients creates new peer clients.
func newPeerS3Clients(endpoints EndpointServerPools) (peers []peerS3Client) {
	nodes := endpoints.GetNodes()
	peers = make([]peerS3Client, len(nodes))
	for i, node := range nodes {
		if node.IsLocal {
			peers[i] = &localPeerS3Client{node: node}
		} else {
			peers[i] = newPeerS3Client(node)
		}

func (l EndpointServerPools) ESCount() (count int) {
	for _, p := range l {
		count += p.SetCount
	}
	return count
}

// GetNodes returns a sorted list of nodes in this cluster
func (l EndpointServerPools) GetNodes() (nodes []Node) {
	nodesMap := make(map[string]Node)
	for _, pool := range l {
		for _, ep := range pool.Endpoints {
			node, ok := nodesMap[ep.Host]
			if !ok {

                    Type t = pt.getActualTypeArguments()[0];
                    if (t == Node.class) {
                        result = res.getNodes();
                    } else if (t == Path.class) {
                        result = res.getPaths();
                    }

        assertEquals(readings, elevateWord.getReadings());
        assertEquals(fields, elevateWord.getFields());
        assertEquals(tags, elevateWord.getTags());
        assertNotNull(elevateWord.getRoles());
        assertTrue(elevateWord.getRoles().isEmpty());
    }

    @Test
    public void testConstructorWithNullTagsAndRoles() {
        // Test constructor with both null tags and roles
        String word = "test word";

        pluginProject.getModel().setParent(createParent(parentProject));
        projects.add(pluginProject);

        Plugin plugin = createPlugin(pluginProject);

        plugin.addDependency(createDependency(pluginLevelDepProject));

        Build build = declaringProject.getModel().getBuild();

        build.addPlugin(plugin);

        declaringProject.getModel().setBuild(build);

        if ((groupId == null) && (getModel().getParent() != null)) {
            groupId = getModel().getParent().getGroupId();
        }

        return groupId;
    }

    public void setArtifactId(String artifactId) {
        getModel().setArtifactId(artifactId);
    }

    public String getArtifactId() {
        return getModel().getArtifactId();
    }

        testInheritance(baseName, true);
    }

    public void testInheritance(String baseName, boolean fromRepo) throws IOException {
        Model parent = getModel(baseName + "-parent");

        Model child = getModel(baseName + "-child");

        if (fromRepo) {
            // when model is read from repo, a stream is used, then pomFile == null

        assertNotNull(childProject.getParent());
        assertEquals("1", childProject.getParent().getVersion());
        assertNotNull(childProject.getModel().getParent());
        assertEquals("[1,10]", childProject.getModel().getParent().getVersion());
    }

    /**
     * Tests whether local version range parent references are built correctly.
     */
    @Test

        assertNotNull(item.getFields());
        assertEquals(0, item.getFields().length);
        assertNotNull(item.getTags());
        assertEquals(0, item.getTags().length);
        assertNotNull(item.getRoles());
        assertEquals(1, item.getRoles().length); // Default role is added
        assertNotNull(item.getLanguages());
        assertEquals(0, item.getLanguages().length);
        assertNotNull(item.getKinds());