* @param localPort the local port to bind to
     * @param hostName the server host name
     * @param exclusive
     *            whether to acquire an unshared connection
     * @return a transport connection to the target
     */
    SmbTransport getSmbTransport(CIFSContext tc, Address address, int port, InetAddress localAddr, int localPort, String hostName,
            boolean exclusive);

    /**

      ),
    )
    server.enqueue(MockResponse())
    val dns = FakeDns()
    dns["fakeurl"] = client.dns.lookup(server.hostName)
    dns["www.fakeurl"] = client.dns.lookup(server.hostName)
    client =
      client
        .newBuilder()
        .dns(dns)
        .build()
    val call =
      client.newCall(
        Request
          .Builder()

            false, false, "Long", 0, 0, null, null, false, null, null, null, null, null, false);
    protected final ColumnInfo _columnHostname = cci("hostname", "hostname", null, null, String.class, "hostname", null, false, false,
            false, "keyword", 0, 0, null, null, false, null, null, null, null, null, false);

    }

    @Test
    @DisplayName("Should handle null hostname in getByName")
    void testGetByNameWithNull() {
        // When/Then
        assertThrows(UnknownHostException.class, () -> {
            nameServiceClient.getByName(null);
        }, "Should throw UnknownHostException for null hostname");
    }

    @Test
    @DisplayName("Should handle empty hostname in getByName")
    void testGetByNameWithEmpty() {

  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<Protocol>,
  ) {
    getDelegate(sslSocket)?.configureTlsExtensions(sslSocket, hostname, protocols)
  }

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? = getDelegate(sslSocket)?.getSelectedProtocol(sslSocket)

            false, false, false, "keyword", 0, 0, null, null, false, null, null, null, null, null, false);
    protected final ColumnInfo _columnHostname = cci("hostname", "hostname", null, null, String.class, "hostname", null, false, false,
            false, "keyword", 0, 0, null, null, false, null, null, null, null, null, false);

    @Override
    public String toString() {
        return "FileAuthentication [fileConfig=" + fileConfig + ", createdBy=" + createdBy + ", createdTime=" + createdTime
                + ", fileConfigId=" + fileConfigId + ", hostname=" + hostname + ", parameters=" + parameters + ", port=" + port
                + ", protocolScheme=" + protocolScheme + ", updatedBy=" + updatedBy + ", updatedTime=" + updatedTime + ", username="

    platform.assumeNotConscrypt()

    val handshakeCertificates = localhost()
    server.useHttps(handshakeCertificates.sslSocketFactory())

    val dns =
      Dns {
        Dns.SYSTEM.lookup(server.hostName)
      }

    val client =
      clientTestRule
        .newClientBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,

        final String hostname = paramMap.get(CRAWLER_WEB_AUTH + "." + webAuthName + ".host");
        final String port = paramMap.get(CRAWLER_WEB_AUTH + "." + webAuthName + ".port");
        final String realm = paramMap.get(CRAWLER_WEB_AUTH + "." + webAuthName + ".realm");
        AuthScope authScope;
        if (StringUtil.isBlank(hostname)) {
            authScope = AuthScope.ANY;
        } else {

                for (int i = 0; i < response.addressArray.length; i++) {
                    response.addressArray[i].hostName.srcHashCode = srcHashCode;
                }
                return response.addressArray;
            }
        }
        throw new UnknownHostException(addr.hostName.name);
    }