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 -> QUIC
        else -> {
          // Support HTTP3 draft like h3-29
          if (protocol.startsWith(HTTP_3.protocol)) HTTP_3 else throw IOException("Unexpected protocol: $protocol")
        }

			}

			// Default protocol is TCP
			protocol := sPort.Protocol
			if protocol == "" {
				protocol = core_v1.ProtocolTCP
			}

			// Appending the service information for the Port/Protocol combination
			portMap[sPort.Port][protocol] = append(portMap[sPort.Port][protocol], swn.Name)
		}
	}

	return portMap
}

      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.Builder()

		}
	}
}

// handshake ensures the provided user protocol matches one of the allowed protocols. It returns
// no error if no protocol is specified.
func handshake(config *websocket.Config, req *http.Request, allowed []string) error {
	protocols := config.Protocol
	if len(protocols) == 0 {
		protocols = []string{""}
	}

	for _, protocol := range protocols {
		for _, allow := range allowed {
			if allow == protocol {

      .assertSuccessful()
      .assertCode(200)
  }

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

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

		{25, "", nil, corev1.ProtocolTCP, protocol.TCP},
		{53, "", nil, corev1.ProtocolTCP, protocol.TCP},
		{3306, "", nil, corev1.ProtocolTCP, protocol.TCP},
		{27017, "", nil, corev1.ProtocolTCP, protocol.TCP},
		{8888, "http", nil, corev1.ProtocolTCP, protocol.HTTP},
		{8888, "http-test", nil, corev1.ProtocolTCP, protocol.HTTP},
		{8888, "http", nil, corev1.ProtocolUDP, protocol.UDP},

    app: my-service
  ports:
  - name: tcp-foo
    protocol: TCP
    port: 8080
    targetPort: 8080
---
# Service is mixed with port protocols, should generate warning.
apiVersion: v1
kind: Service
metadata:
  name: mixed-port-protocol
  namespace: my-namespace
spec:
  type: ClusterIP
  selector:
    app: my-service
  ports:
  - name: tcp
    protocol: TCP
    port: 8080

   */
  var protocols: List<Protocol> = immutableListOf(Protocol.HTTP_2, Protocol.HTTP_1_1)
    set(value) {
      val protocolList = value.toImmutableList()
      require(Protocol.H2_PRIOR_KNOWLEDGE !in protocolList || protocolList.size == 1) {
        "protocols containing h2_prior_knowledge cannot use other protocols: $protocolList"
      }

    app: my-service
  ports:
  - name: tcp-foo
    protocol: TCP
    port: 8080
    targetPort: 8080
---
# Service is mixed with port protocols, should generate warning.
apiVersion: v1
kind: Service
metadata:
  name: mixed-port-protocol
  namespace: my-namespace
spec:
  type: ClusterIP
  selector:
    app: my-service
  ports:
  - name: http
    protocol: TCP
    port: 8080

     *
     * @param protocols the protocols to use, in order of preference. If the list contains
     *     [Protocol.H2_PRIOR_KNOWLEDGE] then that must be the only protocol and HTTPS URLs will not
     *     be supported. Otherwise the list must contain [Protocol.HTTP_1_1]. The list must
     *     not contain null or [Protocol.HTTP_1_0].
     */
    fun protocols(protocols: List<Protocol>) =
      apply {