handshakeCertificates.trustManager,
        ).proxy(server.proxyAddress)
        .build()

    server.enqueue(
      MockResponse
        .Builder()
        .inTunnel()
        .build(),
    )
    server.enqueue(MockResponse())

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

        .heldCertificate(certificate, intermediateCa.certificate)
        .build()
    server.useHttps(serverHandshakeCertificates.sslSocketFactory())

    // The request should complete successfully.
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .build(),
    )
    val call1 =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))

          handshakeCertificates.trustManager,
        ).retryOnConnectionFailure(false)
        .build()
    url = server.url("/")
  }

  @Test
  fun get() {
    assumeNotWindows()
    server.enqueue(
      MockResponse
        .Builder()
        .body("Hello!")
        .setHeader("Content-Type", PLAIN)
        .build(),
    )
    val response = client.newCall(request().build()).execute()

    val client = buildClient(clientCert, clientIntermediateCa.certificate)
    val socketFactory = buildServerSslSocketFactory()
    server.useHttps(socketFactory)
    server.requestClientAuth()
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .build(),
    )
    val call = client.newCall(Request.Builder().url(server.url("/")).build())
    val response = call.execute()

      .build()

  private val server =
    MockWebServer()

  @Test
  fun testHttpsRequest() {
    server.useHttps(handshakeCertificates.sslSocketFactory())

    server.enqueue(MockResponse())
    server.start()

    val request = Request.Builder().url(server.url("/")).build()

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)

    override fun requestHeadersStart(call: Call) {
      if (shouldClose) {
        lastSocket!!.close()
      }
    }
  }

  @Test
  fun socketFailureOnLargeRequestHeaders() {
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())
    server.start()

    val call1 =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )

  fun cancelAndFollowup() {
    val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
    server.enqueue(
      MockResponse
        .Builder()
        .body(
          Buffer()
            .write(ByteArray(responseBodySize)),
        ).throttleBody(64 * 1024, 125, MILLISECONDS) // 500 Kbps
        .build(),
    )
    server.enqueue(MockResponse(body = "."))

                )
              }
            },
          ),
        ).sslSocketFactory(sslSocketFactory, handshakeCertificates.trustManager)
        .build()

    server.enqueue(MockResponse(body = "abc1"))
    server.enqueue(MockResponse(body = "abc2"))

    val request = Request(server.url("/"))

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.enqueue(
      MockResponse(
        headers =
          headersOf(
            "Last-Modified",
            formatDate(-1, TimeUnit.HOURS)!!,
            "Expires",
            formatDate(1, TimeUnit.HOURS)!!,
          ),
        body = "ABC.1",
      ),
    )
    server.enqueue(
      MockResponse(
        headers =
          headersOf(

              }
            server.useHttps(serverSslSocketFactory)
          } else if (socketMode == Channel) {
            socketFactory(ChannelSocketFactory())
          }
        }.build()

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

    @Suppress("HttpUrlsUsage")
    val url =
      if (socketMode is TlsInstance) {
        "https://$hostname:${server.port}/get"
      } else {