InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
            UniAddress uniAddress = new UniAddress(inetAddress);
            assertEquals(uniAddress, uniAddress.unwrap(UniAddress.class));
        }

        @Test
        void shouldReturnNullWhenTypeIsNotAssignable() throws UnknownHostException {
            InetAddress inetAddress = InetAddress.getByName("127.0.0.1");

  public void testIncrementIPv6() throws UnknownHostException {
    InetAddress addressV6_66_0 = InetAddress.getByName("2001:db8::6600");
    InetAddress addressV6_66_ff = InetAddress.getByName("2001:db8::66ff");
    InetAddress addressV6_67_0 = InetAddress.getByName("2001:db8::6700");

    InetAddress address = addressV6_66_0;
    for (int i = 0; i < 255; i++) {
      address = InetAddresses.increment(address);

    @Test
    void getAddressReturnsOriginalObject() {
        InetAddress dummy = mock(InetAddress.class);
        UniAddress ua = new UniAddress(dummy);
        assertSame(dummy, ua.getAddress(), "getAddress should return the wrapped address");
    }

    @Test
    void getHostNameDelegatesToWrappedInetAddress() {
        InetAddress dummy = mock(InetAddress.class);
        when(dummy.getHostName()).thenReturn("host.example.com");

 */
package okhttp3

import assertk.assertThat
import assertk.assertions.containsExactly
import java.net.InetAddress
import java.net.UnknownHostException
import java.util.Collections
import okio.Buffer

class FakeDns : Dns {
  private val hostAddresses: MutableMap<String, List<InetAddress>> =
    Collections.synchronizedMap(mutableMapOf())

   *
   * @param address the InetAddress to decrement
   * @return a new InetAddress that is one less than the passed in address
   * @throws IllegalArgumentException if InetAddress is at the beginning of its range
   * @since 18.0
   */
  public static InetAddress decrement(InetAddress address) {
    byte[] addr = address.getAddress();
    int i = addr.length - 1;
    while (i >= 0 && addr[i] == (byte) 0x00) {

        final String addr = props.getProperty(key);
        if (addr != null) {
            try {
                def = InetAddress.getByName(addr);
            } catch (final UnknownHostException uhe) {
                log.error("Unknown host " + addr, uhe);
            }
        }
        return def;
    }

    /**

  private fun lookupHttps(hostname: String): List<InetAddress> {
    val networkRequests =
      buildList {
        add(client.newCall(buildRequest(hostname, DnsRecordCodec.TYPE_A)))

        if (includeIPv6) {
          add(client.newCall(buildRequest(hostname, DnsRecordCodec.TYPE_AAAA)))
        }
      }

    val failures = ArrayList<Exception>(2)
    val results = ArrayList<InetAddress>(5)

    }

    /**
     * Retrieve an <code>InetAddress</code>. If the address is not
     * an IP address and cannot be resolved <code>null</code> will
     * be returned.
     *
     * @param key the property key to look up
     * @param def the default InetAddress to return if the property is not found or cannot be resolved
     * @return the property value as an InetAddress, or the default value
     */

        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.

  override fun createSocket(
    host: String,
    port: Int,
    localAddress: InetAddress,
    localPort: Int,
  ): SSLSocket {
    val sslSocket = delegate.createSocket(host, port, localAddress, localPort) as SSLSocket
    return configureSocket(sslSocket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: InetAddress,
    port: Int,
  ): SSLSocket {