if (cacheResponse != null) {
      if (networkResponse?.code == HTTP_NOT_MODIFIED) {
        val response =
          cacheResponse.newBuilder()
            .headers(combine(cacheResponse.headers, networkResponse.headers))
            .sentRequestAtMillis(networkResponse.sentRequestAtMillis)
            .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis)

    val networkResponse = chain.proceed(networkRequest)

    cookieJar.receiveHeaders(networkRequest.url, networkResponse.headers)

    val responseBuilder =
      networkResponse.newBuilder()
        .request(networkRequest)

    if (transparentGzip &&
      "gzip".equals(networkResponse.header("Content-Encoding"), ignoreCase = true) &&
      networkResponse.promisesBody()
    ) {

fun Response.Builder.commonBody(body: ResponseBody) =
  apply {
    this.body = body
  }

fun Response.Builder.commonNetworkResponse(networkResponse: Response?) =
  apply {
    checkSupportResponse("networkResponse", networkResponse)
    this.networkResponse = networkResponse
  }

fun Response.Builder.commonCacheResponse(cacheResponse: Response?) =
  apply {
    checkSupportResponse("cacheResponse", cacheResponse)

  @JvmName("-deprecated_networkResponse")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "networkResponse"),
    level = DeprecationLevel.ERROR,
  )
  fun networkResponse(): Response? = networkResponse

  @JvmName("-deprecated_cacheResponse")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "cacheResponse"),

   */
  fun networkResponse(): RecordedResponse {
    val networkResponse = response!!.networkResponse!!
    return RecordedResponse(networkResponse.request, networkResponse, null, null, null)
  }

  /** Asserts that the current response didn't use the network.  */
  fun assertNoNetworkResponse() =
    apply {
      assertThat(response!!.networkResponse).isNull()
    }

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

    val response2Body =
      client.newCall(request).execute().use {
        if (!it.isSuccessful) throw IOException("Unexpected code $it")

        // The network response also has everything, including the raw gzipped content.
        val networkResponse = chain.proceed(networkRequest)
        assertThat(networkResponse.header("Content-Encoding")).isEqualTo("gzip")
        networkResponse
      }
    client =
      client.newBuilder()
        .addNetworkInterceptor(interceptor)
        .build()
    val request =

    val message: String = response.message()
    val handshake: Handshake? = response.handshake()
    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 body: ResponseBody = response.body
    val builder: Response.Builder = response.newBuilder()
    val redirect: Boolean = response.isRedirect
    val networkResponse: Response? = response.networkResponse
    val cacheResponse: Response? = response.cacheResponse
    val priorResponse: Response? = response.priorResponse
    val challenges: List<Challenge> = response.challenges()

          assertNotNull(it.networkResponse)

          assertEquals(3, it.cacheControl.maxAgeSeconds)
          assertTrue(it.cacheControl.isPublic)
        }

      client.newCall(request)
        .execute()
        .use {
          assertEquals(200, it.code)
          assertNotNull(it.cacheResponse)
          assertNull(it.networkResponse)
        }