return copy(proxyAuthenticator = proxyAuthenticator)
  }

  override fun withSslSocketFactory(
    sslSocketFactory: SSLSocketFactory?,
    x509TrustManager: X509TrustManager?,
  ): Interceptor.Chain {
    check(exchange == null) { "sslSocketFactory can't be adjusted in a network interceptor" }

    if (sslSocketFactory != null && x509TrustManager != null) {

  @JvmName("-deprecated_sslSocketFactory")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "sslSocketFactory"),
    level = DeprecationLevel.ERROR,
  )
  fun sslSocketFactory(): SSLSocketFactory? = sslSocketFactory

  @JvmName("-deprecated_hostnameVerifier")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "hostnameVerifier"),

  sslSocketClass: Class<in SSLSocket>,
  private val sslSocketFactoryClass: Class<in SSLSocketFactory>,
  private val paramClass: Class<*>,
) : AndroidSocketAdapter(sslSocketClass) {
  override fun matchesSocketFactory(sslSocketFactory: SSLSocketFactory): Boolean = sslSocketFactoryClass.isInstance(sslSocketFactory)

  override fun trustManager(sslSocketFactory: SSLSocketFactory): X509TrustManager? {
    val context: Any? =
      readFieldOrNull(

import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory
import javax.net.ssl.X509TrustManager
import okhttp3.Protocol

interface SocketAdapter {
  fun isSupported(): Boolean

  fun trustManager(sslSocketFactory: SSLSocketFactory): X509TrustManager? = null

  fun matchesSocket(sslSocket: SSLSocket): Boolean

  fun matchesSocketFactory(sslSocketFactory: SSLSocketFactory): Boolean = false

  fun configureTlsExtensions(

        NodeManager nodeManager = getNodeManager(curlHelper);
        assertNotNull(nodeManager);

        // Verify SSL socket factory is not set
        SSLSocketFactory sslSocketFactory = getSSLSocketFactory(curlHelper);
        assertNull(sslSocketFactory);
    }

    @Test
    public void test_init_withInvalidSSLCertificate() {
        // Create a temporary invalid certificate file

    proxySelector: ProxySelector = this.proxySelector,
    sslSocketFactory: SSLSocketFactory? = this.sslSocketFactory,
    hostnameVerifier: HostnameVerifier? = this.hostnameVerifier,
  ): Address =
    Address(
      uriHost = uriHost,
      uriPort = uriPort,
      dns = dns,
      socketFactory = SocketFactory.getDefault(),
      sslSocketFactory = sslSocketFactory,
      hostnameVerifier = hostnameVerifier,

      DeferredSocketAdapter(BouncyCastleSocketAdapter.factory),
    ).filter { it.isSupported() }

  override fun trustManager(sslSocketFactory: SSLSocketFactory): X509TrustManager? =
    socketAdapters
      .find { it.matchesSocketFactory(sslSocketFactory) }
      ?.trustManager(sslSocketFactory)

  override fun newSSLContext(): SSLContext {
    StrictMode.noteSlowCall("newSSLContext")

    return super.newSSLContext()
  }

    server.useHttps(serverCertificates.sslSocketFactory())
    server.enqueue(MockResponse())

    val clientCertificates =
      HandshakeCertificates
        .Builder()
        .addPlatformTrustedCertificates()
        .addInsecureHost(server.hostName)
        .build()

    val client =
      clientTestRule
        .newClientBuilder()

    object SslSocketFactoryOverride : Override<SSLSocketFactory?> {
      override fun Interceptor.Chain.value(): SSLSocketFactory? = sslSocketFactoryOrNull

      override fun Interceptor.Chain.withOverride(value: SSLSocketFactory?): Interceptor.Chain =
        withSslSocketFactory(value, x509TrustManagerOrNull)

      override fun OkHttpClient.Builder.withOverride(value: SSLSocketFactory?): OkHttpClient.Builder =

    }
  }

  private fun enableTls() {
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }