renderer.addOutputEventListener(listener)
        renderer.onOutput(start)
        renderer.onOutput(progress)
        renderer.onOutput(complete)

        then:
        1 * listener.onOutput({it instanceof LogLevelChangeEvent && it.newLogLevel == logLevel})
        1 * listener.onOutput(start)
        1 * listener.onOutput(progress)
        1 * listener.onOutput(complete)
        0 * listener._

        where:

        def testOutputEvent2 = new TestOutputEvent()
        renderer.onOutput(testOutputEvent1)
        renderer.onOutput(testOutputEvent2)

        then:
        0 * console._
        0 * listener.onOutput(_)
        renderer.eventQueue.size() == 2

        when:
        renderer.onOutput(userInputResumeEvent)

        then:
        1 * console.buildOutputArea >> textArea

        when:
        renderer.onOutput(userInputResumeEvent)

        then:
        1 * listener.onOutput(userInputResumeEvent)
        1 * listener.onOutput(testOutputEvent1)
        1 * listener.onOutput(testOutputEvent2)
        0 * listener.onOutput(_)
        0 * userInput._
        renderer.eventQueue.empty
    }

    def "passes through other events than user input events"() {
        given:

        then:
        1 * outputEventBroadcaster.onOutput(_ as UserInputRequestEvent)
        1 * outputEventBroadcaster.onOutput(_) >> { YesNoQuestionPromptEvent event ->
            assert event.question == 'question?'
        }
        1 * userInputReader.readInput() >> new UserInputReader.TextResponse(enteredUserInput)
        1 * outputEventBroadcaster.onOutput(_ as UserInputResumeEvent)
        0 * outputEventBroadcaster._

        then:
        3 * stdErrListener.onOutput('[SEVERE] Test' + EOL)
        3 * stdErrListener.onOutput('[WARNING] Test' + EOL)
        3 * stdErrListener.onOutput('[INFO] Test' + EOL)
        2 * stdErrListener.onOutput('[CONFIG] Test' + EOL)
        2 * stdErrListener.onOutput('[FINE] Test' + EOL)
        2 * stdErrListener.onOutput('[FINER] Test' + EOL)
        1 * stdErrListener.onOutput('[FINEST] Test' + EOL)
        0 * _

        }

        void bufferOutput(RenderableOutputEvent output) {
            // Forward output immediately when the focus is on this operation group
            if (Objects.equal(buildOpIdentifier, lastRenderedBuildOpId)) {
                listener.onOutput(output);
                lastUpdateTime = currentTimePeriod;
                needHeaderSeparator = true;
            } else {

        redirector.start()
        System.out.println('this is stdout')
        System.err.println('this is stderr')
        redirector.stop()

        then:
        1 * stdOutListener.onOutput('this is stdout' + EOL)
        0 * stdOutListener._
        System.out == outputs.stdOutPrintStream
        System.err == outputs.stdErrPrintStream
    }

    def startAndStopRedirectsStdErr() {
        when:

                        @Override
                        public void onOutput(OutputEvent event) {
                            // Do not forward events for rendering when there are no listeners to receive
                            if (event instanceof LogLevelChangeEvent) {
                                stdOutChain.onOutput(event);
                                stdErrChain.onOutput(event);

            stream.received(bytes1)
            thread.blockUntil.requested2
            stream.received(bytes2)
        }

        then:
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested1 }
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested2 }
    }

    def "read bytes returns when stream is closed"() {
        def dispatch = Mock(OutputEventListener)

        } else if (!(event instanceof ProgressEvent)) {
            listener.onOutput(event);
        }
    }

    private void doOutput(RenderableOutputEvent event) {
        for (Operation operation : operations.values()) {
            operation.completeHeader();
        }
        listener.onOutput(event);
    }

    private void onComplete(ProgressCompleteEvent progressCompleteEvent) {