override fun configureSocket(sslSocket: SSLSocket): SSLSocket {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
          val parameters = sslSocket.sslParameters
          val sni = parameters.serverNames
          Log.d("CustomSSLSocketFactory", "old SNI: $sni")
          parameters.serverNames = mutableListOf<SNIServerName>(SNIHostName("cloudflare-dns.com"))
          sslSocket.sslParameters = parameters
        }

  /** Applies this spec to [sslSocket]. */
  internal fun apply(
    sslSocket: SSLSocket,
    isFallback: Boolean,
  ) {
    val specToApply = supportedSpec(sslSocket, isFallback)

    if (specToApply.tlsVersions != null) {
      sslSocket.enabledProtocols = specToApply.tlsVersionsAsString
    }

    if (specToApply.cipherSuites != null) {
      sslSocket.enabledCipherSuites = specToApply.cipherSuitesAsString

    val systemSslSocketFactory = sslContext.socketFactory
    val sslSocketFactory =
      object : DelegatingSSLSocketFactory(systemSslSocketFactory) {
        override fun configureSocket(sslSocket: SSLSocket): SSLSocket {
          return sslSocket.apply {
            if (reuseSession) {
              this.enableSessionCreation = false
            }
          }
        }
      }

    client =
      client.newBuilder()

  }

  private fun createSocketWithEnabledProtocols(vararg tlsVersions: TlsVersion): SSLSocket {
    return (handshakeCertificates.sslSocketFactory().createSocket() as SSLSocket).apply {
      enabledProtocols = javaNames(*tlsVersions)
    }
  }

  private fun assertEnabledProtocols(
    socket: SSLSocket,
    vararg required: TlsVersion,
  ) {

            }

            val serverSslSocketFactory =
              object : DelegatingSSLSocketFactory(sslSocketFactory) {
                override fun configureSocket(sslSocket: SSLSocket): SSLSocket {
                  return sslSocket.apply {
                    sslParameters =
                      sslParameters.apply {
                        sniMatchers =
                          listOf(

import javax.net.ssl.HandshakeCompletedListener
import javax.net.ssl.SSLParameters
import javax.net.ssl.SSLSession
import javax.net.ssl.SSLSocket

/** An [SSLSocket] that delegates all calls.  */
abstract class DelegatingSSLSocket(protected val delegate: SSLSocket?) : SSLSocket() {
  @Throws(IOException::class)
  override fun shutdownInput() {
    delegate!!.shutdownInput()
  }

  @Throws(IOException::class)

              raw.port,
              true,
            )
          val sslSocket = socket as SSLSocket
          sslSocket.useClientMode = false
          if (clientAuth == CLIENT_AUTH_REQUIRED) {
            sslSocket.needClientAuth = true
          } else if (clientAuth == CLIENT_AUTH_REQUESTED) {
            sslSocket.wantClientAuth = true
          }
          openClientSockets.add(socket)

    }

    override fun connectionAcquired(
      call: Call,
      connection: Connection,
    ) {
      if (random != null) {
        val sslSocket = connection.socket() as SSLSocket
        val session = sslSocket.session

        val masterSecretHex =
          session.masterSecret?.encoded?.toByteString()
            ?.hex()

        if (masterSecretHex != null) {

 */
package okhttp3.internal.platform

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isNotNull
import assertk.assertions.isNull
import javax.net.ssl.SSLSocket
import okhttp3.DelegatingSSLSocket
import okhttp3.internal.platform.Jdk9Platform.Companion.buildIfSupported
import okhttp3.testing.PlatformRule
import org.junit.jupiter.api.Test

    val eventListener =
      object : EventListener() {
        var socket: SSLSocket? = null
        var closed = false

        override fun connectionAcquired(
          call: Call,
          connection: Connection,
        ) {
          socket = connection.socket() as SSLSocket
        }

        override fun requestHeadersStart(call: Call) {
          if (closed) {