apply {
        this.sentRequestAtMillis = sentRequestAtMillis
      }

    open fun receivedResponseAtMillis(receivedResponseAtMillis: Long) =
      apply {
        this.receivedResponseAtMillis = receivedResponseAtMillis
      }

    internal fun initExchange(exchange: Exchange) {
      this.exchange = exchange
    }

    open fun build(): Response {

            .newBuilder()
            .headers(combine(cacheResponse.headers, networkResponse.headers))
            .sentRequestAtMillis(networkResponse.sentRequestAtMillis)
            .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis)
            .cacheResponse(cacheResponse.stripBody())
            .networkResponse(networkResponse.stripBody())
            .build()

        networkResponse.body.close()

      }
      var response =
        responseBuilder
          .request(request)
          .handshake(exchange.connection.handshake())
          .sentRequestAtMillis(sentRequestMillis)
          .receivedResponseAtMillis(System.currentTimeMillis())
          .build()
      var code = response.code

      while (shouldIgnoreAndWaitForRealResponse(code)) {

  }

  fun assertReceivedResponseAtMillis(
    minimum: Long,
    maximum: Long,
  ) = apply {
    assertDateInRange(minimum, response!!.receivedResponseAtMillis, maximum)
  }

  private fun assertDateInRange(
    minimum: Long,
    actual: Long,
    maximum: Long,
  ) {

    val priorResponse: Response? = response.priorResponse()
    val cacheControl: CacheControl = response.cacheControl()
    val sentRequestAtMillis: Long = response.sentRequestAtMillis()
    val receivedResponseAtMillis: Long = response.receivedResponseAtMillis()
  }

  @Test @Disabled
  fun route() {
    val route: Route = factory.newRoute()
    val address: Address = route.address()
    val proxy: Proxy = route.proxy()

        .request(proxyConnectRequest)
        .protocol(Protocol.HTTP_1_1)
        .code(HttpURLConnection.HTTP_PROXY_AUTH)
        .message("Preemptive Authenticate")
        .sentRequestAtMillis(-1L)
        .receivedResponseAtMillis(-1L)
        .header("Proxy-Authenticate", "OkHttp-Preemptive")
        .build()

    val authenticatedRequest =
      route.address.proxyAuthenticator

 * **Request**: body, cacheControl, headers, method, url
 * **Response**: body, cacheControl, cacheResponse, code, handshake, headers, message,
   networkResponse, priorResponse, protocol, receivedResponseAtMillis, request, sentRequestAtMillis
 * **Route**: address, proxy, socketAddress
 * **TlsVersion**: javaName

#### Renamed Functions

      this.responseHeaders = response.headers
      this.handshake = response.handshake
      this.sentRequestMillis = response.sentRequestAtMillis
      this.receivedResponseMillis = response.receivedResponseAtMillis
    }

    @Throws(IOException::class)
    fun writeTo(editor: DiskLruCache.Editor) {
      editor.newSink(ENTRY_METADATA).buffer().use { sink ->
        sink.writeUtf8(url.toString()).writeByte('\n'.code)

    val challenges: List<Challenge> = response.challenges()
    val cacheControl: CacheControl = response.cacheControl
    val sentRequestAtMillis: Long = response.sentRequestAtMillis
    val receivedResponseAtMillis: Long = response.receivedResponseAtMillis
  }

  @Test
  fun responseBuilder() {
    var builder: Response.Builder = Response.Builder()
    builder = builder.request(Request.Builder().build())

    val t0 = System.currentTimeMillis()
    val response1 = get(server.url("/a"))
    assertThat(response1.body.string()).isEqualTo("A")
    assertThat(response1.header("Allow")).isNull()
    assertThat((response1.receivedResponseAtMillis - t0).toDouble()).isCloseTo(0.0, 250.0)

    // A conditional cache hit updates the cache.
    Thread.sleep(500) // Make sure t0 and t1 are distinct.
    val t1 = System.currentTimeMillis()