logFile = File("/tmp/key.log"), tlsVersions = tlsVersions, launch = launch)`
 * 3. Register with `client.eventListenerFactory(eventListenerFactory)`
 * 4. Launch wireshark if not done externally `val process = eventListenerFactory.launchWireShark()`
 */
@SuppressSignatureCheck
class WireSharkListenerFactory(
  private val logFile: File,
  private val tlsVersions: List<TlsVersion>,
  private val launch: Launch? = null,

        this.tlsVersions = null
      }

    fun tlsVersions(vararg tlsVersions: TlsVersion): Builder =
      apply {
        require(tls) { "no TLS versions for cleartext connections" }

        val strings = tlsVersions.map { it.javaName }.toTypedArray()
        return tlsVersions(*strings)
      }

    fun tlsVersions(vararg tlsVersions: String) =
      apply {

    socket.supportedCipherSuites = arrayOf("TLS_A")
    socket.enabledCipherSuites = arrayOf("TLS_A")
    val connectionSpec =
      ConnectionSpec
        .Builder(true)
        .tlsVersions(TlsVersion.TLS_1_1, TlsVersion.TLS_1_2, TlsVersion.TLS_1_3)
        .cipherSuites("TLS_A")
        .build()
    applyConnectionSpec(connectionSpec, socket, false)
    assertArrayEquals(arrayOf("TLSv1.1", "TLSv1.2"), socket.enabledProtocols)

          .containsExactly(
            TlsVersion.SSL_3_0.javaName,
            TlsVersion.TLS_1_1.javaName,
            TlsVersion.TLS_1_2.javaName,
          )
      }
    } else {
      if (majorVersion > 11) {
        assertThat(sslSocket.enabledProtocols)
          .containsExactly(
            TlsVersion.SSL_3_0.javaName,
            TlsVersion.TLS_1_1.javaName,
            TlsVersion.TLS_1_2.javaName,

      enabledProtocols = javaNames(*tlsVersions)
    }

  private fun assertEnabledProtocols(
    socket: SSLSocket,
    vararg required: TlsVersion,
  ) {
    assertThat(socket.enabledProtocols.toList()).containsExactlyInAnyOrder(*javaNames(*required))
  }

  private fun javaNames(vararg tlsVersions: TlsVersion) = tlsVersions.map { it.javaName }.toTypedArray()

 */
private val TLS_13 =
  ConnectionSpec
    .Builder(true)
    .cipherSuites(*TLS13_CIPHER_SUITES.toTypedArray())
    .tlsVersions(TlsVersion.TLS_1_3)
    .build()

private val TLS_12 =
  ConnectionSpec
    .Builder(ConnectionSpec.RESTRICTED_TLS)
    .tlsVersions(TlsVersion.TLS_1_2)
    .build()

private fun testClient(
  urls: List<String>,
  client: OkHttpClient,
) {
  try {

    val proxy: Proxy = route.proxy()
    val inetSocketAddress: InetSocketAddress = route.socketAddress()
  }

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

  }

  @Test
  fun testSessionReuse(tlsVersion: String = burstValues("TLSv1.2", "TLSv1.3")) {
    if (tlsVersion == TlsVersion.TLS_1_3.javaName) {
      assumeTrue(PlatformVersion.majorVersion != 8)
    }

    val sessionIds = mutableListOf<String>()

    enableTls()

    val tlsVersion = TlsVersion.forJavaName(tlsVersion)
    val spec =
      ConnectionSpec

  }

  @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 {

    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) {