keyManagerFactory.init(KeyStoreBuilderParameters(builderList))
    val keyManager = keyManagerFactory.keyManagers[0] as X509ExtendedKeyManager

    val trustManager = Platform.get().platformTrustManager()

    val sslContext = SSLContext.getInstance("TLS")
    sslContext.init(arrayOf(keyManager), arrayOf(trustManager), SecureRandom())

    val client =
      OkHttpClient.Builder()

    }

    val factory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm())
    factory.init(keyStore, password)
    val result = factory.keyManagers!!
    check(result.size == 1 && result[0] is X509KeyManager) {
      "Unexpected key managers:${result.contentToString()}"
    }

    return result[0] as X509KeyManager
  }

  @get:JvmName("keyManager") val keyManager: X509KeyManager,
  @get:JvmName("trustManager") val trustManager: X509TrustManager,
) {
  @JvmName("-deprecated_keyManager")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "keyManager"),
    level = DeprecationLevel.ERROR,
  )
  fun keyManager(): X509KeyManager = keyManager

  @JvmName("-deprecated_trustManager")

          emptyList(),
        )
      val sslContext = SSLContext.getInstance("TLS")
      sslContext.init(
        arrayOf<KeyManager>(keyManager),
        arrayOf<TrustManager>(trustManager),
        SecureRandom(),
      )
      sslContext.socketFactory
    } catch (e: GeneralSecurityException) {
      throw AssertionError(e)
    }
  }

        .heldCertificate(certificate, intermediate.certificate)
        .build()
    assertPrivateKeysEquals(
      certificate.keyPair.private,
      handshakeCertificates.keyManager.getPrivateKey("private"),
    )
    assertThat(handshakeCertificates.keyManager.getCertificateChain("private").toList())
      .isEqualTo(listOf(certificate.certificate, intermediate.certificate))
  }

  @Test fun platformTrustedCertificates() {

    val parse: HttpUrl? = HttpUrl.parse("")
  }

  @Test @Disabled
  fun handshakeCertificates() {
    val handshakeCertificates = HandshakeCertificates.Builder().build()
    val keyManager: X509KeyManager = handshakeCertificates.keyManager()
    val trustManager: X509TrustManager = handshakeCertificates.trustManager()
  }

  @Test @Disabled
  fun handshakeCertificatesBuilder() {

import assertk.assertions.isEqualTo
import assertk.assertions.startsWith
import java.io.IOException
import java.security.SecureRandom
import java.security.cert.X509Certificate
import javax.net.ssl.KeyManager
import javax.net.ssl.SSLHandshakeException
import javax.net.ssl.SSLPeerUnverifiedException
import javax.net.ssl.SSLSocketFactory
import javax.net.ssl.TrustManager
import kotlin.test.assertFailsWith

    val chain: Interceptor.Chain = newInterceptorChain()
  }

  @Test
  fun handshakeCertificates() {
    val handshakeCertificates = HandshakeCertificates.Builder().build()
    val keyManager: X509KeyManager = handshakeCertificates.keyManager
    val trustManager: X509TrustManager = handshakeCertificates.trustManager
    val sslSocketFactory: SSLSocketFactory = handshakeCertificates.sslSocketFactory()