writeTimeoutMillis = client.writeTimeoutMillis,
      )

    var calledNoMoreExchanges = false
    try {
      val response = chain.proceed(originalRequest)
      if (isCanceled()) {
        response.closeQuietly()
        throw IOException("Canceled")
      }
      return response
    } catch (e: IOException) {
      calledNoMoreExchanges = true
      throw noMoreExchanges(e) as Throwable
    } finally {

          e: IOException,
        ) {
          continuation.resumeWithException(e)
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          continuation.resume(response) {
            response.closeQuietly()
          }
        }
      },
    )

        buildString {
          append("<-- ${response.code}")
          if (response.message.isNotEmpty()) append(" ${response.message}")
          append(" ${redactUrl(response.request.url)} (${tookMs}ms")
          if (!logHeaders) append(", $bodySize body")
          append(")")
        },
      )

      if (logHeaders) {
        val headers = response.headers
        for (i in 0 until headers.size) {

        connect(callFactory)
      }
    }
  }

  @JvmStatic
  fun processResponse(
    response: Response,
    listener: EventSourceListener,
  ) {
    val eventSource = RealEventSource(response.request, listener)
    eventSource.processResponse(response)
  }

    proxy selection process.
 *  New: `Response.byteString()` reads the entire response into memory as a byte string.
 *  New: `OkHttpClient.x509TrustManager` accessor.
 *  New: Permit [new WebSocket response codes][iana_websocket]: 1012 (Service Restart), 1013 (Try
    Again Later), and 1014 (invalid response from the upstream).
 *  New: Build with Kotlin 1.3.41, BouncyCastle 1.62, and Conscrypt 2.2.1.

            .withQueryStringParameter("name", "peter"),
        )
        .respond(response().withBody("Peter the person!"))

      val client =
        OkHttpClient.Builder()
          .proxy(Proxy(SOCKS, InetSocketAddress(socks5Proxy.host, socks5Proxy.firstMappedPort)))
          .build()

      val response =
        client.newCall(
          Request("http://mockserver:1080/person?name=peter".toHttpUrl()),

    writeOutputFile(importResults)
  }

  private suspend fun updateLocalFile() =
    withContext(Dispatchers.IO) {
      client.newCall(request).executeAsync().use { response ->
        fileSystem.sink(publicSuffixListDotDat).buffer().use { sink ->
          sink.writeAll(response.body.source())
        }
      }
    }

  private suspend fun readImportResults(): ImportResults =
    withContext(Dispatchers.IO) {

    val response = call.execute()

    // Body contains nothing.
    assertThat(response.body.bytes().size).isEqualTo(0)
    assertThat(response.body.contentLength()).isEqualTo(0)

    // Content-Length header doesn't exist in a 204 response.
    assertThat(response.header("content-length")).isNull()
    assertThat(response.code).isEqualTo(204)
    val request = server.takeRequest()

    server.enqueue(MockResponse(body = "response that will never be received"))
    val response = executeSynchronously("/")
    response.assertFailure(
      // JDK 11 response to the FAIL_HANDSHAKE:
      SSLException::class.java,
      // RI response to the FAIL_HANDSHAKE:
      SSLProtocolException::class.java,
      // Android's response to the FAIL_HANDSHAKE:
      SSLHandshakeException::class.java,

      }
    }

    constructor(response: Response) {
      this.url = response.request.url
      this.varyHeaders = response.varyHeaders()
      this.requestMethod = response.request.method
      this.protocol = response.protocol
      this.code = response.code
      this.message = response.message
      this.responseHeaders = response.headers
      this.handshake = response.handshake