@BeforeEach
  fun setUp() {
    client =
      clientTestRule
        .newClientBuilder()
        .eventListenerFactory(loggingEventListenerFactory)
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).retryOnConnectionFailure(false)
        .build()
    url = server.url("/")
  }

  @Test
  fun get() {

import java.net.Socket
import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory

/**
 * A [SSLSocketFactory] that delegates calls. Sockets can be configured after creation by
 * overriding [.configureSocket].
 */
open class DelegatingSSLSocketFactory(
  private val delegate: SSLSocketFactory,
) : SSLSocketFactory() {
  @Throws(IOException::class)
  override fun createSocket(): SSLSocket {

    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .protocols(protocols.toList())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.protocols = client.protocols
  }

        val sslContext = SSLContext.getInstance("TLS")
        sslContext.init(null, arrayOf<TrustManager>(trustManager), null)
        val sslSocketFactory = sslContext.socketFactory

        client = OkHttpClient.Builder()
            .sslSocketFactory(sslSocketFactory, trustManager)
            .build()
      }

      fun run() {
        val request = Request.Builder()

      client
        .newBuilder()
        .protocols(protocols.toList())
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.protocols = protocols.toList()
  }

  private fun upgradeRequest() =

    StrictMode.noteSlowCall("newSSLContext")

    return super.newSSLContext()
  }

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

  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,

          sslSocket.sslParameters = parameters
        }

        return sslSocket
      }
    }

    client =
      client
        .newBuilder()
        .sslSocketFactory(CustomSSLSocketFactory(client.sslSocketFactory), client.x509TrustManager!!)
        .hostnameVerifier { hostname, session ->
          val s = "hostname: $hostname peerHost:${session.peerHost}"
          Log.d("SniOverrideTest", s)
          try {

      builder.callTimeout(callTimeout.toLong(), SECONDS)
    }
    if (allowInsecure) {
      val trustManager = createInsecureTrustManager()
      val sslSocketFactory = createInsecureSslSocketFactory(trustManager)
      builder.sslSocketFactory(sslSocketFactory, trustManager)
      builder.hostnameVerifier(createInsecureHostnameVerifier())
    }
    if (verbose) {
      val logger = HttpLoggingInterceptor.Logger(::println)

    delegate.protocols = protocols
  }

  @JvmName("-deprecated_protocols")
  fun protocols(): List<Protocol> = delegate.protocols

  fun useHttps(
    sslSocketFactory: SSLSocketFactory,
    tunnelProxy: Boolean,
  ) {
    delegate.useHttps(sslSocketFactory)
  }

  fun noClientAuth() {
    delegate.noClientAuth()
  }

  fun requestClientAuth() {
    delegate.requestClientAuth()
  }

    HttpUrl
      .Builder()
      .scheme(if (sslSocketFactory != null) "https" else "http")
      .host(hostName)
      .port(port)
      .build()
      .resolve(path)!!

  /**
   * Serve requests with HTTPS rather than otherwise.
   */
  public fun useHttps(sslSocketFactory: SSLSocketFactory) {
    this.sslSocketFactory = sslSocketFactory
  }

  /**