}

  override fun requestBodyStart(call: Call) {
    logWithTime("requestBodyStart")
  }

  override fun requestBodyEnd(
    call: Call,
    byteCount: Long,
  ) {
    logWithTime("requestBodyEnd: byteCount=$byteCount")
  }

  override fun requestFailed(
    call: Call,
    ioe: IOException,
  ) {
    logWithTime("requestFailed: $ioe")
  }

  private val fileChannel: FileChannel,
) {
  /** Write [byteCount] bytes from [source] to the file at [pos]. */
  @Throws(IOException::class)
  fun write(
    pos: Long,
    source: Buffer,
    byteCount: Long,
  ) {
    if (byteCount < 0L || byteCount > source.size) {
      throw IndexOutOfBoundsException()
    }
    var mutablePos = pos
    var mutableByteCount = byteCount

    while (mutableByteCount > 0L) {

    logWithTime("requestBodyStart")

    delegate.requestBodyStart(call)
  }

  override fun requestBodyEnd(
    call: Call,
    byteCount: Long,
  ) {
    logWithTime("requestBodyEnd: byteCount=$byteCount")

    delegate.requestBodyEnd(call, byteCount)
  }

  override fun requestFailed(
    call: Call,
    ioe: IOException,
  ) {
    logWithTime("requestFailed: $ioe")

    object : ForwardingSink(sink) {
      @Throws(IOException::class)
      override fun write(
        source: Buffer,
        byteCount: Long,
      ) {
        val bytes = source.readByteString(byteCount)
        delegate.write(
          Buffer()
            .write(bytes.toAsciiUppercase()),
          byteCount,
        )
      }
    }

    override fun write(
      source: Buffer,
      byteCount: Long,
    ) {
      check(!closed) { "closed" }
      if (contentLength != -1L && bytesReceived + byteCount > contentLength) {
        throw ProtocolException(
          "expected $contentLength bytes but received ${bytesReceived + byteCount}",
        )
      }
      try {
        super.write(source, byteCount)
        this.bytesReceived += byteCount

    request: Request,
  ) = logEvent(RequestHeadersEnd(System.nanoTime(), call, request.headers.byteCount()))

  override fun requestBodyStart(call: Call) = logEvent(RequestBodyStart(System.nanoTime(), call))

  override fun requestBodyEnd(
    call: Call,
    byteCount: Long,
  ) = logEvent(RequestBodyEnd(System.nanoTime(), call, byteCount))

  override fun requestFailed(
    call: Call,
    ioe: IOException,

import okhttp3.Headers.Companion.toHeaders
import org.junit.jupiter.api.Test

class HeadersJvmTest {
  @Test fun byteCount() {
    assertThat(Headers.EMPTY.byteCount()).isEqualTo(0L)
    assertThat(
      Headers
        .Builder()
        .add("abc", "def")
        .build()
        .byteCount(),
    ).isEqualTo(10L)
    assertThat(
      Headers
        .Builder()
        .add("abc", "def")

) : Sink by delegate {
  private var bytesWritten = 0L

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    if (byteCount == 0L) return // Avoid double-triggering.

    if (bytesWritten == triggerByteCount) {
      source.skip(byteCount)
      return
    }

    val toWrite = minOf(byteCount, triggerByteCount - bytesWritten)
    bytesWritten += toWrite

    delegate.write(source, toWrite)

      }

      override fun read(
        sink: Buffer,
        byteCount: Long,
      ): Long {
        require(byteCount >= 0L) { "byteCount < 0: $byteCount" }
        check(currentPart == this) { "closed" }

        return source.timeout().intersectWith(timeout) {
          when (val limit = currentPartBytesRemaining(maxByteCount = byteCount)) {
            0L -> -1L // No more bytes in this part.

01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] responseBodyStart
01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] responseBodyEnd: byteCount=128
01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] connectionReleased
01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] callEnd
01-01 12:53:32.816 10999 11090 D OkHttp  : [54 ms] responseHeadersStart