throw e
      }

      val tookMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)

      val responseBody = response.body!!
      val contentLength = responseBody.contentLength()
      val bodySize = if (contentLength != -1L) "$contentLength-byte" else "unknown-length"
      logger.log(
        buildString {
          append("<-- ${response.code}")

    val closed = AtomicBoolean()
    val body: ResponseBody =
      object : ResponseBody() {
        override fun contentType(): MediaType? {
          return null
        }

        override fun contentLength(): Long {
          return 5
        }

        override fun source(): BufferedSource {
          val source = Buffer().writeUtf8("hello")
          return object : ForwardingSource(source) {

   * by malformed content types.
   */
  private val contentTypeString: String?,
  private val contentLength: Long,
  private val source: BufferedSource,
) : ResponseBody() {
  override fun contentLength(): Long = contentLength

  override fun contentType(): MediaType? = contentTypeString?.toMediaTypeOrNull()

  override fun source(): BufferedSource = source

      !response.promisesBody() -> newFixedLengthSource(0)
      response.isChunked -> newChunkedSource(response.request.url)
      else -> {
        val contentLength = response.headersContentLength()
        if (contentLength != -1L) {
          newFixedLengthSource(contentLength)
        } else {
          newUnknownLengthSource()
        }
      }
    }
  }

  override fun trailers(): Headers {

  ) {
    filePath = tempDir.toOkioPath() / "file.txt"
  }

  @Test
  fun testFileDescriptor() {
    assertOnFileDescriptor { fd ->
      val requestBody = fd.toRequestBody()

      assertThat(requestBody.contentLength()).isEqualTo(-1L)
      assertThat(requestBody.isOneShot()).isEqualTo(true)
    }
  }

  @Test
  fun testFileDescriptorRead() {
    assertOnFileDescriptor(content = "Hello") { fd ->

    server.enqueue(MockResponse())
    val contentLength = Int.MAX_VALUE + 1L
    val response =
      getResponse(
        Request(
          url = server.url("/"),
          body =
            object : RequestBody() {
              override fun contentType(): MediaType? = null

              override fun contentLength(): Long = contentLength

              override fun writeTo(sink: BufferedSink) {

    assertThat(body.contentType().toString())
      .isEqualTo("multipart/mixed; boundary=123")
    assertThat(body.parts.size).isEqualTo(1)
    assertThat(body.contentLength()).isEqualTo(33L)
    val buffer = Buffer()
    body.writeTo(buffer)
    assertThat(body.contentLength()).isEqualTo(buffer.size)
    assertThat(buffer.readUtf8()).isEqualTo(expected)
  }

  @Test
  fun threeParts() {
    val expected =
      """

      val contentLength = responseHeaders["Content-Length"]
      val cacheRequest = Request(url, varyHeaders, requestMethod)
      return Response.Builder()
        .request(cacheRequest)
        .protocol(protocol)
        .code(code)
        .message(message)
        .headers(responseHeaders)
        .body(CacheResponseBody(snapshot, contentType, contentLength))
        .handshake(handshake)

      }

      // We can't measure the body's size without the sizes of its components.
      val contentLength = body.contentLength()
      if (contentLength == -1L && countBytes) {
        byteCountBuffer!!.clear()
        return -1L
      }

      sink.write(CRLF)

      if (countBytes) {
        byteCount += contentLength
      } else {
        body.writeTo(sink)
      }

      sink.write(CRLF)
    }

  sizeMapper: (T) -> Int,
): T {
  val contentLength = contentLength()
  if (contentLength > Int.MAX_VALUE) {
    throw IOException("Cannot buffer entire body for content length: $contentLength")
  }

  val bytes = source().use(consumer)
  val size = sizeMapper(bytes)
  if (contentLength != -1L && contentLength != size.toLong()) {
    throw IOException("Content-Length ($contentLength) and stream length ($size) disagree")
  }