override fun secureConnectEnd(handshake: Handshake?) {
    eventListener.secureConnectEnd(call, handshake)
  }

  override fun callConnectEnd(
    route: Route,
    protocol: Protocol?,
  ) {
    eventListener.connectEnd(call, route.socketAddress, route.proxy, protocol)
  }

  override fun connectionConnectEnd(
    connection: Connection,
    route: Route,
  ) {
    poolConnectionListener.connectEnd(connection, route, call)

    assertThat(Protocol.SPDY_3.toString()).isEqualTo("spdy/3.1")
    assertThat(Protocol.HTTP_2.toString()).isEqualTo("h2")
    assertThat(Protocol.H2_PRIOR_KNOWLEDGE.toString())
      .isEqualTo("h2_prior_knowledge")
    assertThat(Protocol.QUIC.toString()).isEqualTo("quic")
    assertThat(Protocol.HTTP_3.toString()).isEqualTo("h3")
  }

      assertThat(response.protocol).isEqualTo(Protocol.HTTP_2)
    }
  }

  @Test
  fun testOkHttpSecureProxiedHttp1() {
    testRequest {
      val client =
        OkHttpClient
          .Builder()
          .trustMockServer()
          .proxy(Proxy(Proxy.Type.HTTP, it.remoteAddress()))
          .protocols(listOf(Protocol.HTTP_1_1))
          .build()

      val response =

  private val http2Connection: Http2Connection,
) : ExchangeCodec {
  @Volatile private var stream: Http2Stream? = null

  private val protocol: Protocol =
    if (Protocol.H2_PRIOR_KNOWLEDGE in client.protocols) {
      Protocol.H2_PRIOR_KNOWLEDGE
    } else {
      Protocol.HTTP_2
    }

  @Volatile
  private var canceled = false

  override val isResponseComplete: Boolean

import java.net.ProtocolException
import okhttp3.Protocol
import okhttp3.Response
import okio.IOException

/** An HTTP response status line like "HTTP/1.1 200 OK". */
class StatusLine(
  @JvmField val protocol: Protocol,
  @JvmField val code: Int,
  @JvmField val message: String,
) {
  override fun toString(): String =
    buildString {
      if (protocol == Protocol.HTTP_1_0) {
        append("HTTP/1.0")
      } else {

  }

  override fun callConnectEnd(
    route: Route,
    protocol: Protocol?,
  ) {
  }

  override fun connectionConnectEnd(
    connection: Connection,
    route: Route,
  ) {
  }

  override fun connectFailed(
    route: Route,
    protocol: Protocol?,
    e: IOException,
  ) {
  }

  override fun connectionAcquired(connection: Connection) {
  }

   */
  private fun enableProtocol(protocol: Protocol) {
    enableTls()
    client =
      client
        .newBuilder()
        .protocols(listOf(protocol, Protocol.HTTP_1_1))
        .build()
    server.protocols = client.protocols
  }

  private fun enableTls() {
    client =
      client
        .newBuilder()

    val s = sslSocket as BCSSLSocket

    return when (val protocol = s.applicationProtocol) {
      null, "" -> null
      else -> protocol
    }
  }

  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<Protocol>,
  ) {
    // No TLS extensions if the socket class is custom.
    if (matchesSocket(sslSocket)) {

    try {
      // SSLSocket.getApplicationProtocol returns "" if application protocols values will not
      // be used. Observed if you didn't specify SSLParameters.setApplicationProtocols
      when (val protocol = sslSocket.applicationProtocol) {
        null, "" -> null
        else -> protocol
      }
    } catch (e: UnsupportedOperationException) {

}

public final class okhttp3/Protocol : java/lang/Enum {
	public static final field Companion Lokhttp3/Protocol$Companion;
	public static final field H2_PRIOR_KNOWLEDGE Lokhttp3/Protocol;
	public static final field HTTP_1_0 Lokhttp3/Protocol;
	public static final field HTTP_1_1 Lokhttp3/Protocol;
	public static final field HTTP_2 Lokhttp3/Protocol;
	public static final field HTTP_3 Lokhttp3/Protocol;