val bytesToRead = minOf(byteCount, upstreamPos - sourcePos)
          buffer.copyTo(sink, sourcePos - bufferPos, bytesToRead)
          sourcePos += bytesToRead
          return bytesToRead
        }

      // Read from the file.
      if (source == SOURCE_FILE) {
        val bytesToRead = minOf(byteCount, upstreamPos - sourcePos)

      byteCount: Long,
    ): Long {
      require(byteCount >= 0L) { "byteCount < 0: $byteCount" }
      check(!closed) { "closed" }
      if (bytesRemaining == 0L) return -1

      val read = super.read(sink, minOf(bytesRemaining, byteCount))
      if (read == -1L) {
        carrier.noNewExchanges() // The server didn't supply the promised content length.
        val e = ProtocolException("unexpected end of stream")

    requestHeaders: List<Header>,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      hpackWriter.writeHeaders(requestHeaders)

      val byteCount = hpackBuffer.size
      val length = minOf(maxFrameSize - 4L, byteCount).toInt()
      frameHeader(
        streamId = streamId,
        length = length + 4,
        type = TYPE_PUSH_PROMISE,

      val ageMillis = cacheResponseAge()
      var freshMillis = computeFreshnessLifetime()

      if (requestCaching.maxAgeSeconds != -1) {
        freshMillis = minOf(freshMillis, SECONDS.toMillis(requestCaching.maxAgeSeconds.toLong()))
      }

      var minFreshMillis: Long = 0
      if (requestCaching.minFreshSeconds != -1) {

        val effectiveHeaderTableSize = minOf(headerTableSizeSetting, SETTINGS_HEADER_TABLE_SIZE_LIMIT)

        if (maxDynamicTableByteCount == effectiveHeaderTableSize) return // No change.

        if (effectiveHeaderTableSize < maxDynamicTableByteCount) {
          smallestHeaderTableSizeSetting =
            minOf(smallestHeaderTableSizeSetting, effectiveHeaderTableSize)
        }

            } else if (readBuffer.size > 0L) {
              // Prepare to read bytes. Start by moving them to the caller's buffer.
              readBytesDelivered = readBuffer.read(sink, minOf(byteCount, readBuffer.size))
              readBytes.update(total = readBytesDelivered)

              val unacknowledgedBytesRead = readBytes.unacknowledged
              if (errorExceptionToDeliver == null &&

        padding = 0
        if (flags and FLAG_END_HEADERS != 0) return -1L
        readContinuationHeader()
        // TODO: test case for empty continuation header?
      }

      val read = source.read(sink, minOf(byteCount, left.toLong()))
      if (read == -1L) return -1L
      left -= read.toInt()
      return read
    }

    override fun timeout(): Timeout = source.timeout()

    @Throws(IOException::class)

        val candidateDelay = maxOf(0L, candidate.nextExecuteNanoTime - now)

        when {
          // Compute the delay of the soonest-executable task.
          candidateDelay > 0L -> {
            minDelayNanos = minOf(candidateDelay, minDelayNanos)
            continue@eachQueue
          }

          // If we already have more than one task, that's enough work for now. Stop searching.
          readyTask != null -> {

  val originalDurationNs =
    if (timeout().hasDeadline()) {
      timeout().deadlineNanoTime() - nowNs
    } else {
      Long.MAX_VALUE
    }
  timeout().deadlineNanoTime(nowNs + minOf(originalDurationNs, timeUnit.toNanos(duration.toLong())))
  return try {
    val skipBuffer = Buffer()
    while (read(skipBuffer, 8192) != -1L) {
      skipBuffer.clear()
    }

      maxChunkSize: Int,
    ) = apply {
      removeHeader("Content-Length")
      headers.add(CHUNKED_BODY_HEADER)

      val bytesOut = Buffer()
      while (!body.exhausted()) {
        val chunkSize = minOf(body.size, maxChunkSize.toLong())
        bytesOut.writeHexadecimalUnsignedLong(chunkSize)
        bytesOut.writeUtf8("\r\n")
        bytesOut.write(body, chunkSize)
        bytesOut.writeUtf8("\r\n")
      }