) {
    this.server1 = server
    this.server2 = server2

    socketFactory = SpecificHostSocketFactory(InetSocketAddress(server.hostName, server.port))

    client =
      clientTestRule.newClientBuilder()
        .dns(dns)
        .socketFactory(socketFactory)
        .eventListenerFactory(clientTestRule.wrap(listener))
        .build()
  }

  @Test

        .build()
  }

  @Test
  fun clientAuthForWants() {
    val client = buildClient(clientCert, clientIntermediateCa.certificate)
    val socketFactory = buildServerSslSocketFactory()
    server.useHttps(socketFactory)
    server.requestClientAuth()
    server.enqueue(
      MockResponse.Builder()
        .body("abc")
        .build(),
    )

    // 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()

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

    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()

      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

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

    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

  }

  @Test fun sslSocketFactorySetAsSocketFactory() {
    val builder = OkHttpClient.Builder()
    assertFailsWith<IllegalArgumentException> {
      builder.socketFactory(SSLSocketFactory.getDefault())
    }
  }

  @Test fun noSslSocketFactoryConfigured() {
    val client =
      OkHttpClient.Builder()
        .connectionSpecs(listOf(ConnectionSpec.CLEARTEXT))

  open fun newSslSocketFactory(trustManager: X509TrustManager): SSLSocketFactory {
    try {
      return newSSLContext().apply {
        init(null, arrayOf<TrustManager>(trustManager), null)
      }.socketFactory
    } catch (e: GeneralSecurityException) {
      throw AssertionError("No System TLS: $e", e) // The system has no TLS. Just give up.
    }
  }

  override fun toString(): String = javaClass.simpleName