) : SSLSocketFactory() {
  @Throws(IOException::class)
  override fun createSocket(): SSLSocket {
    val sslSocket = delegate.createSocket() as SSLSocket
    return configureSocket(sslSocket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: String,
    port: Int,
  ): SSLSocket {
    val sslSocket = delegate.createSocket(host, port) as SSLSocket
    return configureSocket(sslSocket)
  }

) : SocketFactory() {
  @Throws(IOException::class)
  override fun createSocket(): Socket {
    val socket = delegate.createSocket()
    return configureSocket(socket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: String,
    port: Int,
  ): Socket {
    val socket = delegate.createSocket(host, port)
    return configureSocket(socket)
  }

  @Throws(IOException::class)

  override fun createSocket(): Socket = SocketChannel.open().socket()

  override fun createSocket(
    host: String,
    port: Int,
  ): Socket = TODO("Not yet implemented")

  override fun createSocket(
    host: String,
    port: Int,
    localHost: InetAddress,
    localPort: Int,
  ): Socket = TODO("Not yet implemented")

  override fun createSocket(
    host: InetAddress,
    port: Int,

    val tlsSpec =
      ConnectionSpec
        .Builder(true)
        .tlsVersions(TlsVersion.TLS_1_2)
        .supportsTlsExtensions(false)
        .build()
    val socket = SSLSocketFactory.getDefault().createSocket() as SSLSocket
    socket.enabledCipherSuites =
      arrayOf(
        CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.javaName,
        CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA.javaName,
      )

    serverAddress: InetSocketAddress,
  ): Future<Handshake> {
    return executorService.submit<Handshake> {
      SocketFactory.getDefault().createSocket().use { rawSocket ->
        rawSocket.connect(serverAddress)
        val sslSocket =
          client.sslSocketFactory().createSocket(
            rawSocket,
            rawSocket.inetAddress.hostAddress,
            rawSocket.port,
            true,
          ) as SSLSocket

  /** Sets the [real] address for [requested].  */
  operator fun set(
    requested: InetAddress,
    real: InetSocketAddress,
  ) {
    hostMapping[requested] = real
  }

  override fun createSocket(): Socket =
    object : Socket() {
      override fun connect(
        endpoint: SocketAddress?,
        timeout: Int,
      ) {
        val requested = (endpoint as InetSocketAddress)

    // sslV3 is not used because SSLv3 is not enabled on the socket.
  }

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

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

      object : DelegatingSocketFactory(SocketFactory.getDefault()) {
        var first = true

        override fun createSocket(): Socket {
          if (first) {
            first = false
            firstConnectLatch.await()
          }
          return super.createSocket()
        }
      }

    client =
      client
        .newBuilder()

    val size: Int = formBody.size()
  }

  @Test @Disabled
  fun handshake() {
    val handshake: Handshake =
      Handshake.get((localhost().sslSocketFactory().createSocket() as SSLSocket).session)
    val tlsVersion: TlsVersion = handshake.tlsVersion()
    val cipherSuite: CipherSuite = handshake.cipherSuite()
    val peerCertificates: List<Certificate> = handshake.peerCertificates()

    val supportsTlsExtensions: Boolean = connectionSpec.supportsTlsExtensions
    val compatible: Boolean =
      connectionSpec.isCompatible(
        localhost().sslSocketFactory().createSocket() as SSLSocket,
      )
  }

  @Test
  fun connectionSpecBuilder() {
    var builder = ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
    builder = builder.allEnabledCipherSuites()