ianaSuites = ianaSuites,
  )
}

fun systemDefault(
  name: String,
  version: String,
  ianaSuites: IanaSuites,
): Client {
  val socketFactory = SSLSocketFactory.getDefault() as SSLSocketFactory
  val sslSocket = socketFactory.createSocket() as SSLSocket

  return Client(
    userAgent = name,
    version = version,
    enabled = sslSocket.enabledCipherSuites.map { ianaSuites.fromJavaName(it) },

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

    proxy: Proxy? = null,
    proxySelector: ProxySelector = this.proxySelector,
  ): Address {
    return Address(
      uriHost = uriHost,
      uriPort = uriPort,
      dns = dns,
      socketFactory = SocketFactory.getDefault(),
      sslSocketFactory = null,
      hostnameVerifier = null,
      certificatePinner = null,
      proxyAuthenticator = proxyAuthenticator,
      proxy = proxy,
      protocols = protocols,

    factory.close()
  }

  @Test @Disabled
  fun address() {
    val address: Address = factory.newAddress()
    val url: HttpUrl = address.url()
    val dns: Dns = address.dns()
    val socketFactory: SocketFactory = address.socketFactory()
    val proxyAuthenticator: Authenticator = address.proxyAuthenticator()
    val protocols: List<Protocol> = address.protocols()
    val connectionSpecs: List<ConnectionSpec> = address.connectionSpecs()

 * limitations under the License.
 */
package okhttp3

import java.net.InetAddress
import java.net.Socket
import java.nio.channels.SocketChannel
import javax.net.SocketFactory

class ChannelSocketFactory : SocketFactory() {
  override fun createSocket(): Socket {
    return SocketChannel.open().socket()
  }

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

      server.useHttps(handshakeCertificates.sslSocketFactory())
    }
    server.start()

    client =
      clientTestRule.newClientBuilder()
        .socketFactory(
          object : DelegatingSocketFactory(SocketFactory.getDefault()) {
            @Throws(IOException::class)
            override fun configureSocket(socket: Socket): Socket {
              socket.sendBufferSize = SOCKET_BUFFER_SIZE

import java.security.PrivateKey
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import java.util.concurrent.Future
import javax.net.ServerSocketFactory
import javax.net.SocketFactory
import javax.net.ssl.SSLSocket
import okhttp3.Handshake
import okhttp3.Handshake.Companion.handshake
import okhttp3.TestUtil.threadFactory
import okhttp3.internal.closeQuietly
import okhttp3.testing.PlatformRule

  @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 client =
      OkHttpClient.Builder()
        .dns(AsyncDns.toDns(AndroidAsyncDns.IPv4, AndroidAsyncDns.IPv6))
        .socketFactory(network.socketFactory)
        .build()

    val call =
      client.newCall(Request("https://google.com/robots.txt".toHttpUrl()))

    call.execute().use { response ->
      assertThat(response.code).isEqualTo(200)

        .signedBy(compromisedIntermediateCa)
        .commonName(server.hostName)
        .build()
    val socketFactory =
      newServerSocketFactory(
        rogueCertificate,
        compromisedIntermediateCa.certificate,
        goodCertificate.certificate,
      )
    server.useHttps(socketFactory)
    server.enqueue(
      MockResponse.Builder()
        .body("abc")