`org.bouncycastle`, and `org.openjsse`.
 *  Upgrade: Explicitly depend on `kotlin-stdlib-jdk8`. This fixes a problem with dependency
    locking. That's a potential security vulnerability, tracked as [CVE-2022-24329].
 *  Upgrade: [publicsuffix.org data][public_suffix]. This powers `HttpUrl.topPrivateDomain()`.
    It's also how OkHttp knows which domains can share cookies with one another.

 * Any IO - writing to files or network should be done asynchronously.
 */
@ExperimentalOkHttpApi
abstract class ConnectionListener {
  /**
   * Invoked as soon as a call causes a connection to be started.
   */
  open fun connectStart(
    route: Route,
    call: Call,
  ) {}

  /**
   * Invoked when a connection fails to be established.
   */
  open fun connectFailed(
    route: Route,

  private var waitingCoordinatorTask: SerialTask? = null
  private var waitingCoordinatorInterrupted = false
  private var waitingCoordinatorNotified = false

  /** How many times a new task has been started. Guarded by [TaskRunner.lock]. */
  private var contextSwitchCount = 0

  /** Guarded by [TaskRunner.lock]. */
  private var activeThreads = 0

 * handshakes.
 */
class Handshake internal constructor(
  /**
   * Returns the TLS version used for this connection. This value wasn't tracked prior to OkHttp
   * 3.0. For responses cached by preceding versions this returns [TlsVersion.SSL_3_0].
   */
  @get:JvmName("tlsVersion") val tlsVersion: TlsVersion,
  /** Returns the cipher suite used for the connection. */

  private var coordinatorWaiting = false
  private var coordinatorWakeUpAt = 0L

  /**
   * When we need a new thread to run tasks, we call [Backend.execute]. A few microseconds later we
   * expect a newly-started thread to call [Runnable.run]. We shouldn't request new threads until
   * the already-requested ones are in service, otherwise we might create more threads than we need.
   *

  private val factory = routePlanner.factory
  private val taskFaker = routePlanner.taskFaker
  private val peer = MockHttp2Peer()

  /** The fake task runner prevents the cleanup runnable from being started.  */
  private val addressA = factory.newAddress("a")
  private val routeA1 = factory.newRoute(addressA)
  private val addressB = factory.newAddress("b")
  private val routeB1 = factory.newRoute(addressB)

 * imposes both obligations and limits on the client application.
 *
 * ### The response body must be closed.
 *
 * Each response body is backed by a limited resource like a socket (live network responses) or
 * an open file (for cached responses). Failing to close the response body will leak resources and
 * may ultimately cause the application to slow down or crash.
 *

    val a3 = client.newCall(newRequest("http://a/3"))
    val a4 = client.newCall(newRequest("http://a/4"))
    val t1 = makeSynchronousCall(a1)
    val t2 = makeSynchronousCall(a2)

    // We created 4 calls and started 2 of them. That's 2 running calls and 0 queued.
    ready.await()
    assertThat(dispatcher.runningCallsCount()).isEqualTo(2)
    assertThat(dispatcher.queuedCallsCount()).isEqualTo(0)

    private val servers = mutableMapOf<String, MockWebServer>()
    private var started = false

    fun server(name: String): MockWebServer {
      return servers.getOrPut(name) {
        MockWebServer().also {
          if (started) it.start()
        }
      }
    }

    fun startAll() {
      started = true
      for (server in servers.values) {
        server.start()
      }
    }

  fun beforeEach(server: MockWebServer) {
    instanceServer = server

    assertThat(instanceServer).isNotSameInstanceAs(staticServer)
    assertThat(instanceServer).isSameInstanceAs(server)

    assertThat(server.started).isTrue()
    server.enqueue(MockResponse())
  }

  @AfterEach
  fun afterEach(server: MockWebServer) {
    assertThat(server).isSameInstanceAs(instanceServer)
  }

  @Test