def "adds and caches channel queue on first lookup"() {
        def id1 = new ChannelIdentifier("channel1")
        def id2 = new ChannelIdentifier("channel2")

        expect:
        def channelQueue = queue.getChannel(id1)
        channelQueue == queue.getChannel(id1)
        channelQueue != queue.getChannel(id2)
    }

    def "adds channel queue when channel message added"() {

        when:
        def dispatcher1 = hub.getOutgoing("channel1", String)
        def dispatcher2 = hub.getOutgoing("channel1", Integer)

        then:
        dispatcher1 != null
        dispatcher2 != null
        dispatcher1 != dispatcher2
    }

    def "creates a separate dispatcher for each outgoing channel"() {
        when:
        def dispatcher1 = hub.getOutgoing("channel1", String)

        client2.connectTo(server)
        server.addHandler("channel", serverHandler)
        client1.addHandler("channel", client1Handler)
        client2.addHandler("channel", client2Handler)

        def serverDispatch = server.createOutgoing("channel")
        def client1Dispatch = client1.createOutgoing("channel")
        def client2Dispatch = client2.createOutgoing("channel")

        when:
        serverDispatch.dispatch("message 1")

        result[0] instanceof ChannelMessage
        result[0].channel == channelId
        result[0].payload == "payload 1"
        result[1] instanceof ChannelMessage
        result[1].channel == channelId
        result[1].payload == "payload 2"
        serialized.length < message1Serialized.length + message2Serialized.length
    }

    def "can serialize messages for multiple channels"() {
        def channelId1 = new ChannelIdentifier("channel 1")

            int channelNum = decoder.readSmallInt();
            ChannelIdentifier channelId = channels.get(channelNum);
            if (channelId == null) {
                String channel = decoder.readString();
                channelId = new ChannelIdentifier(channel);
                channels.put(channelNum, channelId);
            }
            return channelId;
        }
    }

				conn.channels[channel].Close() // After first Close, other closes are noop.
			}
			continue
		}
		channel := data[0]
		if conn.codec == base64Codec {
			channel = channel - '0'
		}
		data = data[1:]
		if int(channel) >= len(conn.channels) {
			klog.V(6).Infof("Frame is targeted for a reader %d that is not valid, possible protocol error", channel)
			continue
		}

				WebSocketProtocolHeader: "v4.channel.k8s.io, v5.channel.k8s.io, v3.channel.k8s.io",
			},
			expected: true,
		},

		"Websocket connection upgrade headers key is case-insensitive": {
			headers: map[string]string{
				"Connection":             "upgrade",
				"Upgrade":                "websocket",
				"sec-websocket-protocol": "v4.channel.k8s.io, v5.channel.k8s.io, v3.channel.k8s.io",
			},
			expected: true,

	}
}

// createChannels returns the standard channel types for a shell connection (STDIN 0, STDOUT 1, STDERR 2)
// along with the approximate duplex value. It also creates the error (3) and resize (4) channels.
func createChannels(opts Options) []wsstream.ChannelType {
	// open the requested channels, and always open the error channel
	channels := make([]wsstream.ChannelType, 5)
	channels[constants.StreamStdIn] = readChannel(opts.Stdin)

}

// recv processes a receive operation on a full channel c.
// There are 2 parts:
//  1. The value sent by the sender sg is put into the channel
//     and the sender is woken up to go on its merry way.
//  2. The value received by the receiver (the current G) is
//     written to ep.
//
// For synchronous channels, both values are the same.
// For asynchronous channels, the receiver gets its data from

	// Unnamed directed channels win over bidirectional channels.
	b = f(a, b)
	b = f(b, a)

	// Defined directed channels win over defined bidirectional channels.
	A = f(A, a)
	A = f(a, A)
	B = f(B, b)
	B = f(b, B)

	f(a, b, B)
	f(a, B, b)
	f(b, B, a)
	f(b, a, B)
	f(B, a, b)
	f(B, b, a)

	// Differently named channel types conflict irrespective of channel direction.