ipv6_ab,
          ipv6_fc,
        ),
      )

    assertThat(result).isEqualTo(
      listOf(ipv6_ab, ipv4_10_0_0_6, ipv6_fc, ipv4_10_0_0_1, ipv4_10_0_0_4),
    )
  }

  @Test fun ipv6Only() {
    val result = reorderForHappyEyeballs(listOf(ipv6_ab, ipv6_fc))

    assertThat(result).isEqualTo(
      listOf(ipv6_ab, ipv6_fc),
    )
  }

  @Test fun ipv4Only() {
    val result =

    assertThat(stringPrep("a\u00ADz")).isEqualTo("az")
    assertThat(stringPrep("a\u200Dz")).isEqualTo("az")
  }

  @Test fun caseFolding() {
    assertThat(stringPrep("localhost")).isEqualTo("localhost")
    assertThat(stringPrep("Localhost")).isEqualTo("localhost")
    assertThat(stringPrep("LOCALHOST")).isEqualTo("localhost")
    assertThat(stringPrep("abc123def")).isEqualTo("abc123def")

    }

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

  @Test fun equalsAndHashcode() {
    val a = factory.newAddress()
    val b = factory.newAddress()
    assertThat(b).isEqualTo(a)
    assertThat(b.hashCode()).isEqualTo(a.hashCode())
  }

  @Test fun differentProxySelectorsAreDifferent() {
    val a = factory.newAddress(proxySelector = RecordingProxySelector())

    val call = client.newCall(request)
    val response1 = call.execute()

    val cloned = call.clone()
    val response2 = cloned.execute()

    assertThat("abc").isEqualTo(response1.body.string())
    assertThat("def").isEqualTo(response2.body.string())
  }

  @Test
  @Flaky
  fun testMockWebserverRequest() {
    enableTls()

    server.enqueue(MockResponse(body = "abc"))

      cache.evictAll()
      assertThat(cache.size()).isEqualTo(expectedByteCount)
      assertThat(readFileOrNull(getCleanFile("a", 0))).isEqualTo(afterRemoveFileContents)
      assertThat(readFileOrNull(getCleanFile("a", 1))).isEqualTo(afterRemoveFileContents)
      it.assertValue(1, "a")
    }
    assertThat(cache.size()).isEqualTo(0L)
  }

  @ParameterizedTest

      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }
  }

  @Test
  @Disabled
  fun testGoogle() {
    assumeNetwork()

    val request = Request.Builder().url("https://google.com/robots.txt").build()

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)

    val response = request.send()
    assertThat(response.status).isEqualTo(200)
    assertThat(response.contentAsString).isEqualTo("hello, Jetty HTTP Client")

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(recorded.headers["Accept-Encoding"]).isEqualTo("gzip")
    assertThat(recorded.headers["Connection"]).isNull()

    val client = clientTestRule.newClient()
    assertThat(client.callTimeoutMillis).isEqualTo(0)
    assertThat(client.connectTimeoutMillis).isEqualTo(10000)
    assertThat(client.readTimeoutMillis).isEqualTo(10000)
    assertThat(client.writeTimeoutMillis).isEqualTo(10000)
    assertThat(client.pingIntervalMillis).isEqualTo(0)
    assertThat(client.webSocketCloseTimeout).isEqualTo(60_000)
  }

  @Test fun webSocketDefaults() {

    call.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
    }
  }

  @Test
  fun testRequestExternal() {
    assumeNetwork()

    val call = client.newCall(Request("https://google.com/robots.txt".toHttpUrl()))

    call.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
    }
  }

  @Test
  fun testRequestInvalid() {

      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }
  }

  @Test
  @Disabled
  fun testGoogle() {
    assumeNetwork()

    val request = Request.Builder().url("https://google.com/robots.txt").build()

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)