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

    }

    val networkRequest = requestBuilder.build()
    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) &&

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

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

private fun sendRequest(
  url: String,
  client: OkHttpClient,
) {
  val req = Request.Builder().url(url).build()

  client.newCall(req).execute().use {
    println(url)
    println("""Content-Encoding: ${it.networkResponse?.header("Content-Encoding")}""")
    println("| ${it.body.string().replace("\n", "\n| ")}")
  }

    delegate.retryDecision(call, exception, retry)
  }

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

    delegate.followUpDecision(call, networkResponse, nextRequest)
  }

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

    Request request = new Request.Builder()
        .url(url)
        .build();
    try (Response response = client.newCall(request).execute()) {
      String responseSource = response.networkResponse() != null ? ("(network: "
          + response.networkResponse().code()
          + " over "
          + response.protocol()
          + ")") : "(cache)";
      int responseCode = response.code();

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

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

    byteCount: Long,
  ): Long =
    throw IllegalStateException(
      """
      |Unreadable ResponseBody! These Response objects have bodies that are stripped:
      | * Response.cacheResponse
      | * Response.networkResponse
      | * Response.priorResponse
      | * EventSourceListener
      | * WebSocketListener
      |(It is safe to call contentType() and contentLength() on these response bodies.)
      """.trimMargin(),
    )

      try (Response response = clientForCall.newCall(request).execute()) {
        if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

        System.out.println("    Network: " + (response.networkResponse() != null));
        System.out.println();
      }
    }
  }

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