mutableInetSocketAddresses += InetSocketAddress.createUnresolved(socketHost, socketPort)
    } else {
      val addresses =
        if (socketHost.canParseAsIpAddress()) {
          listOf(InetAddress.getByName(socketHost))
        } else {
          call.eventListener.dnsStart(call, socketHost)

          val result = address.dns.lookup(socketHost)
          if (result.isEmpty()) {

     */
    public static boolean isIPv6Address(final String address) {
        if (address == null) {
            return false;
        }
        try {
            final InetAddress inetAddress = InetAddress.getByName(address);
            return inetAddress instanceof Inet6Address;
        } catch (final Exception e) {
            return false;
        }
    }

    /**
     * Formats an IP address string for use in a URL.

                    final String mb = nameServiceClient.getNbtByName(NbtAddress.MASTER_BROWSER_NAME, 0x01, null).getHostAddress();
                    dc = nameServiceClient.getByName(mb);
                } else {
                    dc = nameServiceClient.getByName(server, possibleWorkgroup);
                }

                req.getSession(); /* ensure session id is set for cluster env. */

    //         */
    //
    //        UniAddress dc = UniAddress.getByName(domainName);
    //        SmbTransport trans = SmbTransport.getSmbTransport(dc, 0);
    //        DfsReferral[] dr = trans.getDfsReferrals(auth, "\\" + domainName, 1);
    //
    //        handle = DcerpcHandle.getHandle("ncacn_np:" +
    //                    UniAddress.getByName(dr[0].server).getHostAddress() +
    //                    "[\\PIPE\\netdfs]", auth);

        lenient().when(cifsContext.getConfig()).thenReturn(configuration);
        lenient().when(configuration.getDefaultDomain()).thenReturn("TEST_DOMAIN");
        lenient().when(nameServiceClient.getByName(anyString(), anyBoolean())).thenReturn(mock(Address.class));
        lenient().when(transportPool.getChallenge(any(), any())).thenReturn(new byte[8]);
    }

  }

  private fun urlWithIpAddress(
    server: MockWebServer,
    path: String,
  ): HttpUrl =
    server
      .url(path)
      .newBuilder()
      .host(InetAddress.getByName(server.hostName).hostAddress)
      .build()

  private operator fun get(url: HttpUrl) {
    val call =
      client.newCall(
        Request
          .Builder()
          .url(url)

                addresses = new UniAddress[1];
                addresses[0] = UniAddress.getByName(server);
                return getNextAddress();
            }
            final String address = queryLookup(query, "address");
            if (address != null && address.length() > 0) {
                final byte[] ip = java.net.InetAddress.getByName(address).getAddress();
                addresses = new UniAddress[1];

      if (altNames.isNotEmpty()) {
        val extensionValue =
          altNames.map {
            when {
              it.canParseAsIpAddress() -> {
                generalNameIpAddress to InetAddress.getByName(it).address.toByteString()
              }
              else -> {
                generalNameDnsName to it
              }
            }
          }
        result +=
          Extension(

import java.util.Locale;
import org.jspecify.annotations.Nullable;

/**
 * Static utility methods pertaining to {@link InetAddress} instances.
 *
 * <p><b>Important note:</b> Unlike {@code InetAddress.getByName()}, the methods of this class never
 * cause DNS services to be accessed. For this reason, you should prefer these methods as much as
 * possible over their JDK equivalents whenever you are expecting to handle only IP address string

            task.getExcludedPackages().convention(excludedPackages);
        });
        SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
        sourceSets.getByName("main", main ->
            main.getOutput().dir(singletonMap("builtBy", asList(apiMapping, defaultImports)), generatedDirectory)
        );

        extension.getUserManual().getResources().from(apiMapping);