// Cancel some calls. That doesn't impact running or queued.
    a2.cancel()
    a3.cancel()
    assertThat(dispatcher.runningCalls())
      .containsExactlyInAnyOrder(a1, a2)
    assertThat(dispatcher.queuedCalls()).isEmpty()

    // Let the calls finish.
    waiting.countDown()
    t1.join()
    t2.join()

    // Now we should have 0 running calls and 0 queued calls.

   * `allocations.size() < allocationLimit` then new streams can be created on this connection.
   */
  internal var allocationLimit = 1
    private set

  /** Current calls carried by this connection. */
  val calls = mutableListOf<Reference<RealCall>>()

  /** Timestamp when `allocations.size()` reached zero. Also assigned upon initial connection. */
  var idleAtNs = Long.MAX_VALUE

  /**

   *
   * ### Duplex Transmission
   *
   * With regular HTTP calls the request always completes sending before the response may begin
   * receiving. With duplex the request and response may be interleaved! That is, request body bytes
   * may be sent after response headers or body bytes have been received.
   *
   * Though any call may be initiated as a duplex call, only web servers that are specially

import org.junit.Ignore;

/**
 * Common superclass for {@link MultisetSetCountUnconditionallyTester} and {@link
 * MultisetSetCountConditionallyTester}. It is used by those testers to test calls to the
 * unconditional {@code setCount()} method and calls to the conditional {@code setCount()} method
 * when the expected present count is correct.
 *
 * @author Chris Povirk
 */
@GwtCompatible

          Buffer()
            .write(ByteArray(responseBodySize)),
        ).throttleBody(64 * 1024, 125, MILLISECONDS) // 500 Kbps
        .build(),
    )
    val call = client.newCall(Request(server.url("/")))
    val response = call.execute()
    cancelLater(call, 500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)
    assertFailsWith<IOException> {
      while (responseBody.read(buffer) != -1) {

   * exception.
   *
   * <p>When the underlying delegate throws an exception then this memoizing supplier will keep
   * delegating calls until it returns valid data.
   *
   * @param duration the length of time after a value is created that it should stop being returned
   *     by subsequent {@code get()} calls
   * @param unit the unit that {@code duration} is expressed in
   * @throws IllegalArgumentException if {@code duration} is not positive

       * class with a manual reference back to the "containing" class.)
       *
       * This has the nice-ish side effect of limiting reentrancy: run() calls
       * timeoutFuture.setException() calls run(). That reentrancy would already be harmless, since
       * timeoutFuture can be set (and delegate cancelled) only once. (And "set only once" is

    certain bad routes indefinitely; now we only track the ones that could be necessary.
 *  Fix: Defer proxy selection until a proxy is required. This saves calls to `ProxySelector` on
    calls that use a pooled connection.


## Version 4.3.1

_2020-01-07_

 *  Fix: Don't crash with a `NullPointerException` when a web socket is closed before it connects.

   * exception.
   *
   * <p>When the underlying delegate throws an exception then this memoizing supplier will keep
   * delegating calls until it returns valid data.
   *
   * @param duration the length of time after a value is created that it should stop being returned
   *     by subsequent {@code get()} calls
   * @param unit the unit that {@code duration} is expressed in
   * @throws IllegalArgumentException if {@code duration} is not positive

  fun testLoggingLevels() {
    enableTls()

    val testHandler =
      object : Handler() {
        val calls = mutableMapOf<String, AtomicInteger>()

        override fun publish(record: LogRecord) {
          calls
            .getOrPut(record.loggerName) { AtomicInteger(0) }
            .incrementAndGet()
        }

        override fun flush() {
        }