clientTestRule.newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(eventListener))
      .build()

  @BeforeEach
  fun before(server: MockWebServer) {
    this.server = server
  }

  @AfterEach
  fun after() {
    listener.assertExhausted()
  }

  @Test
  fun event() {
    server.enqueue(
      MockResponse.Builder()
        .body(
          """
          |data: hey
          |

    level = DeprecationLevel.ERROR,
  )
  fun subtype(): String = subtype

  /**
   * Returns the encoded media type, like "text/plain; charset=utf-8", appropriate for use in a
   * Content-Type header.
   */
  override fun toString(): String = commonToString()

  override fun equals(other: Any?): Boolean = commonEquals(other)

  override fun hashCode(): Int = commonHashCode()

  companion object {
    /**

    level = DeprecationLevel.ERROR,
  )
  fun certificate(): X509Certificate = certificate

  @JvmName("-deprecated_keyPair")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "keyPair"),
    level = DeprecationLevel.ERROR,
  )
  fun keyPair(): KeyPair = keyPair

  /**
   * Returns the certificate encoded in [PEM format][rfc_7468].

   */
  fun <T> withTypeHint(block: () -> T): T {
    typeHintStack.add(null)
    try {
      return block()
    } finally {
      typeHintStack.removeAt(typeHintStack.size - 1)
    }
  }

  private fun sink(): BufferedSink = stack[stack.size - 1]

  fun writeBoolean(b: Boolean) {
    sink().writeByte(if (b) -1 else 0)
  }

  fun writeBigInteger(value: BigInteger) {

   */
  open fun callStart(call: Call) {
  }

  /**
   * Invoked prior to a proxy selection.
   *
   * This will be invoked for route selection regardless of whether the client
   * is configured with a single proxy, a proxy selector, or neither.
   *
   * @param url a URL with only the scheme, hostname, and port specified.
   */
  open fun proxySelectStart(
    call: Call,
    url: HttpUrl,

     * it requires that bytes have already been flushed by the server.
     */
    fun clientSourceBufferSize(): Long {
      source.request(1L)
      return source.buffer.size
    }

    fun processNextFrame(): Boolean {
      taskFaker.runTasks()
      return webSocket!!.processNextFrame()
    }

    override fun close() {
      if (closed) {
        throw AssertionError("Already closed")
      }

  private val routeDatabase = RouteDatabase()

  @BeforeEach fun setUp() {
    call =
      clientTestRule.newClient().newCall(
        Request.Builder()
          .url("https://$uriHost:$uriPort/")
          .build(),
      ) as RealCall
  }

  @AfterEach fun tearDown() {
    factory.close()
  }

  @Test fun singleRoute() {
    val address = factory.newAddress()

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
  }

  @Test
  fun defaultConfigIsNoTimeout() {
    val request =
      Request.Builder()
        .url(server.url("/"))
        .build()
    val call = client.newCall(request)
    assertThat(call.timeout().timeoutNanos()).isEqualTo(0)
  }

  @Test
  fun configureClientDefault() {
    val request =

  }

  @Test
  fun cacheControl() {
    val request =
      Request.Builder()
        .cacheControl(CacheControl.Builder().noCache().build())
        .url("https://square.com")
        .build()
    assertThat(request.headers("Cache-Control")).containsExactly("no-cache")
    assertThat(request.cacheControl.noCache).isTrue()
  }

  @Test
  fun emptyCacheControlClearsAllCacheControlHeaders() {

  private val executorService = Executors.newScheduledThreadPool(1)

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
    platform.assumeNotOpenJSSE()
    platform.assumeHttp2Support()
  }

  @AfterEach
  fun tearDown() {
    executorService.shutdown()
  }

  @Test
  @Throws(IOException::class)
  fun http1DoesntSupportDuplex() {
    val call =
      client.newCall(