var addresses1 []Address
	if err := DB.Model(&person).Association("Addresses").Find(&addresses1); err != nil || len(addresses1) != 2 {
		t.Fatalf("Failed to find address, got error %v, length: %v", err, len(addresses1))
	}

	if err := DB.Model(&person).Association("Addresses").Delete(&person.Addresses[0]); err != nil {
		t.Fatalf("Failed to delete address, got error %v", err)
	}

	if len(person.Addresses) != 1 {

import assertk.assertions.isNotEqualTo
import java.net.Proxy
import okhttp3.internal.http.RecordingProxySelector
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Test

class AddressTest {
  private val factory =
    TestValueFactory().apply {
      uriHost = "example.com"
      uriPort = 80
    }

  @AfterEach fun tearDown() {
    factory.close()
  }

    val addressD = decodeIpv6("abcd:ef01:2345:6789:abcd:ef01:2345:6789")!!
    assertThat(canonicalizeInetAddress(addressD)).isEqualTo(addressD)

    val addressE = decodeIpv6("2001:db8::1:0:0:1")!!
    assertThat(canonicalizeInetAddress(addressE)).isEqualTo(addressE)

    val addressF = decodeIpv6("0:0:0:0:0:ffff:7f00:1")!!
    assertThat(canonicalizeInetAddress(addressF)).isEqualTo(addressB)

  /** Returns this address's certificate pinner, or null if this is not an HTTPS address. */
  @get:JvmName("certificatePinner") val certificatePinner: CertificatePinner?,
  /** Returns the client's proxy authenticator. */
  @get:JvmName("proxyAuthenticator") val proxyAuthenticator: Authenticator,
  /**
   * Returns this address's explicitly-specified HTTP proxy, or null to delegate to the

* For large fixes (>100 LOC that’s not from generated files), SMEs from that area must also approve the PR.

## Bug Fixes

* Bug fixes will not be merged in until the first release has been published, unless it addresses a critical issue.
* All changes should have an associated GitHub issue and/or a release note.
* Large fixes, where the LOC>100 not withstanding unit tests changes, require subject matter expert approval.

# Backporting fixes

                break;
            case 9: // Host Addresses
                ASN1Sequence adressesSequence = ASN1Util.as(ASN1Sequence.class, tagged);
                Enumeration<?> adresses = adressesSequence.getObjects();
                while ( adresses.hasMoreElements() ) {
                    ASN1Sequence addressSequence = ASN1Util.as(ASN1Sequence.class, adresses);

 *    requires an IP address. The DNS server may return multiple IP addresses to attempt.
 *
 * Each route is a specific selection of these options.
 */
class Route(
  @get:JvmName("address") val address: Address,
  /**
   * Returns the [Proxy] of this route.
   *
   * **Warning:** This may disagree with [Address.proxy] when it is null. When the address's proxy
   * is null, the proxy selector is used.
   */

/**
 * Implementation of HappyEyeballs Sorting Addresses.
 *
 * The current implementation does not address any of:
 *  - Async DNS split by IP class
 *  - Stateful handling of connectivity results
 *  - The prioritisation of addresses
 *
 * https://datatracker.ietf.org/doc/html/rfc8305#section-4
 */
fun reorderForHappyEyeballs(addresses: List<InetAddress>): List<InetAddress> {
  if (addresses.size < 2) {
    return addresses
  }

    /**
     * Retrieve all addresses of a host by it's address. NetBIOS hosts can
     * have many names for a given IP address. The name and IP address make the
     * NetBIOS address. This provides a way to retrieve the other names for a
     * host with the same IP address.
     *
     * @param host
     *            hostname to lookup all addresses for
     * @return resolved addresses
     * @throws java.net.UnknownHostException

import okhttp3.Dns

/**
 * A network that always resolves two IP addresses per host. Use this when testing route selection
 * fallbacks to guarantee that a fallback address is available.
 */
class DoubleInetAddressDns : Dns {
  override fun lookup(hostname: String): List<InetAddress> {
    val addresses = Dns.SYSTEM.lookup(hostname)
    return listOf(addresses[0], addresses[0])
  }