*
   * @param eventClass a class to assert that the returned event is an instance of, or null to
   *     take any event class.
   * @param elapsedMs the time in milliseconds elapsed since the immediately-preceding event, or
   *     -1L to take any duration.
   */
  fun takeEvent(
    eventClass: Class<out ConnectionEvent>? = null,
    elapsedMs: Long = -1L,
  ): ConnectionEvent {

    fullBuffer.read(bytesOut, lastFrame.start + length)
    outFrames.add(OutFrame(lastFrame.sequence, lastFrame.start, true))
    return writer
  }

  fun takeFrame(): InFrame = inFrames.take()

  fun play() {
    check(serverSocket == null)
    serverSocket = ServerSocket()
    serverSocket!!.reuseAddress = false
    serverSocket!!.bind(InetSocketAddress("localhost", 0), 1)

/**
 * Logs SSL keys to a log file, allowing Wireshark to decode traffic and be examined with http2
 * filter. The approach is to hook into JSSE log events for the messages between client and server
 * during handshake, and then take the agreed masterSecret from private fields of the session.
 *
 * Copy WireSharkKeyLoggerListener to your test code to use in development.
 *
 * This logs TLSv1.2 on a JVM (OpenJDK 11+) without any additional code.  For TLSv1.3

      if (rule[0][0] == EXCEPTION_MARKER) {
        // Exception rules hold the effective TLD plus one.
        domainLabels.size - rule.size
      } else {
        // Otherwise the rule is for a public suffix, so we must take one more label.
        domainLabels.size - (rule.size + 1)
      }

    return splitDomain(domain).asSequence().drop(firstLabelOffset).joinToString(".")
  }

  private fun splitDomain(domain: String): List<String> {

            },
          )
          .build(),
      )
    call.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("success!")
    }
    body.awaitSuccess()
    assertThat(log.take()!!)
      .contains("StreamResetException: stream was reset: CANCEL")
  }

  /**
   * We delay sending the last byte of the request body 1500 ms. The 1000 ms read timeout should

   * forever.
   *
   * @return the head of the request queue
   */
  @Throws(InterruptedException::class)
  fun takeRequest(): RecordedRequest = requestQueue.take()

  /**
   * Awaits the next HTTP request (waiting up to the specified wait time if necessary), removes it,
   * and returns it. Callers should use this to verify the request was sent as intended within the

misato.shimane.jp misato.wakayama.jp misawa.aomori.jp misconfused.org mishima.fukushima.jp mishima.shizuoka.jp missile.museum missoula.museum misugi.mie.jp mit mitaka.tokyo.jp mitake.gifu.jp mitane.akita.jp mito.ibaraki.jp mitou.yamaguchi.jp mitoyo.kagawa.jp mitsubishi mitsue.nara.jp mitsuke.niigata.jp miura.kanagawa.jp miyada.nagano.jp miyagi.jp miyake.nara.jp miyako.fukuoka.jp miyako.iwate.jp miyakonojo.miyazaki.jp miyama.fukuoka.jp miyama.mie.jp miyashiro.saitama.jp miyawaka.fukuoka.jp miyazaki.jp miyazaki.miyazaki.jp...

 *
 * This class is pretty fast and loose with default values: it attempts to provide values that are
 * well-formed, but doesn't guarantee values are internally consistent. Callers must take care to
 * configure the factory when sample values impact the correctness of the test.
 */
class TestValueFactory : Closeable {
  var taskFaker: TaskFaker = TaskFaker()
  var taskRunner: TaskRunner = taskFaker.taskRunner

    recurrence: Boolean,
  ): Boolean {
    task.initQueue(this)

    val now = taskRunner.backend.nanoTime()
    val executeNanoTime = now + delayNanos

    // If the task is already scheduled, take the earlier of the two times.
    val existingIndex = futureTasks.indexOf(task)
    if (existingIndex != -1) {
      if (task.nextExecuteNanoTime <= executeNanoTime) {

### Holding multiple locks

You're allowed to take the Http2Connection lock while holding the Http2Writer lock. But not vice-versa. Because taking the Http2Writer lock can block.