cleanupQueue.schedule(cleanupTask)
    }

    return true
  }

  @Synchronized private fun checkNotClosed() {
    check(!closed) { "cache is closed" }
  }

  /** Force buffered operations to the filesystem. */
  @Synchronized
  @Throws(IOException::class)
  override fun flush() {
    if (!initialized) return

    checkNotClosed()
    trimToSize()
    journalWriter!!.flush()

    val recordedRequest = server.takeRequest()
    assertThat(recordedRequest.headers[":authority"]).isEqualTo("privateobject.com")
  }

  private fun gzip(bytes: String): Buffer {
    val bytesOut = Buffer()
    val sink = GzipSink(bytesOut).buffer()
    sink.writeUtf8(bytes)
    sink.close()
    return bytesOut
  }

  internal inner class AsyncRequest(
    val path: String,

      else -> "MockWebServer{new}"
    }
  }

  /** A buffer wrapper that drops data after [bodyLimit] bytes. */
  private class TruncatingBuffer(
    private var remainingByteCount: Long,
  ) : Sink {
    val buffer = Buffer()
    var receivedByteCount = 0L

    @Throws(IOException::class)
    override fun write(
      source: Buffer,
      byteCount: Long,
    ) {

    int initialBufferSize = min(BUFFER_SIZE, max(128, Integer.highestOneBit(totalLen) * 2));
    // Starting with an 8k buffer, double the size of each successive buffer. Smaller buffers
    // quadruple in size until they reach 8k, to minimize the number of small reads for longer
    // streams. Buffers are retained in a deque so that there's no copying between buffers while

   *
   * @throws IOException if an I/O error occurs while opening the stream
   */
  public abstract InputStream openStream() throws IOException;

  /**
   * Opens a new buffered {@link InputStream} for reading from this source. The returned stream is
   * not required to be a {@link BufferedInputStream} in order to allow implementations to simply

  fun contentDisagreesWithChunkedHeaderBodyTooLong() {
    val builder =
      MockResponse
        .Builder()
        .chunkedBody("abc", 3)
    val buffer = Buffer()
    builder.body!!.writeTo(buffer)
    buffer.writeUtf8("\r\nYOU SHOULD NOT SEE THIS")
    builder.body(buffer)
    builder.clearHeaders()
    builder.addHeader("Transfer-encoding: chunked")
    server.enqueue(builder.build())

Here we `POST` a request body as a stream. The content of this request body is being generated as it's being written. This example streams directly into the [Okio](https://github.com/square/okio) buffered sink. Your programs may prefer an `OutputStream`, which you can get from `BufferedSink.outputStream()`.

=== ":material-language-kotlin: Kotlin"
    ```kotlin
      private val client = OkHttpClient()

import okhttp3.TestUtil.headerEntries
import okio.Buffer
import okio.ByteString
import okio.ByteString.Companion.decodeHex
import okio.ByteString.Companion.encodeUtf8
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test

class HpackTest {
  private val bytesIn = Buffer()
  private var hpackReader: Hpack.Reader? = null
  private val bytesOut = Buffer()
  private var hpackWriter: Hpack.Writer? = null

    assertThat(stream.readBytes.total).isEqualTo(0L)
    assertThat(stream.takeHeaders()).isEqualTo(headersOf("a", "android"))
    val source = stream.source
    val buffer = Buffer()
    buffer.writeAll(source)
    assertThat(source.read(buffer, 1)).isEqualTo(-1)
    assertThat(buffer.size).isEqualTo(150)
    val synStream = peer.takeFrame()
    assertThat(synStream.type).isEqualTo(Http2.TYPE_HEADERS)
    for (i in 0..2) {

    val buffer = Buffer()
    operator.read(6, buffer, 21)
    operator.read(36, buffer, 1)
    operator.read(5, buffer, 5)
    operator.read(28, buffer, 8)
    operator.read(17, buffer, 10)
    operator.read(36, buffer, 2)
    operator.read(2, buffer, 4)
    operator.write(0, buffer, buffer.size)
    operator.read(0, buffer, 12)
    operator.read(47, buffer, 3)
    operator.read(45, buffer, 2)
    operator.read(47, buffer, 3)