}

    internal constructor(response: Response) {
      this.request = response.request
      this.protocol = response.protocol
      this.code = response.code
      this.message = response.message
      this.handshake = response.handshake
      this.headers = response.headers.newBuilder()
      this.body = response.body
      this.networkResponse = response.networkResponse

        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 {

        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) {

    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.

      }
    }

    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

      }

    /**
     * Adds an HTTP 1xx response to precede this response. Note that this response's
     * [headers delay][headersDelay] applies after this response is transmitted. Set a
     * headers delay on that response to delay its transmission.
     */
    fun addInformationalResponse(response: MockResponse) =
      apply {
        informationalResponses += response
      }

    fun add100Continue() =

 *
 * Both this class and [Response] implement [Closeable]. Closing a response simply
 * closes its response body. If you invoke [Call.execute] or implement [Callback.onResponse] you
 * must close this body by calling any of the following methods:
 *
 * * `Response.close()`
 * * `Response.body().close()`
 * * `Response.body().source().close()`
 * * `Response.body().charStream().close()`
 * * `Response.body().byteStream().close()`

          .build()

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

      response.use {
        assertEquals(Protocol.HTTP_2, response.protocol)
        assertEquals(200, response.code)
        assertEquals("com.google.android.gms.org.conscrypt.Java8FileDescriptorSocket", socketClass)
        assertEquals(TlsVersion.TLS_1_2, response.handshake?.tlsVersion)
      }

  }

  override fun reportedContentLength(response: Response): Long {
    return when {
      !response.promisesBody() -> 0L
      response.isChunked -> -1L
      else -> response.headersContentLength()
    }
  }

  override fun openResponseBodySource(response: Response): Source {
    return when {
      !response.promisesBody() -> newFixedLengthSource(0)
      response.isChunked -> newChunkedSource(response.request.url)

    }
    val request =
      Request.Builder()
        .url(server.url("/"))
        .build()
    val response = client.newCall(request).execute()
    assertThat(response.body.string()).isEqualTo("ABC")
    assertThat(response.header("OkHttp-Intercepted")).isEqualTo("yep")
    assertThat(response.header("Original-Header")).isEqualTo("foo")
  }

  @Test
  fun multipleApplicationInterceptors() {