then:
        InvalidUserDataException e = thrown()
        e.message == "Not a supported repository protocol 'unsupported': valid protocols are [protocol1, protocol2a, protocol2b]"
    }

    def "cannot creates a transport for mixed url scheme"() {
        when:
        createTransport(['protocol1', 'protocol2b'] as Set, null, [])

        then:
        InvalidUserDataException e = thrown()

        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")
        }

	filteredProtocols := []string{}
	for _, protocolHeader := range req.Header[protocolHeader] {
		for _, protocol := range strings.Split(protocolHeader, ",") {
			protocol = strings.TrimSpace(protocol)

			if !strings.HasPrefix(protocol, bearerProtocolPrefix) {
				filteredProtocols = append(filteredProtocols, protocol)
				continue
			}

			if sawTokenProtocol {

type Instance struct {
	e           *executor
	protocolMap map[scheme.Instance]protocol
	protocols   []protocol
}

// New creates a new forwarder Instance.
func New() *Instance {
	var protocols []protocol
	add := func(p protocol) protocol {
		protocols = append(protocols, p)
		return p
	}

	// Create the protocols and populate the map.
	e := newExecutor()
	protocolMap := make(map[scheme.Instance]protocol)

        listener.withWorkerLoggingProtocol(protocol2) {
            listener.onOutput(logEvent2)
            listener.onOutput(logEvent3)
        }
        listener.onOutput(logEvent4)

        then:
        1 * protocol1.sendOutputEvent(logEvent1)
        1 * protocol2.sendOutputEvent(logEvent2)
        1 * protocol2.sendOutputEvent(logEvent3)
        1 * protocol1.sendOutputEvent(logEvent4)
    }

			}

			// 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
}

		return MySQL
	}

	return Unsupported
}

// IsHTTP2 is true for protocols that use HTTP/2 as transport protocol
func (i Instance) IsHTTP2() bool {
	switch i {
	case HTTP2, GRPC, GRPCWeb:
		return true
	default:
		return false
	}
}

// IsHTTPOrSniffed is true for protocols that use HTTP as transport protocol, or *can* use it if sniffed to be HTTP
func (i Instance) IsHTTPOrSniffed() bool {

          val protocol = peerProtocols[i] as String
          if (protocol in protocols) {
            selected = protocol
            return selected
          }
        }
        selected = protocols[0] // On no intersection, try peer's first protocol.
        return selected
      } else if ((methodName == "protocolSelected" || methodName == "selected") && callArgs.size == 1) {

      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 {