}
      }
    if (connectionType != HTTP) {
      server.useHttps(handshakeCertificates.sslSocketFactory())
    }
    server.start()

    client =
      clientTestRule
        .newClientBuilder()
        .socketFactory(
          object : DelegatingSocketFactory(SocketFactory.getDefault()) {
            @Throws(IOException::class)
            override fun configureSocket(socket: Socket): Socket {

    if (heldCertificate != null) {
      builder.heldCertificate(heldCertificate, *intermediates)
    }
    val handshakeCertificates = builder.build()
    return clientTestRule
      .newClientBuilder()
      .sslSocketFactory(
        handshakeCertificates.sslSocketFactory(),
        handshakeCertificates.trustManager,
      ).build()
  }

  private fun buildServerSslSocketFactory(): SSLSocketFactory {

    dnsResults =
      listOf(
        localhostIpv4,
        localhostIpv6,
      )

    client =
      clientTestRule
        .newClientBuilder()
        .eventListenerFactory(clientTestRule.wrap(listener))
        .connectTimeout(60, TimeUnit.SECONDS) // Deliberately exacerbate slow fallbacks.
        .dns { dnsResults }
        .fastFallback(true)

  val webSocketListener =
    object : WebSocketListener() {
    }
  val dispatcher = Dispatcher(executor)
  val listener = RecordingEventListener()
  var client =
    clientTestRule
      .newClientBuilder()
      .dns { throw UnknownHostException() }
      .dispatcher(dispatcher)
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()

  @BeforeEach
  fun setUp() {

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

  private val clientListener = WebSocketRecorder("client")
  private val serverListener = WebSocketRecorder("server")
  private val random = Random(0)
  private var client =
    clientTestRule
      .newClientBuilder()
      .writeTimeout(Duration.ofMillis(500))
      .readTimeout(Duration.ofMillis(500))
      .addInterceptor(
        Interceptor { chain: Interceptor.Chain ->

  private var listener = RecordingEventListener()
  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()
  private val executorService = Executors.newScheduledThreadPool(1)

  @BeforeEach
  fun setUp() {
    platform.assumeNotOpenJSSE()

  public val clientTestRule =
    OkHttpClientTestRule().apply {
      logger = Logger.getLogger(OkHttpTest::class.java.name)
    }

  private var client: OkHttpClient =
    clientTestRule
      .newClientBuilder()
      .addInterceptor(CompressionInterceptor(Zstd, Brotli, Gzip))
      .build()

  private val moshi =
    Moshi
      .Builder()
      .add(KotlinJsonAdapterFactory())
      .build()

  private val listener: RecordingEventListener = RecordingEventListener()
  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()
  private var socksProxy: SocksProxy? = null
  private var cache: Cache? = null

  @BeforeEach
  fun setUp() {

  private var listener = RecordingEventListener()
  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()
  private val callback = RecordingCallback()
  private val cache =
    Cache(
      fileSystem = LoggingFilesystem(fileSystem),