* an IPv4 address or not.
   *
   * <p>IPv6 addresses are <b>coerced</b> to IPv4 addresses before being converted to integers.
   *
   * <p>As long as there are applications that assume that all IP addresses are IPv4 addresses and
   * can therefore be converted safely to integers (for whatever purpose) this function can be used
   * to handle IPv6 addresses as well until the application is suitably fixed.
   *

	"github.com/minio/minio/internal/logger"
	xnet "github.com/minio/pkg/v3/net"
)

var (
	// IPv4 addresses of localhost.
	localIP4 = mustGetLocalIP4()

	// IPv6 addresses of localhost.
	localIP6 = mustGetLocalIP6()

	// List of all local loopback addresses.
	localLoopbacks = mustGetLocalLoopbacks()
)

// mustSplitHostPort is a wrapper to net.SplitHostPort() where error is assumed to be a fatal.

They're also concrete: each URL identifies a specific path (like `/square/okhttp`) and query (like `?q=sharks&lang=en`). Each webserver hosts many URLs.

### [Addresses](https://square.github.io/okhttp/5.x/okhttp/okhttp3/-address/)

Addresses specify a webserver (like `github.com`) and all of the **static** configuration necessary to connect to that server: the port number, HTTPS settings, and preferred network protocols (like HTTP/2).

    }

    @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

    val result = proxies[nextProxyIndex++]
    resetNextInetSocketAddress(result)
    return result
  }

  /** Prepares the socket addresses to attempt for the current proxy or host. */
  @Throws(IOException::class)
  private fun resetNextInetSocketAddress(proxy: Proxy) {
    // Clear the addresses. Necessary if getAllByName() below throws!
    val mutableInetSocketAddresses = mutableListOf<InetSocketAddress>()

    @Test
    public void testIsIPv6Address() {
        // IPv6 addresses
        assertTrue(IpAddressUtil.isIPv6Address("::1"));
        assertTrue(IpAddressUtil.isIPv6Address("2001:db8::1"));
        assertTrue(IpAddressUtil.isIPv6Address("fe80::1"));
        assertTrue(IpAddressUtil.isIPv6Address("2001:0db8:0000:0000:0000:ff00:0042:8329"));

        // IPv4 addresses
        assertFalse(IpAddressUtil.isIPv6Address("127.0.0.1"));

    }

    /**
     * Gets the list of new IP addresses.
     *
     * @return the new IP addresses
     */
    public List<WitnessIPAddress> getNewIPAddresses() {
        return newIPAddresses;
    }

    /**
     * Gets the list of old IP addresses.
     *
     * @return the old IP addresses
     */
    public List<WitnessIPAddress> getOldIPAddresses() {

     * fallbacks to prevent the host machine's various IP addresses from interfering.
     */
    private val SINGLE_INET_ADDRESS_DNS =
      Dns { hostname ->
        val addresses = Dns.SYSTEM.lookup(hostname)
        listOf(addresses[0])
      }

    private operator fun Throwable?.plus(throwable: Throwable): Throwable {
      if (this != null) {

			// the 'for=' capture, which we ignore. In the case of multiple IP
			// addresses (for=8.8.8.8, 8.8.4.4, 172.16.1.20 is valid) we only
			// extract the first, which should be the client IP.
			if match := forRegex.FindStringSubmatch(fwd); len(match) > 1 {
				// IPv6 addresses in Forwarded headers are quoted-strings. We strip
				// these quotes.
				addr = strings.Trim(match[1], `"`)
			}
		}

import okio.Buffer

/**
 * Quick and dirty pattern to differentiate IP addresses from hostnames. This is an approximation
 * of Android's private InetAddress#isNumeric API.
 *
 * This matches IPv6 addresses as a hex string containing at least one colon, and possibly
 * including dots after the first colon. It matches IPv4 addresses as strings containing only