override fun contentLength(): Long {
        return if (chunked) -1L else size
      }

      override fun writeTo(sink: BufferedSink) {
        var count = 0
        while (count < size) {
          sink.write(buffer, 0, Math.min(size - count, writeSize.toLong()).toInt())
          count += writeSize
        }
      }
    }
  }

  @Test

 * deterministic.
 *
 * This class ensures that at most one thread is running at a time. This is initially the JUnit test
 * thread, which yields its execution privilege while calling [runTasks], [runNextTask], or
 * [advanceUntil]. These functions don't return until the task threads are all idle.
 *
 * Task threads release their execution privilege in these ways:
 *

  private val readyQueues = mutableListOf<TaskQueue>()

  private val runnable: Runnable =
    object : Runnable {
      override fun run() {
        var incrementedRunCallCount = false
        while (true) {
          val task =
            ******@****.***ck {
              if (!incrementedRunCallCount) {
                incrementedRunCallCount = true
                runCallCount++
              }

  @Throws(IOException::class)
  operator fun next(): Selection {
    if (!hasNext()) throw NoSuchElementException()

    // Compute the next set of routes to attempt.
    val routes = mutableListOf<Route>()
    while (hasNextProxy()) {
      // Postponed routes are always tried last. For example, if we have 2 proxies and all the
      // routes for proxy1 should be postponed, we'll move to proxy2. Only after we've exhausted

  }

  /** Wait for the client to receive `dataLength` DATA frames.  */
  private fun waitForDataFrames(dataLength: Int) {
    val expectedFrameCount = dataLength / 16384
    var dataFrameCount = 0
    while (dataFrameCount < expectedFrameCount) {
      val log = testLogHandler.take()
      if (log == "FINE: << 0x00000003 16384 DATA          ") {
        dataFrameCount++
      }
    }
  }

  @ParameterizedTest

      sink.close()
    }
  }

  @Throws(IOException::class)
  private fun writeContinuationFrames(
    streamId: Int,
    byteCount: Long,
  ) {
    var byteCount = byteCount
    while (byteCount > 0L) {
      val length = minOf(maxFrameSize.toLong(), byteCount)
      byteCount -= length
      frameHeader(
        streamId = streamId,
        length = length.toInt(),

    routePlanner.autoGeneratePlans = true
    val address = routePlanner.address
    val pool = routePlanner.pool

    // Add a connection to the pool that won't expire for a while
    routePlanner.defaultConnectionIdleAtNanos = expireLater
    setPolicy(pool, address, ConnectionPool.AddressPolicy(1))
    assertThat(pool.connectionCount()).isEqualTo(1)

    clientListener.assertOpen()

    // Send messages until the client's outgoing buffer overflows!
    val message: ByteString = ByteString.of(*ByteArray(1024 * 1024))
    var messageCount: Long = 0
    while (true) {
      val success = webSocket.send(message)
      if (!success) break
      messageCount++
      val queueSize = webSocket.queueSize()
      assertThat(queueSize).isBetween(0L, messageCount * message.size)

    set("a", "a", "a")
    set("b", "b", "b")
    while (taskFaker.isIdle()) {
      assertValue("a", "a", "a")
      assertValue("b", "b", "b")
    }
  }

  @ParameterizedTest
  @ArgumentsSource(FileSystemParamProvider::class)
  fun rebuildJournalOnRepeatedEdits(parameters: Pair<FileSystem, Boolean>) {
    setUp(parameters.first, parameters.second)
    while (taskFaker.isIdle()) {
      set("a", "a", "a")

    if (byteCount == 0L) {
      writer.data(outFinished, streamId, buffer, 0)
      return
    }

    var byteCount = byteCount
    while (byteCount > 0L) {
      var toWrite: Int
      this.withLock {
        try {
          while (writeBytesTotal >= writeBytesMaximum) {
            // Before blocking, confirm that the stream we're writing is still open. It's possible