queue.dispatch(message)
        queue.dispatch(message2)
        def messages1 = []
        endpoint1.take(messages1)
        def messages2 = []
        endpoint2.take(messages2)

        then:
        messages1 == [message]
        messages2 == [message]
    }

    def "forwards broadcast messages to all endpoints when nothing queued"() {
        given:
        def message = broadcast()

        when:
        def messages1 = []
        def messages2 = []
        queue.queue(message1)
        queue.queue(message2)
        endpoint1.take(messages1)
        endpoint2.take(messages2)

        then:
        messages1 == [message1, message2]
        messages2 == [message2]
    }

    def "forwards most recent stateful broadcast messages to all new queues"() {

        e.message == 'Cannot wait for messages to be dispatched, as there are no dispatch threads running.'
    }

    def 'cannot dispatch messages after stop'() {
        given:
        dispatch.stop()

        when:
        dispatch.dispatch('message')

        then:
        IllegalStateException e = thrown()

        def channelId = new ChannelIdentifier("channel name")
        def message1 = new ChannelMessage(channelId, "payload 1")
        def message2 = new ChannelMessage(channelId, "payload 2")

        given:
        def message1Serialized = serialize(message1)
        def message2Serialized = serialize(message2)

        when:
        def serialized = serialize(message1, message2)
        def result = deserializeMultiple(serialized, 2)

class ModelBuildingExceptionTest {

    @Test
    void testMessage() {
        DefaultModelProblem pb1 =
                new DefaultModelProblem("message1", ModelProblem.Severity.ERROR, null, "source", 0, 0, "modelId", null);
        DefaultModelProblem pb2 =
                new DefaultModelProblem("message2", ModelProblem.Severity.ERROR, null, "source", 0, 0, "modelId", null);

        RenderableOutputEvent event1 = new StyledTextOutputEvent(tenAm, 'category', LogLevel.INFO, null, 'message')
        RenderableOutputEvent event2 = new StyledTextOutputEvent(tenAm, 'category2', LogLevel.INFO, null, 'message2')

        when:
        renderer.onOutput(new LogLevelChangeEvent(LogLevel.DEBUG))
        renderer.onOutput(event1)
        renderer.onOutput(event2)

        RuntimeException failure2 = new RuntimeException('broken2')

        when:
        dispatch.dispatchFailed("message1", failure1)
        dispatch.dispatchFailed("message2", failure2)
        dispatch.stop()

        then:
        def e = thrown(DispatchException)
        e.cause == failure1
        1 * logger.error('broken2', failure2)
        0 * logger._
    }

        0 * listener._

        when:
        output.text('line').println()

        then:
        1 * listener.onOutput({ it.spans[0].text == toNative('another line\n') })
        0 * listener._
    }

    def forwardsEachLineOfTextToListener() {
        when:
        output.text(toNative('message1\nmessage2')).println()

        then:

package diag

import (
	"sort"
)

// Messages is a slice of Message items.
type Messages []Message

// Add a new message to the messages
func (ms *Messages) Add(m ...Message) {
	*ms = append(*ms, m...)
}

// Sort the message lexicographically by level, code, resource origin name, then string.
func (ms *Messages) Sort() {
	sort.Slice(*ms, func(i, j int) bool {
		a, b := (*ms)[i], (*ms)[j]

const (
	SysMetrics SysType = iota
	SysStats
)

// ParseRIB parses b as a routing information base and returns a list
// of routing messages.
func ParseRIB(typ RIBType, b []byte) ([]Message, error) {
	if !typ.parseable() {
		return nil, errUnsupportedMessage
	}
	var msgs []Message
	nmsgs, nskips := 0, 0
	for len(b) > 4 {
		nmsgs++
		l := int(nativeEndian.Uint16(b[:2]))
		if l == 0 {
			return nil, errInvalidMessage