assertThat(server.protocols[0]).isEqualTo(Protocol.H2_PRIOR_KNOWLEDGE)
  }

  @Test
  fun https() {
    val handshakeCertificates = platform.localhostHandshakeCertificates()
    server.useHttps(handshakeCertificates.sslSocketFactory(), false)
    server.enqueue(MockResponse().setBody("abc"))
    val url = server.url("/")
    val connection = url.toUrl().openConnection() as HttpsURLConnection

        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())

    defaultEnabledCipherSuites =
      handshakeCertificates.sslSocketFactory().defaultCipherSuites.toList()
    defaultSupportedCipherSuites =

        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.protocols = protocols.toList()
  }

  private fun upgradeRequest() =
    Request(
      url = server.url("/"),
      headers =
        headersOf(

        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }
}

@Flaky // STDOUT logging enabled for test
@Timeout(30)
@Tag("Slow")
class ConnectionListenerLegacyTest : ConnectionListenerTest() {

  fun wsScheme() {
    assumeNotWindows()
    websocketScheme("ws")
  }

  @Test
  fun wsUppercaseScheme() {
    websocketScheme("WS")
  }

  @Test
  fun wssScheme() {
    webServer.useHttps(handshakeCertificates.sslSocketFactory())
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,

    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }

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

          serverSocket.receiveBufferSize = SOCKET_BUFFER_SIZE
          return serverSocket
        }
      }
    if (connectionType != HTTP) {
      server.useHttps(handshakeCertificates.sslSocketFactory())
    }
    server.start()

    client =
      clientTestRule
        .newClientBuilder()
        .socketFactory(

    assertThat(server.protocols[0]).isEqualTo(Protocol.H2_PRIOR_KNOWLEDGE)
  }

  @Test
  fun https() {
    val handshakeCertificates = platform.localhostHandshakeCertificates()
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .build(),
    )
    val url = server.url("/")

      localhostInsecureRequest()
    } finally {
      Security.removeProvider("GmsCore_OpenSSL")
      client.close()
    }
  }

  private fun localhostInsecureRequest() {
    server.useHttps(handshakeCertificates.sslSocketFactory())

    server.enqueue(MockResponse())

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

    client.newCall(request).execute().use {

        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }

  /** A request body that slowly trickles bytes, expecting to not complete. */
  private object SlowRequestBody : RequestBody() {