arrayOf(
          TlsVersion.SSL_3_0.javaName,
          TlsVersion.TLS_1_1.javaName,
          TlsVersion.TLS_1_2.javaName,
          TlsVersion.TLS_1_3.javaName,
        )
    } else {
      sslSocket.enabledProtocols =
        arrayOf(
          TlsVersion.SSL_3_0.javaName,
          TlsVersion.TLS_1_1.javaName,
          TlsVersion.TLS_1_2.javaName,
        )
    }

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

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
      assertEquals(TlsVersion.TLS_1_3, response.handshake?.tlsVersion)
      assertEquals(Protocol.HTTP_2, response.protocol)

      assertThat(response.exchangeAccessor!!.connectionAccessor.socket())
        .isInstanceOf<SSLSocketImpl>()
    }
  }

  @Test

  }

  @Test
  fun socketPolicy() {
    val socketPolicy: SocketPolicy = SocketPolicy.KEEP_OPEN
  }

  @Test
  fun tlsVersion() {
    var tlsVersion: TlsVersion = TlsVersion.TLS_1_3
    val javaName: String = tlsVersion.javaName
    tlsVersion = TlsVersion.forJavaName("")
  }

  @Test
  fun webSocket() {
    val webSocket =
      object : WebSocket {

    var body: Buffer = recordedRequest.body
    var utf8Body: String = recordedRequest.body.readUtf8()
    var sequenceNumber: Int = recordedRequest.sequenceNumber
    var tlsVersion: TlsVersion? = recordedRequest.tlsVersion
    var handshake: Handshake? = recordedRequest.handshake
  }

  @Test @Ignore
  fun socketPolicy() {
    val socketPolicy: SocketPolicy = SocketPolicy.KEEP_OPEN
  }

    )
    assertThat(handshake.tlsVersion).isEqualTo(TlsVersion.TLS_1_2)
  }

  @Test
  fun testDefaultHandshakeCipherSuiteOrderingTls12Modern() {
    // We are avoiding making guarantees on ordering of secondary Platforms.
    platform.assumeNotConscrypt()
    platform.assumeNotBouncyCastle()

    val client = makeClient(ConnectionSpec.MODERN_TLS, TlsVersion.TLS_1_2)

    val handshake = makeRequest(client)

import okhttp3.Connection
import okhttp3.ConnectionSpec
import okhttp3.EventListener
import okhttp3.Handshake
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.TlsVersion
import okhttp3.TlsVersion.TLS_1_2
import okhttp3.TlsVersion.TLS_1_3
import okhttp3.internal.SuppressSignatureCheck
import okhttp3.recipes.kt.WireSharkListenerFactory.WireSharkKeyLoggerListener.Launch

    provider: Provider = Provider.JSSE,
    protocol: Protocol = burstValues(HTTP_1_1, HTTP_2),
    tlsVersion: TlsVersion = burstValues(TLS_1_3, TLS_1_2),
    socketMode: SocketMode = burstValues(Channel, Standard),
    tlsExtensionMode: TlsExtensionMode = TlsExtensionMode.STANDARD,
  ) {
    testConnection(TlsInstance(provider, protocol, tlsVersion, socketMode, tlsExtensionMode))
  }

  private fun testConnection(socketMode: SocketMode) {

      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }
  }

  @Test
  @Disabled
  fun testGoogle() {
    assumeNetwork()

    val request = Request.Builder().url("https://google.com/robots.txt").build()

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      if (it.handshake!!.tlsVersion != TlsVersion.TLS_1_3) {

     */
    @JvmField
    val COMPATIBLE_TLS =
      Builder(true)
        .cipherSuites(*APPROVED_CIPHER_SUITES.toTypedArray())
        .tlsVersions(TlsVersion.TLS_1_3, TlsVersion.TLS_1_2, TlsVersion.TLS_1_1, TlsVersion.TLS_1_0)
        .supportsTlsExtensions(true)
        .build()

    /** Unencrypted, unauthenticated connections for `http:` URLs. */
    @JvmField

    response.use {
      assertEquals(200, response.code)
      assertEquals(Protocol.HTTP_2, response.protocol)
      val tlsVersion = response.handshake?.tlsVersion
      assertTrue(tlsVersion == TlsVersion.TLS_1_2 || tlsVersion == TlsVersion.TLS_1_3)
      assertEquals(
        "CN=localhost",
        (response.handshake!!.peerCertificates.first() as X509Certificate).subjectDN.name,
      )
    }