private var listener = RecordingEventListener()
  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()

  @Test
  fun upgrade() {
    val socketHandler =
      MockSocketHandler()
        .apply {
          receiveRequest("client says hello\n")

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].
 *
 * 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.
 */

    val interceptors: List<Interceptor> = client.interceptors
    val networkInterceptors: List<Interceptor> = client.networkInterceptors
    val eventListenerFactory: EventListener.Factory = client.eventListenerFactory
    val proxySelector: ProxySelector = client.proxySelector
    val cookieJar: CookieJar = client.cookieJar
    val cache: Cache? = client.cache

              this.enableSessionCreation = false
            }
          }
      }

    client =
      client
        .newBuilder()
        .connectionSpecs(listOf(spec))
        .eventListenerFactory(
          clientTestRule.wrap(
            object : EventListener() {
              override fun connectionAcquired(
                call: Call,
                connection: Connection,
              ) {

  }

  @Test
  @Disabled
  fun testFacebook() {
    val sessionIds = mutableListOf<String>()

    assumeNetwork()

    client =
      client
        .newBuilder()
        .eventListenerFactory(
          clientTestRule.wrap(
            object : EventListener() {
              override fun connectionAcquired(
                call: Call,
                connection: Connection,
              ) {

 * **MultipartBody.**: boundary, parts, size, type
 * **OkHttpClient**: authenticator, cache, callTimeoutMillis, certificatePinner,
   connectTimeoutMillis, connectionPool, connectionSpecs, cookieJar, dispatcher, dns,
   eventListenerFactory, followRedirects, followSslRedirects, hostnameVerifier, interceptors,
   networkInterceptors, pingIntervalMillis, protocols, proxy, proxyAuthenticator, proxySelector,

  private val eventListener = RecordingEventListener()
  private val listener = EventSourceRecorder()
  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(eventListener))
      .build()

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

  @Test
  fun event() {
    server.enqueue(
      MockResponse

  private val listener = RecordingEventListener()
  private val handshakeCertificates = platform.localhostHandshakeCertificates()

  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()

  @StartStop
  private val server = MockWebServer()

  @BeforeEach
  fun setUp() {
    platform.assumeNotOpenJSSE()
    platform.assumeHttp2Support()

    dnsResults =
      listOf(
        localhostIpv4,
        localhostIpv6,
      )

    client =
      clientTestRule
        .newClientBuilder()
        .eventListenerFactory(clientTestRule.wrap(listener))
        .connectTimeout(60, TimeUnit.SECONDS) // Deliberately exacerbate slow fallbacks.
        .dns { dnsResults }
        .fastFallback(true)
        .build()
    url =

    client =
      clientTestRule
        .newClientBuilder()
        .dns(dns)
        .socketFactory(socketFactory)
        .eventListenerFactory(clientTestRule.wrap(listener))
        .build()
  }

  @Test
  fun http2OneBadHostOneGoodNoRetryOnConnectionFailure() {
    enableProtocol(Protocol.HTTP_2)

    val request = Request(server1.url("/"))