.sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
        .build()
    ```

 *  New: Add `cacheHit`, `cacheMiss`, and `cacheConditionalHit()` events to `EventListener`. Use
    these in logs, metrics, and even test cases to confirm your cache headers are configured as
    expected.

 *  New: Constant string `okhttp3.VERSION`. This is a string like "4.5.0-RC1", "4.5.0", or

	public abstract fun lookup (Ljava/lang/String;)Ljava/util/List;
}

public final class okhttp3/Dns$Companion {
}

public abstract class okhttp3/EventListener {
	public static final field Companion Lokhttp3/EventListener$Companion;
	public static final field NONE Lokhttp3/EventListener;
	public fun <init> ()V
	public fun cacheConditionalHit (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun cacheHit (Lokhttp3/Call;Lokhttp3/Response;)V

          }
        }
      }

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

import java.io.IOException
import java.net.InetAddress
import java.net.InetSocketAddress
import java.net.Proxy
import okhttp3.internal.SuppressSignatureCheck

/** Data classes that correspond to each of the methods of [EventListener]. */
@SuppressSignatureCheck
sealed class CallEvent {
  abstract val timestampNs: Long
  abstract val call: Call

  val name: String
    get() = javaClass.simpleName

 * [RFC 2817][1]. The HTTP CONNECT request that creates this tunnel connection is special: it
 * does not participate in any [interceptors][Interceptor] or [event listeners][EventListener]. It
 * doesn't include the motivating request's HTTP headers or even its full URL; only the target
 * server's hostname is sent to the proxy.
 *

import org.junit.jupiter.api.Assertions.fail

open class RecordingEventListener(
  /**
   * An override to ignore the normal order that is enforced.
   * EventListeners added by Interceptors will not see all events.
   */
  private val enforceOrder: Boolean = true,
) : EventListener() {
  val eventSequence: Deque<CallEvent> = ConcurrentLinkedDeque()

  private val forbiddenLocks = mutableListOf<Any>()

            }
          },
        )
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .eventListener(listener)
        .apply {
          if (connectionType == HTTPS) {
            protocols(listOf(HTTP_1_1))
          }
        }
        .build()
    threadToCancel = Thread.currentThread()
  }

        .build()
    var client = buildClient(clientCert, clientIntermediateCa.certificate)
    val listener = RecordingEventListener()
    client =
      client.newBuilder()
        .eventListener(listener)
        .build()
    val socketFactory = buildServerSslSocketFactory()
    server.useHttps(socketFactory)
    server.requireClientAuth()

  fun connectionIsImmediatelyUnhealthy() {
    val listener: EventListener =
      object : EventListener() {
        override fun connectionAcquired(
          call: Call,
          connection: Connection,
        ) {
          connection.socket().closeQuietly()
        }
      }
    client =
      client.newBuilder()
        .eventListener(listener)
        .build()
    executeSynchronously("/")

    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()