hand it off to another thread to write to it after `writeTo` returns.

    The `EventListener` may now see requests and responses interleaved in ways not previously
    permitted. For example, a listener may receive `responseHeadersStart()` followed by
    `requestBodyEnd()`, both on the same call. Such events may be triggered by different threads
    even for a single call.

    // Confirm the events occur when expected.
    listener.takeEvent(CallStart::class.java, 0L)
    listener.takeEvent(ConnectionAcquired::class.java, applicationInterceptorDelay)
    listener.takeEvent(RequestHeadersStart::class.java, networkInterceptorDelay)
    listener.takeEvent(RequestHeadersEnd::class.java, 0L)
    listener.takeEvent(RequestBodyStart::class.java, 0L)
    listener.takeEvent(RequestBodyEnd::class.java, requestBodyDelay)

    val response = call.execute()
    assertThat(response.code).isEqualTo(200)
    response.body.close()
    listener.removeUpToEvent(ConnectionEvent.ConnectEnd::class.java)
    listener.removeUpToEvent(ConnectionEvent.ConnectionReleased::class.java)
    listener.removeUpToEvent(ConnectionEvent.ConnectionAcquired::class.java)
    listener.removeUpToEvent(ConnectionEvent.ConnectionReleased::class.java)
  }

  @Test

    Listener listener;
    synchronized (this) {
      listener = listeners.get(state);
    }

    if (code == null || listener == null) {
      return new MockResponse()
          .setResponseCode(404)
          .setBody("unexpected request");
    }

    try {
      OAuthSession session = slackApi.exchangeCode(code, redirectUrl());
      listener.sessionGranted(session);

          client -> "$okHttpName $peerName"
          else -> "MockWebServer $peerName"
        }
      this.source = source
      this.sink = sink
    }

    fun listener(listener: Listener) =
      apply {
        this.listener = listener
      }

    fun pushObserver(pushObserver: PushObserver) =
      apply {
        this.pushObserver = pushObserver
      }

    return delegate!!.session
  }

  override fun addHandshakeCompletedListener(listener: HandshakeCompletedListener) {
    delegate!!.addHandshakeCompletedListener(listener)
  }

  override fun removeHandshakeCompletedListener(listener: HandshakeCompletedListener) {
    delegate!!.removeHandshakeCompletedListener(listener)
  }

  @Throws(IOException::class)
  override fun startHandshake() {

  @Synchronized fun receivedPongCount(): Int = receivedPongCount

  @Throws(IOException::class)
  override fun onReadMessage(text: String) {
    listener.onMessage(this, text)
  }

  @Throws(IOException::class)
  override fun onReadMessage(bytes: ByteString) {
    listener.onMessage(this, bytes)
  }

  @Synchronized override fun onReadPing(payload: ByteString) {

    val response =
      Response.Builder().request(request).code(200).message("").protocol(Protocol.HTTP_2)
        .build()
    val listener = loggingEventListenerFactory.create(call)
    listener.cacheConditionalHit(call, response)
    listener.cacheHit(call, response)
    listener.cacheMiss(call)
    listener.satisfactionFailure(call, response)
    logRecorder

   */
  open fun onClosed(
    webSocket: WebSocket,
    code: Int,
    reason: String,
  ) {
  }

  /**
   * Invoked when a web socket has been closed due to an error reading from or writing to the
   * network. Both outgoing and incoming messages may have been lost. No further calls to this
   * listener will be made.
   */
  open fun onFailure(

/**
 * An OkHttp EventListener, which logs call events. Can be applied as an
 * [event listener factory][OkHttpClient.eventListenerFactory].
 *
 * The format of the logs created by this class should not be considered stable and may change
 * slightly between releases. If you need a stable logging format, use your own event listener.
 */
class LoggingEventListener private constructor(
  private val logger: HttpLoggingInterceptor.Logger,