}

  private fun enableTls() {
    client =
      client.newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .hostnameVerifier(RecordingHostnameVerifier())
        .build()
    server1.useHttps(handshakeCertificates.sslSocketFactory())
    server2.useHttps(handshakeCertificates.sslSocketFactory())
  }

        .body("ABC")
        .build(),
    )
    client =
      client.newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .hostnameVerifier(NULL_HOSTNAME_VERIFIER)
        .build()
    val request = Request.Builder().url(server.url("/")).build()
    val response1 = client.newCall(request).execute()

  }

  @Test
  fun equalsFromTrustManager() {
    val handshakeCertificates = HandshakeCertificates.Builder().build()
    val x509TrustManager = handshakeCertificates.trustManager
    assertThat(get(x509TrustManager)).isEqualTo(get(x509TrustManager))
  }

  @Test
  fun normalizeSingleSelfSignedCertificate() {
    val root =
      HeldCertificate.Builder()
        .serialNumber(1L)

    server.enqueue(MockResponse())

    client =
      clientTestRule.newClientBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .hostnameVerifier(RecordingHostnameVerifier())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())

    defaultEnabledCipherSuites =

      )
    }
  }

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

  @RetryingTest(5)
  @Flaky
  fun testHeadAfterPut() {
    class ErringRequestBody : RequestBody() {

    client =
      clientTestRule.newClientBuilder()
        .eventListenerFactory(loggingEventListenerFactory)
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .retryOnConnectionFailure(false)
        .build()
    url = server.url("/")
  }

  @Test
  fun get() {
    assumeNotWindows()
    server.enqueue(
      MockResponse.Builder()

  }

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

@Flaky // STDOUT logging enabled for test

              return socket
            }
          },
        )
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .eventListener(listener)
        .apply {
          if (connectionType == HTTPS) {
            protocols(listOf(HTTP_1_1))
          }
        }
        .build()

    webServer.useHttps(handshakeCertificates.sslSocketFactory())
    client =
      client.newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .hostnameVerifier(RecordingHostnameVerifier())
        .build()
    websocketScheme("wss")
  }

  @Test
  fun httpsScheme() {

  }

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

  private inner class DelayedRequestBody(