}

    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 {

   */
  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) &&

    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)

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

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

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