try {
          trustManager = trustManagerForCertificates(trustedCertificatesInputStream());
          SSLContext sslContext = SSLContext.getInstance("TLS");
          sslContext.init(null, new TrustManager[] { trustManager }, null);
          sslSocketFactory = sslContext.getSocketFactory();
        } catch (GeneralSecurityException e) {
          throw new RuntimeException(e);
        }

        ) {}

        override fun getAcceptedIssuers(): Array<X509Certificate> = arrayOf()
      }

    val sslContext =
      Platform.get().newSSLContext().apply {
        init(null, arrayOf(trustManager), null)
      }
    val sslSocketFactory = sslContext.socketFactory

    val hostnameVerifier = HostnameVerifier { _, _ -> true }

    client =
      client.newBuilder()

  }

  @Test
  fun testUrlConnectionSecureDirect() {
    val keyStoreFactory = KeyStoreFactory(Configuration.configuration(), MockServerLogger())
    HttpsURLConnection.setDefaultSSLSocketFactory(keyStoreFactory.sslContext().socketFactory)

    testRequest {
      val url = URI(mockServer.secureEndpoint + "/person?name=peter").toURL()

      val connection = url.openConnection() as HttpURLConnection

    val spec =
      ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
        .tlsVersions(tlsVersion)
        .build()

    var reuseSession = false

    val sslContext = handshakeCertificates.sslContext()
    val systemSslSocketFactory = sslContext.socketFactory
    val sslSocketFactory =
      object : DelegatingSSLSocketFactory(systemSslSocketFactory) {
        override fun configureSocket(sslSocket: SSLSocket): SSLSocket {

 */
class BouncyCastlePlatform private constructor() : Platform() {
  private val provider: Provider = BouncyCastleJsseProvider()

  override fun newSSLContext(): SSLContext = SSLContext.getInstance("TLS", provider)

  override fun platformTrustManager(): X509TrustManager {
    val factory =
      TrustManagerFactory.getInstance(
        "PKIX",
        BouncyCastleJsseProvider.PROVIDER_NAME,

  @RegisterExtension @JvmField
  val platform = PlatformRule()

  @BeforeEach
  fun setUp() {
    platform.assumeConscrypt()
  }

  val context: SSLContext by lazy {
    val provider: Provider = Conscrypt.newProviderBuilder().provideTrustManager(true).build()

    SSLContext.getInstance("TLS", provider).apply {
      init(null, null, null)
    }
  }

  @ParameterizedTest
  @MethodSource("data")

  // See release notes https://groups.google.com/forum/#!forum/conscrypt
  // for version differences
  override fun newSSLContext(): SSLContext =
    // supports TLSv1.3 by default (version api is >= 1.4.0)
    SSLContext.getInstance("TLS", provider)

  override fun platformTrustManager(): X509TrustManager {
    val trustManagers =

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

          uri: URI,
          socketAddress: SocketAddress,
          e: IOException,
        ) {}
      }

    val trustManager = get().platformTrustManager()
    val sslContext = get().newSSLContext()
    sslContext.init(null, null, null)

    // new client, may share all same fields but likely different connection pool
    assertNotSame(
      client.routeDatabase,
      OkHttpClient.Builder()

        println("Usage: Http2Server <base directory>")
        return
      }
      val server =
        Http2Server(
          File(args[0]),
          localhost().sslContext().socketFactory,
        )
      server.run()
    }
  }