var client =
    OkHttpClient.Builder()
      .build()

  @Test
  fun getWithCustomSocketFactory() {
    assumeTrue(Build.VERSION.SDK_INT >= 24)

    class CustomSSLSocketFactory(
      delegate: SSLSocketFactory,
    ) : DelegatingSSLSocketFactory(delegate) {
      override fun configureSocket(sslSocket: SSLSocket): SSLSocket {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {

      HandshakeCertificates.Builder()
        .addPlatformTrustedCertificates()
        .addInsecureHost(server.hostName)
        .build()

    val client =
      clientTestRule.newClientBuilder()
        .sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
        .build()

    val call = client.newCall(Request(server.url("/")))
    val response = call.execute()

        .addHeader("Set-Cookie", "a=android")
        .addHeader("Set-Cookie", "b=banana")
        .build(),
    )
    server.enqueue(MockResponse())
    val cookieManager = CookieManager(null, CookiePolicy.ACCEPT_ORIGINAL_SERVER)
    client =
      client.newBuilder()
        .cookieJar(JavaNetCookieJar(cookieManager))
        .build()
    get(urlWithIpAddress(server, "/"))
    val request1 = server.takeRequest()

  private lateinit var dns: Dns
  private val cacheFs = FakeFileSystem()
  private val bootstrapClient =
    OkHttpClient.Builder()
      .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
      .build()

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
    server.protocols = bootstrapClient.protocols
    dns = buildLocalhost(bootstrapClient, false)
  }

  @Test
  fun getOne() {

        .noStore()
        .maxAge(1, TimeUnit.SECONDS)
        .maxStale(2, TimeUnit.SECONDS)
        .minFresh(3, TimeUnit.SECONDS)
        .onlyIfCached()
        .noTransform()
        .immutable()
        .build()
    assertThat(cacheControl.toString()).isEqualTo(
      "no-cache, no-store, max-age=1, max-stale=2, min-fresh=3, only-if-cached, " +
        "no-transform, immutable",
    )
    assertThat(cacheControl.noCache).isTrue()

    val headers1 =
      Headers.Builder()
        .add("Connection", "close")
        .add("Transfer-Encoding", "chunked")
        .build()
    val headers2 =
      Headers.Builder()
        .add("Connection", "close")
        .add("Transfer-Encoding", "chunked")
        .build()
    assertThat(headers2).isEqualTo(headers1)
    assertThat(headers2.hashCode()).isEqualTo(headers1.hashCode())
  }

 */
private val TLS_13 =
  ConnectionSpec.Builder(true)
    .cipherSuites(*TLS13_CIPHER_SUITES.toTypedArray())
    .tlsVersions(TlsVersion.TLS_1_3)
    .build()

private val TLS_12 =
  ConnectionSpec.Builder(ConnectionSpec.RESTRICTED_TLS)
    .tlsVersions(TlsVersion.TLS_1_2)
    .build()

private fun testClient(
  urls: List<String>,
  client: OkHttpClient,
) {
  try {
    for (url in urls) {
      sendRequest(client, url)

          """
          |data: hey
          |
          |
          """.trimMargin(),
        ).setHeader("content-type", "text/event-stream")
        .build(),
    )
    val request =
      Request.Builder()
        .url(server.url("/"))
        .build()
    val response = client.newCall(request).execute()
    processResponse(response, listener)
    listener.assertOpen()
    listener.assertEvent(null, null, "hey")

          .build(),
      )
      .setDnsOptions(
        DnsOptions.Builder()
          .setUseHttpStackDnsResolver(DnsOptions.DNS_OPTION_ENABLED)
          .setStaleDns(DnsOptions.DNS_OPTION_ENABLED)
          .setPersistHostCache(DnsOptions.DNS_OPTION_ENABLED)
          .build(),
      )
      .setQuicOptions(
        QuicOptions.Builder()

              .add("publicobject.com", "sha256/Vjs8r4z+80wjNcr1YKepWQboSIRi63WsWXhIMN+eWys=")
              .build())
      .build();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/robots.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {