*/
    fun create(call: Call): EventListener
  }

  companion object {
    @JvmField
    val NONE: EventListener =
      object : EventListener() {
      }
  }

  private class AggregateEventListener(
    val eventListeners: Array<EventListener>,
  ) : EventListener() {
    override fun callStart(call: Call) {
      for (delegate in eventListeners) {
        delegate.callStart(call)
      }

      .apply {
        listeners += ::onEvent
      }

  val eventListener: EventListener
    get() = eventListenerAdapter

  var eventCount = 0

  private fun onEvent(callEvent: CallEvent) {
    if (eventCount++ == 0) {
      eventRecorder.logEvent(callEvent)
      val next = EventListenerRelay(call, eventRecorder)
      call.addEventListener(next.eventListener)
    }
  }

        )
      this.connection = connection
      connection.start()

      // Success.
      call.eventListener.connectEnd(call, route.socketAddress, route.proxy, protocol)
      success = true
      return ConnectResult(plan = this)
    } catch (e: IOException) {
      call.eventListener.connectFailed(call, route.socketAddress, route.proxy, null, e)
      connectionPool.connectionListener.connectFailed(route, call, e)

  override fun timeout(): Timeout = timeout

  override fun addEventListener(eventListener: EventListener) {
    // Atomically replace the current eventListener with a composite one.
    do {
      val previous = this.eventListener
    } while (!eventListenerUpdater.compareAndSet(this, previous, previous + eventListener))
  }

  override fun <T : Any> tag(type: KClass<T>): T? = type.java.cast(tags.get()[type])

          ioe: IOException,
        ) = TODO()

        override fun canceled(call: Call) = TODO()
      }
    val none: EventListener = EventListener.NONE
  }

  @Test
  fun eventListenerBuilder() {
    var builder: EventListener.Factory = EventListener.Factory { TODO() }
  }

  @Test
  fun formBody() {
    val formBody: FormBody = FormBody.Builder().build()

    val b = EventRecorder(enforceOrder = false)
    val c = EventRecorder(enforceOrder = false)
    val d = EventRecorder(enforceOrder = false)

    val abcd = (a.eventListener + b.eventListener) + (c.eventListener + d.eventListener)
    abcd.callStart(FailingCall())

    assertThat(a.takeEvent()).isInstanceOf<CallStart>()
    assertThat(a.eventSequence).isEmpty()

import java.util.concurrent.TimeUnit
import okhttp3.Call
import okhttp3.Connection
import okhttp3.Dispatcher
import okhttp3.EventListener
import okhttp3.Handshake
import okhttp3.HttpUrl
import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.Request
import okhttp3.Response

/**
 * An OkHttp EventListener, which logs call events. Can be applied as an
 * [event listener factory][OkHttpClient.eventListenerFactory].
 *

  @StartStop
  private val server = MockWebServer()

  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListener(listener)
      .build()

  class SocketClosingEventListener : EventListener() {
    var shouldClose: Boolean = false
    var lastSocket: Socket? = null

    override fun connectionAcquired(
      call: Call,
      connection: Connection,
    ) {

          listOf(
            ConnectionSpec
              .Builder(ConnectionSpec.MODERN_TLS)
              .supportsTlsExtensions(false)
              .build(),
          ),
        ).eventListener(
          object : EventListener() {
            override fun connectionAcquired(
              call: Call,
              connection: Connection,
            ) {
              val sslSocket = connection.socket() as SSLSocket

      }
    val localClient = client.newBuilder().eventListener(eventListener).build()

    val call1 = localClient.newCall(Request(server.url("/")))

    call1.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("Req1")
      assertThat(response.handshake).isNotNull()
      assertThat(response.protocol == Protocol.HTTP_1_1)
    }

    eventListener.closed = true