}

  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)

        println("Response 2 response:          $it")
        println("Response 2 cache response:    ${it.cacheResponse}")
        println("Response 2 network response:  ${it.networkResponse}")
        return@use it.body.string()
      }

    println("Response 2 equals Response 1? " + (response1Body == response2Body))
  }
}

fun main() {

    val webSocket: WebSocket,
    val response: Response,
  )

  internal class Failure(
    val t: Throwable,
    val response: Response?,
  ) {
    val responseBody: String? =
      when {
        response != null && response.code != 101 -> response.body.string()
        else -> null
      }

    override fun toString(): String {
      return when (response) {
        null -> "Failure[$t]"

        .build()
    val response1 = client.newCall(request).execute()
    response1.body.close()
    assertThat(response1.header("X-Response-ID")).isEqualTo("1")
    val response2 = get(url)
    response2.body.close()
    if (expectCached) {
      assertThat(response2.header("X-Response-ID")).isEqualTo("1")
    } else {
      assertThat(response2.header("X-Response-ID")).isEqualTo("2")
    }
  }

## Rewriting Responses

If transparent compression was used, OkHttp will drop the corresponding response headers `Content-Encoding` and `Content-Length` because they don’t apply to the decompressed response body.

If a conditional GET was successful, responses from the network and cache are merged as directed by the spec.

## Follow-up Requests

        "Mock Response",
      )
    for (i in 0..599) {
      val response = MockResponse().setResponseCode(i)
      val expectedReason = reasons[i / 100]
      assertThat(response.status).isEqualTo("HTTP/1.1 $i $expectedReason")
      assertThat(headersToList(response)).containsExactly("Content-Length: 0")
    }
  }

  @Test
  fun setStatusControlsWholeStatusLine() {

  @Test
  fun testOkHttpDirect() {
    testRequest {
      val client = OkHttpClient()

      val response =
        client.newCall(
          Request((mockServer.endpoint + "/person?name=peter").toHttpUrl()),
        ).execute()

      assertThat(response.body.string()).contains("Peter the person")
      assertThat(response.protocol).isEqualTo(Protocol.HTTP_1_1)
    }
  }

  @Test
  fun testOkHttpProxied() {

        }
      }
    val request =
      request()
        .post(asyncRequestBody)
        .build()
    val response = client.newCall(request).execute()
    Assumptions.assumeTrue(response.protocol == Protocol.HTTP_2)
    assertThat(response.body.string()).isEqualTo("Hello response!")
    applicationLogs
      .assertLogEqual("--> POST $url")
      .assertLogEqual("--> END POST (duplex request body omitted)")

      } else {
        append("HTTP/1.1")
      }
      append(' ').append(code)
      append(' ').append(message)
    }
  }

  companion object {
    fun get(response: Response): StatusLine {
      return StatusLine(response.protocol, response.code, response.message)
    }

    @Throws(IOException::class)
    fun parse(statusLine: String): StatusLine {
      // H T T P / 1 . 1   2 0 0   T e m p o r a r y   R e d i r e c t

    /** Don't accept an unvalidated cached response. */
    fun noCache() = commonNoCache()

    /** Don't store the server's response in any cache. */
    fun noStore() = commonNoStore()

    /**
     * Only accept the response if it is in the cache. If the response isn't cached, a `504
     * Unsatisfiable Request` response will be returned.
     */
    fun onlyIfCached() = commonOnlyIfCached()