System.out.println("Response 2 cache response:    " + response2.cacheResponse());
      System.out.println("Response 2 network response:  " + response2.networkResponse());
    }

    System.out.println("Response 2 equals Response 1? " + response1Body.equals(response2Body));
  }

  public static void main(String... args) throws Exception {
    new CacheResponse(new File("CacheResponse.tmp")).run();
  }

        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() {
  CacheResponse(File("CacheResponse.tmp")).run()

  fun assertNoCacheResponse() =
    apply {
      assertThat(response!!.cacheResponse).isNull()
    }

  /**
   * Asserts that the current response used the cache and returns the cache response.
   */
  fun cacheResponse(): RecordedResponse {
    val cacheResponse = response!!.cacheResponse!!
    return RecordedResponse(cacheResponse.request, cacheResponse, null, null, null)
  }

        checkSupportResponse("networkResponse", networkResponse)
        this.networkResponse = networkResponse
      }

    open fun cacheResponse(cacheResponse: Response?) =
      apply {
        checkSupportResponse("cacheResponse", cacheResponse)
        this.cacheResponse = cacheResponse
      }

    private fun checkSupportResponse(
      name: String,
      response: Response?,
    ) {
      response?.apply {

    if (networkRequest == null) {
      return cacheResponse!!
        .newBuilder()
        .cacheResponse(cacheResponse.stripBody())
        .build()
        .also {
          listener.cacheHit(call, it)
        }
    }

    if (cacheResponse != null) {
      listener.cacheConditionalHit(call, cacheResponse)
    } else if (cache != null) {
      listener.cacheMiss(call)
    }

     */
    private fun isFreshnessLifetimeHeuristic(): Boolean = cacheResponse!!.cacheControl.maxAgeSeconds == -1 && expires == null

    init {
      if (cacheResponse != null) {
        this.sentRequestMillis = cacheResponse.sentRequestAtMillis
        this.receivedResponseMillis = cacheResponse.receivedResponseAtMillis
        val headers = cacheResponse.headers
        for (i in 0 until headers.size) {

 [CacheResponseJava]: https://github.com/square/okhttp/blob/master/samples/guide/src/main/java/okhttp3/recipes/CacheResponse.java
 [CacheResponseKotlin]: https://github.com/square/okhttp/blob/master/samples/guide/src/main/java/okhttp3/recipes/kt/CacheResponse.kt
 [CancelCallJava]: https://github.com/square/okhttp/blob/master/samples/guide/src/main/java/okhttp3/recipes/CancelCall.java

    call.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.cacheResponse).isNull()
    }

    val cachedCall = client.newCall(request)

    cachedCall.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.cacheResponse).isNotNull()
    }
  }

  @Test
  open fun testPublicSuffixDb() {

received followed by a cache hit or miss.  Critically in the cache hit scenario the server won’t send the response body.

The response will have non-null `cacheResponse` and `networkResponse`. The cacheResponse will be used as the top level
response only if the response code is HTTP/1.1 304 Not Modified.
 
 - CallStart
 - **CacheConditionalHit**
 - ConnectionAcquired
 - ... Standard Events...

    val headers: Headers = response.headers()
    val body: ResponseBody = response.body()
    val networkResponse: Response? = response.networkResponse()
    val cacheResponse: Response? = response.cacheResponse()
    val priorResponse: Response? = response.priorResponse()
    val cacheControl: CacheControl = response.cacheControl()
    val sentRequestAtMillis: Long = response.sentRequestAtMillis()