assertThat(pool.connectionCount()).isEqualTo(1)

    // All other connections created will expire sooner
    routePlanner.defaultConnectionIdleAtNanos = expireSooner

    // Turn it into an http/2 connection that supports 5 concurrent streams
    // which can satisfy a larger policy
    val connection = routePlanner.plans.first().connection
    val http2Connection = connectHttp2(peer, connection, 5)

 * ⬜️ [Moshi](https://github.com/square/moshi): A modern JSON library for Android and Java.
 * [Ok2Curl](https://github.com/mrmike/Ok2Curl): Convert OkHttp requests into curl logs.
 * [OkHttp AWS Signer](https://github.com/babbel/okhttp-aws-signer): AWS V4 signing algorithm for OkHttp requests
 * [okhttp-digest](https://github.com/rburgst/okhttp-digest): A digest authenticator for OkHttp.

      // May have failed with an IOException
      "Unable to load $PUBLIC_SUFFIX_RESOURCE resource from the classpath."
    }

    // Break apart the domain into UTF-8 labels, i.e. foo.bar.com turns into [foo, bar, com].
    val domainLabelsUtf8Bytes = Array(domainLabels.size) { i -> domainLabels[i].toByteArray() }

        (adapter as DerAdapter<Any?>).toDer(writer, v)
      }

      override fun toString(): String = choices.joinToString(separator = " OR ")
    }
  }

  /**
   * This decodes a value into its contents using a preceding member of the same SEQUENCE. For
   * example, extensions type IDs specify what types to use for the corresponding values.
   *

//    .enableImplicitConfigurationParameters(false)
      .selectors(selectors)
      .build()
  return request
}

/**
 * Flattens a test filter into a list of specific test descriptors, usually individual method in a
 * test class annotated with @Test.
 */
fun findTests(selectors: List<DiscoverySelector>): List<TestDescriptor> {

   *
   * Use this method to create a degenerate Okio Buffer where each byte is in a separate segment of
   * the internal list.
   */
  @JvmStatic
  fun fragmentBuffer(buffer: Buffer): Buffer {
    // Write each byte into a new buffer, then clone it so that the segments are shared.
    // Shared segments cannot be compacted so we'll get a long chain of short segments.
    val result = Buffer()
    while (!buffer.exhausted()) {

  private fun ensureAllTaskQueuesIdle() {
    val entryTime = System.nanoTime()

    for (queue in TaskRunner.INSTANCE.activeQueues()) {
      // We wait at most 1 second, so we don't ever turn multiple lost threads into
      // a test timeout failure.
      val waitTime = (entryTime + 1_000_000_000L - System.nanoTime())
      if (!queue.idleLatch().await(waitTime, TimeUnit.NANOSECONDS)) {
        TaskRunner.INSTANCE.lock.withLock {

    this.withLock {
      return Collections.unmodifiableList(runningSyncCalls + runningAsyncCalls.map { it.call })
    }

  fun queuedCallsCount(): Int = this.withLock { readyAsyncCalls.size }

  fun runningCallsCount(): Int = this.withLock { runningAsyncCalls.size + runningSyncCalls.size }

  @JvmName("-deprecated_executorService")
  @Deprecated(
    message = "moved to val",

     * those already in the buffer.
     */
    internal var finished: Boolean,
  ) : Source {
    /** Buffer to receive data from the network into. Only accessed by the reader thread. */
    val receiveBuffer = Buffer()

    /** Buffer with readable data. Guarded by Http2Stream.this. */
    val readBuffer = Buffer()

    /**

          }
        }
      }
    }

    override fun priority(
      streamId: Int,
      streamDependency: Int,
      weight: Int,
      exclusive: Boolean,
    ) {
      // TODO: honor priority.
    }

    override fun pushPromise(
      streamId: Int,
      promisedStreamId: Int,
      requestHeaders: List<Header>,
    ) {
      pushRequestLater(promisedStreamId, requestHeaders)