connectTls(sslSocket, connectionSpec)
        user.secureConnectEnd(handshake)
      } else {
        socket = rawSocket
        protocol =
          when {
            Protocol.H2_PRIOR_KNOWLEDGE in route.address.protocols -> Protocol.H2_PRIOR_KNOWLEDGE
            else -> Protocol.HTTP_1_1
          }
      }

      val connection =
        RealConnection(
          taskRunner = taskRunner,

    val i = HttpLoggingInterceptor()

    builder.interceptors().add(i)
    builder.networkInterceptors().add(i)
  }

  @Test
  fun protocol() {
    var protocol: Protocol = Protocol.HTTP_2
    protocol = Protocol.get("")
  }

  @Test
  fun pushPromise() {
    val pushPromise: PushPromise = PushPromise("", "", headersOf(), MockResponse())

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

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? =

      "ConnectionAcquired",
      "ConnectionReleased",
    )
  }

  @Test
  @Throws(IOException::class)
  fun secondCallEventSequence() {
    enableTls()
    server!!.protocols = listOf(Protocol.HTTP_2, Protocol.HTTP_1_1)
    server!!.enqueue(MockResponse())
    server!!.enqueue(MockResponse())

    client.newCall(Request(server!!.url("/")))
      .execute().close()

  fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<Protocol>,
  )

  fun getSelectedProtocol(sslSocket: SSLSocket): String?

    override fun getEnabledProtocols(): Array<String> {
      return enabledProtocols
    }

    override fun setEnabledProtocols(protocols: Array<String>) {
      this.enabledProtocols = protocols
    }

    override fun getSupportedCipherSuites(): Array<String> {
      return supportedCipherSuites
    }

   *
   * For cipher suites, at least one of the [required cipher suites][cipherSuites] must match the
   * socket's enabled cipher suites. If there are no required cipher suites the socket must have at
   * least one cipher suite enabled.
   *
   * For protocols, at least one of the [required protocols][tlsVersions] must match the socket's
   * enabled protocols.

    return delegate!!.supportedProtocols
  }

  override fun getEnabledProtocols(): Array<String> {
    return delegate!!.enabledProtocols
  }

  override fun setEnabledProtocols(protocols: Array<String>) {
    delegate!!.enabledProtocols = protocols
  }

  override fun getSession(): SSLSession {
    return delegate!!.session
  }

  override fun addHandshakeCompletedListener(listener: HandshakeCompletedListener) {

            sslSocketFactory(
              sslSocketFactory,
              handshakeCertificates.trustManager,
            )

            when (socketMode.protocol) {
              HTTP_2 -> protocols(listOf(HTTP_2, HTTP_1_1))
              HTTP_1_1 -> protocols(listOf(HTTP_1_1))
              else -> TODO()
            }

            val serverSslSocketFactory =

  optional int32 port = 3;

  // The application protocol for this port.
  // This is used as a hint for implementations to offer richer behavior for protocols that they understand.
  // This field follows standard Kubernetes label syntax.
  // Valid values are either:
  //
  // * Un-prefixed protocol names - reserved for IANA standard service names (as per