Kotlin does have properties and we take advantage of them in OkHttp.

 * **Address**: certificatePinner, connectionSpecs, dns, hostnameVerifier, protocols, proxy,
   proxyAuthenticator, proxySelector, socketFactory, sslSocketFactory, url
 * **Cache**: directory
 * **CacheControl**: immutable, maxAgeSeconds, maxStaleSeconds, minFreshSeconds, mustRevalidate,
   noCache, noStore, noTransform, onlyIfCached, sMaxAgeSeconds

  @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

      assertThat(

	public final fun -deprecated_socketFactory ()Ljavax/net/SocketFactory;
	public final fun -deprecated_sslSocketFactory ()Ljavax/net/ssl/SSLSocketFactory;
	public final fun -deprecated_url ()Lokhttp3/HttpUrl;

        .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 =
          sslSocket.apply {

        .writeTimeout(2, SECONDS)
        .readTimeout(2, SECONDS)
        .apply {
          if (socketMode is TlsInstance) {
            if (socketMode.socketMode == Channel) {
              socketFactory(ChannelSocketFactory())
            }

            connectionSpecs(
              listOf(
                ConnectionSpec
                  .Builder(ConnectionSpec.COMPATIBLE_TLS)

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

      Platform
        .get()
        .newSSLContext()
        .apply {
          init(null, arrayOf(trustManager), null)
        }.socketFactory

    private fun createInsecureHostnameVerifier(): HostnameVerifier = HostnameVerifier { _, _ -> true }
  }

    server.enqueue(MockResponse())
    client =
      client
        .newBuilder()
        .socketFactory(uselessSocketFactory)
        .build()
    assertFailsWith<IllegalArgumentException> {
      getResponse(newRequest("/"))
    }
    client =
      client
        .newBuilder()
        .socketFactory(SocketFactory.getDefault())
        .build()
    val response = getResponse(newRequest("/"))

    }

  override fun newSslSocketFactory(trustManager: X509TrustManager): SSLSocketFactory =
    newSSLContext()
      .apply {
        init(null, arrayOf<TrustManager>(trustManager), null)
      }.socketFactory

  companion object {
    val isSupported: Boolean =
      try {
        // Trigger an early exception over a fatal error, prefer a RuntimeException over Error.

    sslContext.init(arrayOf(keyManager), arrayOf(trustManager), SecureRandom())

    val client =
      OkHttpClient
        .Builder()
        .sslSocketFactory(sslContext.socketFactory, trustManager)
        .build()

    // An example test URL that returns client certificate details.
    val request =
      Request
        .Builder()
        .url("https://prod.idrix.eu/secure/")