socket.enabledCipherSuites = arrayOf("SSL_A", "SSL_B", "SSL_C")
    val connectionSpec =
      ConnectionSpec
        .Builder(true)
        .tlsVersions(TlsVersion.TLS_1_0)
        .cipherSuites("TLS_A", "TLS_C", "TLS_E")
        .build()
    applyConnectionSpec(connectionSpec, socket, false)
    assertArrayEquals(arrayOf("TLS_A", "TLS_C"), socket.enabledCipherSuites)
  }

  @Test

          }
    }
  }
}

@SuppressSignatureCheck
class WiresharkExample(
  tlsVersions: List<TlsVersion>,
  private val launch: Launch? = null,
) {
  private val connectionSpec =
    ConnectionSpec
      .Builder(ConnectionSpec.RESTRICTED_TLS)
      .tlsVersions(*tlsVersions.toTypedArray())
      .build()

  private val eventListenerFactory =
    WireSharkListenerFactory(

        val connectionSpec = connectionSpecs[tlsEquipPlan.connectionSpecIndex]

        // Figure out the next connection spec in case we need a retry.
        retryTlsConnection = tlsEquipPlan.nextConnectionSpec(connectionSpecs, sslSocket)

        connectionSpec.apply(sslSocket, isFallback = tlsEquipPlan.isTlsFallback)
        connectTls(sslSocket, connectionSpec)

  }

  @Test @Disabled
  fun connectionSpec() {
    val connectionSpec: ConnectionSpec = ConnectionSpec.RESTRICTED_TLS
    val tlsVersions: List<TlsVersion>? = connectionSpec.tlsVersions()
    val cipherSuites: List<CipherSuite>? = connectionSpec.cipherSuites()
    val supportsTlsExtensions: Boolean = connectionSpec.supportsTlsExtensions()
  }

  @Test @Disabled
  fun cookie() {

  }

  @Test
  fun connectionSpec() {
    var connectionSpec: ConnectionSpec = ConnectionSpec.RESTRICTED_TLS
    connectionSpec = ConnectionSpec.MODERN_TLS
    connectionSpec = ConnectionSpec.COMPATIBLE_TLS
    connectionSpec = ConnectionSpec.CLEARTEXT
    val tlsVersions: List<TlsVersion>? = connectionSpec.tlsVersions
    val cipherSuites: List<CipherSuite>? = connectionSpec.cipherSuites

internal fun cacheGet(
  cache: Cache,
  request: Request,
): Response? = cache.get(request)

internal fun applyConnectionSpec(
  connectionSpec: ConnectionSpec,
  sslSocket: SSLSocket,
  isFallback: Boolean,
) = connectionSpec.apply(sslSocket, isFallback)

internal fun ConnectionSpec.effectiveCipherSuites(socketEnabledCipherSuites: Array<String>): Array<String> =
  if (cipherSuitesAsString != null) {
    // 3 options here for ordering

      client
        .newBuilder()
        .sslSocketFactory(CustomSSLSocketFactory(client.sslSocketFactory), client.x509TrustManager!!)
        .connectionSpecs(
          listOf(
            ConnectionSpec
              .Builder(ConnectionSpec.MODERN_TLS)
              .supportsTlsExtensions(false)
              .build(),
          ),
        ).eventListener(
          object : EventListener() {

}

public final class okhttp3/ConnectionSpec {
	public static final field CLEARTEXT Lokhttp3/ConnectionSpec;
	public static final field COMPATIBLE_TLS Lokhttp3/ConnectionSpec;
	public static final field Companion Lokhttp3/ConnectionSpec$Companion;
	public static final field MODERN_TLS Lokhttp3/ConnectionSpec;
	public static final field RESTRICTED_TLS Lokhttp3/ConnectionSpec;

  }

  @Test fun someFallbacksSupported() {
    val sslV3 =
      ConnectionSpec
        .Builder(ConnectionSpec.MODERN_TLS)
        .tlsVersions(TlsVersion.SSL_3_0)
        .build()
    val routePlanner = factory.newRoutePlanner(client)
    val route = factory.newRoute()
    val connectionSpecs = listOf(ConnectionSpec.MODERN_TLS, ConnectionSpec.COMPATIBLE_TLS, sslV3)
    val enabledSocketTlsVersions =
      arrayOf(

    }

    val sessionIds = mutableListOf<String>()

    enableTls()

    val tlsVersion = TlsVersion.forJavaName(tlsVersion)
    val spec =
      ConnectionSpec
        .Builder(ConnectionSpec.MODERN_TLS)
        .tlsVersions(tlsVersion)
        .build()

    var reuseSession = false

    val sslContext = handshakeCertificates.sslContext()