return when (protocol) {
        HTTP_1_0.protocol -> {
          HTTP_1_0
        }

        HTTP_1_1.protocol -> {
          HTTP_1_1
        }

        H2_PRIOR_KNOWLEDGE.protocol -> {
          H2_PRIOR_KNOWLEDGE
        }

        HTTP_2.protocol -> {
          HTTP_2
        }

        SPDY_3.protocol -> {
          SPDY_3
        }

        QUIC.protocol -> {

    }
  }

  private fun MockResponse.Builder.body(
    protocol: Protocol,
    body: String,
  ) = apply {
    when (protocol) {
      Protocol.HTTP_1_1 -> chunkedBody(body, 1024)

      // Force multiple chunks.
      else -> body(body)
    }
  }

  private fun enableProtocol(protocol: Protocol) {
    if (protocol == Protocol.HTTP_2) {
      enableTls()
      client =
        client

     *
     * @param protocol the protocol name to add (without colon suffix)
     */
    public void addWebProtocol(final String protocol) {
        final String prefix = protocol + ":";
        if (stream(webProtocols).get(stream -> stream.anyMatch(s -> s.equals(prefix)))) {
            logger.debug("Web protocols already contains: protocol={}", protocol);
            return;
        }

@Burst
class CallLimitsTest(
  private val protocol: Protocol = burstValues(Protocol.H2_PRIOR_KNOWLEDGE, Protocol.HTTP_1_1),
) {
  @RegisterExtension
  val platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server =
    MockWebServer().apply {
      protocols = listOf(protocol)
    }

  private var client =
    clientTestRule

        call.eventListener.secureConnectEnd(call, handshake)
      } else {
        javaNetSocket = 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,

      super.configureTlsExtensions(sslSocket, hostname, protocols)
    }
  }

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? =
    if (sslSocket is org.openjsse.javax.net.ssl.SSLSocket) {
      when (val protocol = sslSocket.applicationProtocol) {
        // Handles both un-configured and none selected.
        null, "" -> null

        else -> protocol
      }
    } else {

      OkHttpClient
        .Builder()
        .protocols(protocols as List<Protocol>)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("protocols must not contain null")
    }
  }

  @Test fun spdy3IsRemovedFromProtocols() {
    val protocols =
      mutableListOf(
        Protocol.HTTP_1_1,
        Protocol.SPDY_3,
      )
    val client =
      OkHttpClient

                else -> Protocol.HTTP_1_1
              }
            Platform.get().afterHandshake(sslSocket)
          } else {
            protocol = Protocol.HTTP_1_1
          }
          openClientSockets.remove(raw)
        }

        else -> {
          protocol =
            when {
              Protocol.H2_PRIOR_KNOWLEDGE in protocols -> Protocol.H2_PRIOR_KNOWLEDGE

import jakarta.validation.Payload;

public class UriTypeTest extends UnitFessTestCase {

    // Test field with UriType annotation for WEB protocol
    @UriType(protocolType = ProtocolType.WEB)
    private String testFieldWeb;

    // Test field with UriType annotation for FILE protocol
    @UriType(protocolType = ProtocolType.FILE)
    private String testFieldFile;

    // Test field with custom message

    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) {