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

    }

    private String join(String message1, String message2) {
        String message = "";

        if (message1 != null && !message1.isEmpty()) {
            message = message1.trim();
        }

        if (message2 != null && !message2.isEmpty()) {
            if (message != null && !message.isEmpty()) {
                if (message.endsWith(".") || message.endsWith("!") || message.endsWith(":")) {

    def "each outgoing message is dispatched in order to connection"() {
        def messages = new CopyOnWriteArrayList()
        RemoteConnection<InterHubMessage> outgoing = Mock()
        def connection = new MockOutgoingConnection(outgoing)

        given:
        outgoing.dispatch({ it instanceof ChannelMessage }) >> { ChannelMessage message ->
            messages.add(message.payload)
            if (messages.size() == 20) {

        collector.add(null, "MESSAGE1", -1, -1, null);

        Exception e2 = new Exception();
        collector.add(Severity.WARNING, null, 42, 127, e2);

        assertEquals(2, collector.getProblems().size());

        Problem p1 = collector.getProblems().get(0);
        assertEquals(Severity.ERROR, p1.getSeverity());
        assertEquals("MESSAGE1", p1.getMessage());

    // Empty server to client message.
    val message3 = ""
    server.send(message3)
    clientListener.assertTextMessage(message3)

    // Empty client to server message.
    val message4 = ""
    client.send(message4)
    serverListener.assertTextMessage(message4)

    // Server to client message that shares context with message1.
    val message5 = message1 + message1

        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: