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

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import javax.net.SocketFactory;
import jnr.unixsocket.UnixSocketChannel;

/** Impersonate TCP-style SocketFactory over UNIX domain sockets. */
public final class UnixDomainSocketFactory extends SocketFactory {
  private final File path;

  public UnixDomainSocketFactory(File path) {
    this.path = path;
  }

     * [SocketFactory.createSocket] method to create unconnected sockets. Overriding this method,
     * e. g., allows the socket to be bound to a specific local address.
     *
     * If unset, the [system-wide default][SocketFactory.getDefault] socket factory will be used.
     */
    fun socketFactory(socketFactory: SocketFactory) =
      apply {

    factory.close()
  }

  @Test
  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

    // Yield the first IP address so the second IP address completes first.
    val firstConnectLatch = CountDownLatch(1)
    val socketFactory =
      object : DelegatingSocketFactory(SocketFactory.getDefault()) {
        var first = true

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

 * 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 = SocketChannel.open().socket()

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

  @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;

    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