.addPlatformTrustedCertificates()
        .addInsecureHost("localhost")
        .build()

    val client = OkHttpClient.Builder()
        .sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
        .build()
    ```

 *  New: Add `cacheHit`, `cacheMiss`, and `cacheConditionalHit()` events to `EventListener`. Use

              else -> chain.proceed(chain.request())
            }
          },
        ).addNetworkInterceptor(networkInterceptor)
        .addInterceptor(applicationInterceptor)
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(hostnameVerifier)
        .build()
    host = "${server.hostName}:${server.port}"
    url = server.url("/")
  }

import assertk.assertions.isFalse
import assertk.assertions.isNull
import assertk.assertions.isTrue
import java.util.concurrent.CopyOnWriteArraySet
import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory
import kotlin.test.assertFailsWith
import okhttp3.internal.applyConnectionSpec
import okhttp3.internal.platform.Platform.Companion.isAndroid
import okhttp3.testing.PlatformRule

    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }

  @Test
  fun redirectUsingSameConnectionEventSequence() {

 *  Fix: Permit multipart file names to contain non-ASCII characters.
 *  New: API to get MockWebServer's dispatcher.
 *  New: API to access headers as `java.time.Instant`.
 *  New: Fail fast if a `SSLSocketFactory` is used as a `SocketFactory`.
 *  New: Log the TLS handshake in `LoggingEventListener`.

## Version 3.12.13

_2021-01-30_

              // noticeable memory pressure in Android apps.
//              .addPlatformTrustedCertificates()
              .build();

      builder.sslSocketFactory(certificates.sslSocketFactory(), certificates.trustManager());
    }

    OkHttpClient client = builder.build();

    sendRequest(client, "https://valid-isrgrootx1.letsencrypt.org/robots.txt");

    try {

    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .build(),
    )
    val url = server.url("/")
    val connection = url.toUrl().openConnection() as HttpsURLConnection
    connection.sslSocketFactory = handshakeCertificates.sslSocketFactory()
    connection.hostnameVerifier = RecordingHostnameVerifier()

      platform.assumeHttp2Support()
      server.useHttps(handshakeCertificates.sslSocketFactory())
      client =
        clientTestRule
          .newClientBuilder()
          .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
          .sslSocketFactory(
            handshakeCertificates.sslSocketFactory(),
            handshakeCertificates.trustManager,

  private fun doServerHandshake(server: HandshakeCertificates): Future<Handshake> {
    return executorService.submit<Handshake> {
      serverSocket!!.accept().use { rawSocket ->
        val sslSocket =
          server.sslSocketFactory().createSocket(
            rawSocket,
            rawSocket.inetAddress.hostAddress,
            rawSocket.port,
            true,
          ) as SSLSocket
        sslSocket.use {

    server.useHttps(handshakeCertificates.sslSocketFactory(), false)
    server.enqueue(MockResponse().setBody("abc"))
    val url = server.url("/")
    val connection = url.toUrl().openConnection() as HttpsURLConnection
    connection.setSSLSocketFactory(handshakeCertificates.sslSocketFactory())
    connection.setHostnameVerifier(RecordingHostnameVerifier())