}
              awaitTaskToRun()
            } ?: return

          logger.logElapsed(task, task.queue!!) {
            var completedNormally = false
            try {
              runTask(task)
              completedNormally = true
            } finally {
              // If the task is crashing start another thread to service the queues.
              if (!completedNormally) {
                lock.withLock {

    taskFaker.runTasks()
    client.listener.assertFailure(IOException::class.java, "source is closed")
    assertThat(client.webSocket!!.send("Hello!")).isFalse()
  }

  @Test
  fun socketClosedDuringMessageKillsWebSocket() {
    client2Server.source.close()
    assertThat(client.webSocket!!.send("Hello!")).isTrue()
    taskFaker.runTasks()

    plan0.connectState = TLS_CONNECTED

    taskRunner.newQueue().execute("connect") {
      val result0 = finder.find()
      assertThat(result0).isEqualTo(plan0.connection)
    }

    taskFaker.runTasks()
    assertEvents(
      "take plan 0",
    )

    taskFaker.assertNoMoreTasks()
  }

  @Test
  fun takeConnectingConnection() {
    val plan0 = routePlanner.addPlan()

 * 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:
 *

    address: Address,
    policy: ConnectionPool.AddressPolicy,
  ) {
    pool.setPolicy(address, policy)
    taskFaker.runTasks()
  }

  private fun evictAllConnections(pool: RealConnectionPool) {
    pool.evictAll()
    assertThat(pool.connectionCount()).isEqualTo(0)
    taskFaker.runTasks()
  }

  private fun forceConnectionsToExpire(
    pool: RealConnectionPool,
    expireTime: Long,
  ) {

      readControlFrame()
    }
  }

  /**
   * Reads a message body into across one or more frames. Control frames that occur between
   * fragments will be processed. If the message payload is masked this will unmask as it's being
   * processed.
   */
  @Throws(IOException::class)
  private fun readMessage() {
    while (true) {
      if (closed) throw IOException("closed")

      if (frameLength > 0L) {

    blueQueue.execute("blue task", 200.µs) {
      log += "blue:run@${taskFaker.nanoTime}"
    }
    assertThat(taskFaker.executeCallCount).isEqualTo(1)

    // Nothing to do.
    taskFaker.runTasks()
    assertThat(log).isEmpty()

    // At 100.µs, the coordinator runs the red task and starts a thread for the new coordinator.
    taskFaker.advanceUntil(100.µs)
    assertThat(log).containsExactly("red:run@100000")