) : Call, Cloneable {
  internal val lock: ReentrantLock = ReentrantLock()

  private val connectionPool: RealConnectionPool = client.connectionPool.delegate

  internal val eventListener: EventListener = client.eventListenerFactory.create(this)

  private val timeout =
    object : AsyncTimeout() {
      override fun timedOut() {
        ******@****.***()
      }
    }.apply {

  fun networkInterceptors(): List<Interceptor> = networkInterceptors

  @JvmName("-deprecated_eventListenerFactory")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "eventListenerFactory"),
    level = DeprecationLevel.ERROR,
  )
  fun eventListenerFactory(): EventListener.Factory = eventListenerFactory

  @JvmName("-deprecated_retryOnConnectionFailure")
  @Deprecated(

    )
    // We should consider if these logs should retain Exceptions
    assertThat(logs.last().throwable).isNull()
  }

  @Test
  fun testLoggingEventListener() {
    val client =
      clientBuilder.eventListenerFactory(LoggingEventListener.androidLogging(tag = "testLoggingEventListener")).build()

    try {
      client.newCall(request).execute()
    } catch (uhe: UnknownHostException) {
      // expected
    }

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 dispatcher = Dispatcher(executor)
  val listener = RecordingEventListener()
  var client =
    clientTestRule.newClientBuilder()
      .dns { throw UnknownHostException() }
      .dispatcher(dispatcher)
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()

  @BeforeEach
  fun setUp() {
    dispatcher.maxRequests = 20
    dispatcher.maxRequestsPerHost = 10
    listener.forbidLock(dispatcher)
  }

  @Test

    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

    serverListener.assertClosed(1000, "goodbye")
  }

  @Test
  fun webSocketsDontTriggerEventListener() {
    val listener = RecordingEventListener()
    client =
      client.newBuilder()
        .eventListenerFactory(clientTestRule.wrap(listener))
        .build()
    webServer.enqueue(
      MockResponse.Builder()
        .webSocketUpgrade(serverListener)
        .build(),
    )

  private var listener = RecordingEventListener()
  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private var client =
    clientTestRule.newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()
  private val callback = RecordingCallback()
  private val cache =
    Cache(
      fileSystem = LoggingFilesystem(fileSystem),

	public final fun -deprecated_cookieJar ()Lokhttp3/CookieJar;
	public final fun -deprecated_dispatcher ()Lokhttp3/Dispatcher;
	public final fun -deprecated_dns ()Lokhttp3/Dns;
	public final fun -deprecated_eventListenerFactory ()Lokhttp3/EventListener$Factory;
	public final fun -deprecated_followRedirects ()Z
	public final fun -deprecated_followSslRedirects ()Z
	public final fun -deprecated_hostnameVerifier ()Ljavax/net/ssl/HostnameVerifier;

        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          latch.countDown()
        }
      }
    client =
      client.newBuilder().eventListenerFactory(
        clientTestRule.wrap(
          object : EventListener() {
            var callCount = 0

            override fun connectionAcquired(
              call: Call,