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 {

      }
    } catch (e: UnsupportedOperationException) {
      // https://docs.oracle.com/javase/9/docs/api/javax/net/ssl/SSLSocket.html#getApplicationProtocol--
      null
    }

  override fun trustManager(sslSocketFactory: SSLSocketFactory): X509TrustManager? {
    // Not supported due to access checks on JDK 9+:
    // java.lang.reflect.InaccessibleObjectException: Unable to make member of class

    val connectionSpecs: List<ConnectionSpec> = address.connectionSpecs()
    val proxySelector: ProxySelector = address.proxySelector()
    val proxy: Proxy? = address.proxy()
    val sslSocketFactory: SSLSocketFactory? = address.sslSocketFactory()
    val hostnameVerifier: HostnameVerifier? = address.hostnameVerifier()
    val certificatePinner: CertificatePinner? = address.certificatePinner()
  }

  @Test @Disabled
  fun cache() {

    }

    /**
     * Sets the SSL socket factory for secure connections.
     *
     * @param sslSocketFactory the SSL socket factory
     * @return this CurlRequest instance
     */
    public CurlRequest sslSocketFactory(final SSLSocketFactory sslSocketFactory) {
        this.sslSocketFactory = sslSocketFactory;
        return this;
    }

    /**
     * Sets the body content for the request.
     *

                  .build(),
              ),
            )

            val sslSocketFactory = handshakeCertificates.sslSocketFactory()

            sslSocketFactory(
              sslSocketFactory,
              handshakeCertificates.trustManager,
            )

            when (socketMode.protocol) {

    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?,

 * limitations under the License.
 */
package okhttp3

import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory
import okhttp3.FallbackTestClientSocketFactory.Companion.TLS_FALLBACK_SCSV

/**
 * An SSLSocketFactory that delegates calls. Sockets created by the delegate are wrapped with ones
 * that will not accept the [TLS_FALLBACK_SCSV] cipher, thus bypassing server-side fallback

    val handshakeCertificates = localhost()
    server.useHttps(handshakeCertificates.sslSocketFactory())

    val dns =
      Dns {
        Dns.SYSTEM.lookup(server.hostName)
      }

    val client =
      clientTestRule
        .newClientBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).dns(dns)
        .build()

    val protocols: List<Protocol> = address.protocols
    val connectionSpecs: List<ConnectionSpec> = address.connectionSpecs
    val proxySelector: ProxySelector = address.proxySelector
    val sslSocketFactory: SSLSocketFactory? = address.sslSocketFactory
    val hostnameVerifier: HostnameVerifier? = address.hostnameVerifier
    val certificatePinner: CertificatePinner? = address.certificatePinner
  }

  @Test
  fun authenticator() {

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