val sslContext =
      Platform.get().newSSLContext().apply {
        init(null, arrayOf(trustManager), null)
      }
    val sslSocketFactory = sslContext.socketFactory

    val hostnameVerifier = HostnameVerifier { _, _ -> true }

    client =
      client.newBuilder()
        .sslSocketFactory(sslSocketFactory, trustManager)
        .hostnameVerifier(hostnameVerifier)
        .build()

        trustManagerFactory.init(keyStoreFactory.loadOrCreateKeyStore())
        val trustManager = trustManagerFactory.trustManagers.first() as X509TrustManager

        sslSocketFactory(socketFactory, trustManager)
      }
  }

    val trustManager = RecordingTrustManager(handshakeCertificates.trustManager)
    val sslContext = get().newSSLContext()
    sslContext.init(null, arrayOf<TrustManager>(trustManager), null)
    client =
      client.newBuilder()
        .hostnameVerifier(hostnameVerifier)
        .sslSocketFactory(sslContext.socketFactory, trustManager)
        .build()

                if ("all".equals(trustManager)) {
                    ftpsClient.setTrustManager(TrustManagerUtils.getAcceptAllTrustManager());
                } else if ("valid".equals(trustManager)) {
                    ftpsClient.setTrustManager(TrustManagerUtils.getValidateServerCertificateTrustManager());
                } else if ("none".equals(trustManager)) {
                    ftpsClient.setTrustManager(null);

                sessionIds.add(sslSocket.session.id.toByteString().hex())
              }
            },
          ),
        )
        .sslSocketFactory(sslSocketFactory, handshakeCertificates.trustManager)
        .build()

    server.enqueue(MockResponse(body = "abc1"))
    server.enqueue(MockResponse(body = "abc2"))

    val request = Request(server.url("/"))

import org.gradle.test.fixtures.server.http.HttpServerFixture

import javax.net.ssl.KeyManager
import javax.net.ssl.KeyManagerFactory
import javax.net.ssl.SSLContext
import javax.net.ssl.TrustManager
import javax.net.ssl.TrustManagerFactory
import java.security.Key
import java.security.KeyStore
import java.security.cert.Certificate

@CompileStatic
class TestKeyStore {
    TestFile trustStore

     * sslContext.init(null, new TrustManager[] { trustManager }, null);
     * SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
     *
     * OkHttpClient client = new OkHttpClient.Builder()
     *     .sslSocketFactory(sslSocketFactory, trustManager)
     *     .build();
     * ```
     *
     * ## TrustManagers on Android are Weird!
     *

      clientTestRule.newClientBuilder()
        .fastFallback(false) // Avoid data races.
        .dns(dns)
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .build()
    val serverHandshakeCertificates =
      HandshakeCertificates.Builder()
        .heldCertificate(certificate)
        .build()

        override fun connectFailed(
          uri: URI,
          socketAddress: SocketAddress,
          e: IOException,
        ) {}
      }

    val trustManager = get().platformTrustManager()
    val sslContext = get().newSSLContext()
    sslContext.init(null, null, null)

    // new client, may share all same fields but likely different connection pool
    assertNotSame(

        .build()

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