void getAllByNameRejectsNullOrEmptyHostname() {
        assertThrows(UnknownHostException.class, () -> UniAddress.getAllByName("", false),
                "getAllByName should throw UnknownHostException for empty string");
        assertThrows(UnknownHostException.class, () -> UniAddress.getAllByName(null, false),
                "getAllByName should throw UnknownHostException for null name");
    }

        // getFirstAddress branch: host given and path non-root -> possibleNTDomain=false
        when(nsc.getAllByName(eq("server"), eq(false))).thenReturn(new Address[] { addr });
        SmbResourceLocatorImpl workgroupLike = locator("smb://server/");
        // path is "/" -> triggers possibleNTDomainOrWorkgroup true
        when(nsc.getAllByName(eq("server"), eq(true))).thenReturn(new Address[] { addr });
        assertTrue(workgroupLike.isWorkgroup());

        boolean possibleNTDomainOrWorkgroup = true;
        Address[] expectedAddresses = { mock(Address.class) };
        when(nameServiceClient.getAllByName(hostname, possibleNTDomainOrWorkgroup)).thenReturn(expectedAddresses);

        // Act
        Address[] actualAddresses = nameServiceClient.getAllByName(hostname, possibleNTDomainOrWorkgroup);

        // Assert
        assertNotNull(actualAddresses);

     */

    public static UniAddress getByName(final String hostname, final boolean possibleNTDomainOrWorkgroup) throws UnknownHostException {
        final UniAddress[] addrs = UniAddress.getAllByName(hostname, possibleNTDomainOrWorkgroup);
        return addrs[0];
    }

    /**
     * Resolves all addresses for the given hostname.
     *
     * @param hostname the hostname to resolve

    @Override
    public UniAddress getByName(final String hostname, final boolean possibleNTDomainOrWorkgroup) throws UnknownHostException {
        return getAllByName(hostname, possibleNTDomainOrWorkgroup)[0];
    }

    @Override
    public UniAddress[] getAllByName(final String hostname, final boolean possibleNTDomainOrWorkgroup) throws UnknownHostException {
        if (hostname == null || hostname.length() == 0) {

                    }
                } else if (path.length() == 0 || path.equals("/")) {
                    this.addresses = this.ctx.getNameServiceClient().getAllByName(host, true);
                } else {
                    this.addresses = this.ctx.getNameServiceClient().getAllByName(host, false);
                }

        when(addr1.getHostAddress()).thenReturn("10.0.0.1");

        Address addr2 = mock(Address.class);
        when(addr2.getHostAddress()).thenReturn("10.0.0.2");

        when(nameSvc.getAllByName(eq("test.server"), eq(true))).thenReturn(new Address[] { addr1, addr2 });

        // Set fail counts (addr1 has more failures, addr2 has fewer)
        pool.failCounts.put("10.0.0.1", 5);

    }

    @Test
    @DisplayName("Should get all addresses by name")
    void testGetAllByName() throws UnknownHostException {
        // When
        Address[] addresses = nameServiceClient.getAllByName("localhost", false);

        // Then
        assertNotNull(addresses, "Should return addresses array");
        assertTrue(addresses.length > 0, "Should return at least one address");
    }

    @Test

     * @param possibleNTDomainOrWorkgroup if true, perform additional master browser lookup
     * @return found addresses
     * @throws UnknownHostException if the hostname cannot be resolved
     */
    Address[] getAllByName(String hostname, boolean possibleNTDomainOrWorkgroup) throws UnknownHostException;

    /**
     * Lookup <code>hostname</code> and return it's <code>UniAddress</code>. If the

     * @throws UnknownHostException if there is an error resolving the name
     */
    public static NbtAddress[] getAllByName(final String host, final int type, final String scope, final InetAddress svr)
            throws UnknownHostException {
        return CLIENT.getAllByName(new Name(host, type, scope), svr);
    }

    /**
     * Retrieve all addresses of a host by it's address. NetBIOS hosts can