import okio.buffer
import okio.source

/** A basic HTTP/2 server that serves the contents of a local directory.  */
class Http2Server(
  private val baseDirectory: File,
  private val sslSocketFactory: SSLSocketFactory,
) : Http2Connection.Listener() {
  private fun run() {
    val serverSocket = ServerSocket(8888)
    serverSocket.reuseAddress = true
    while (true) {
      var socket: Socket? = null
      try {

                  .build(),
              ),
            )

            val sslSocketFactory = handshakeCertificates.sslSocketFactory()

            sslSocketFactory(
              sslSocketFactory,
              handshakeCertificates.trustManager,
            )

            when (socketMode.protocol) {

      message = "Use the sslSocketFactory overload that accepts a X509TrustManager.",
      level = DeprecationLevel.ERROR,
    )
    fun sslSocketFactory(sslSocketFactory: SSLSocketFactory) =
      apply {
        if (sslSocketFactory != this.sslSocketFactoryOrNull) {
          this.routeDatabase = null
        }

        this.sslSocketFactoryOrNull = sslSocketFactory
        this.x509TrustManagerOrNull =

    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,

        .build()

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

    if (https) {
      server.useHttps(handshakeCertificates.sslSocketFactory())
      server2.useHttps(handshakeCertificates.sslSocketFactory())
      server2.protocolNegotiationEnabled = false
      client =
        client
          .newBuilder()
          .sslSocketFactory(
            handshakeCertificates.sslSocketFactory(),
            handshakeCertificates.trustManager,

 * limitations under the License.
 */
package okhttp3

import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory
import okhttp3.FallbackTestClientSocketFactory.Companion.TLS_FALLBACK_SCSV

/**
 * An SSLSocketFactory that delegates calls. Sockets created by the delegate are wrapped with ones
 * that will not accept the [TLS_FALLBACK_SCSV] cipher, thus bypassing server-side fallback

    server.useHttps(serverCertificates.sslSocketFactory(), false);
    server.enqueue(new MockResponse());

    HandshakeCertificates clientCertificates = new HandshakeCertificates.Builder()
        .addTrustedCertificate(localhostCertificate.certificate())
        .build();
    OkHttpClient client = new OkHttpClient.Builder()
        .sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager())
        .build();

  }

  private fun enableTls() {
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }

            formatDate(1, TimeUnit.HOURS)!!,
          ),
        body = "ABC.2",
      ),
    )
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(nullHostnameVerifier)
        .build()
    val request = Request(server.url("/"))