*/
  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()
    }

    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)

      }

    open fun socket(socket: Socket) =
      apply {
        this.socket = socket
      }

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

    open fun cacheResponse(cacheResponse: Response?) =
      apply {

    }

    val networkRequest = requestBuilder.build()
    val networkResponse = chain.proceed(networkRequest)

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

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

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

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

    String response2Body;
    try (Response response2 = client.newCall(request).execute()) {
      if (!response2.isSuccessful()) throw new IOException("Unexpected code " + response2);

    retry: Boolean,
  ) = onEvent(RetryDecision(System.nanoTime(), call, exception, retry))

  override fun followUpDecision(
    call: Call,
    networkResponse: Response,
    nextRequest: Request?,
  ) = onEvent(FollowUpDecision(System.nanoTime(), call, networkResponse, nextRequest))

   *  * [OkHttpClient.authenticator] must respond to an authorization challenge.
   *
   * @param networkResponse the intermediate response that may require a follow-up request.
   * @param nextRequest the follow-up request that will be made. Null if no follow-up will be made.
   */
  open fun followUpDecision(
    call: Call,
    networkResponse: Response,
    nextRequest: Request?,
  ) {
  }

        // 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()

  override fun retryDecision(
    call: Call,
    exception: IOException,
    retry: Boolean,
  ) {
    logWithTime("retryDecision")
  }

  override fun followUpDecision(
    call: Call,
    networkResponse: Response,
    nextRequest: Request?,
  ) {
    logWithTime("followUpDecision")
  }

  private fun logWithTime(message: String) {
    val startNs = startNs
    val timeMs =

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...