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._

        renderer.onOutput(complete(3))
        renderer.onOutput(updateNow())

        then:
        statusBar.display == '<===----------> 25% CONFIGURING [0ms]'

        when:
        renderer.onOutput(event4)
        renderer.onOutput(complete(4))
        renderer.onOutput(event5)
        renderer.onOutput(complete(5))
        renderer.onOutput(complete(2))
        renderer.onOutput(updateNow())

        1 * target.onOutput(event)
        0 * target._
    }

    def doesNotForwardLogLevelChangeEvents() {
        StyledTextOutputEvent event = Mock()
        StyledTextOutputEvent transformed = Mock()

        when:
        listener.onOutput(new LogLevelChangeEvent(LogLevel.ERROR))
        listener.onOutput(event)

        then:
        1 * event.withLogLevel(LogLevel.ERROR) >> transformed
        1 * target.onOutput(transformed)

        when:
        listener.onOutput(startEvent1)
        listener.onOutput(logEvent1)
        listener.onOutput(completeEvent1)
        listener.onOutput(startEvent2)
        listener.onOutput(completeEvent2)
        listener.onOutput(startEvent3)
        listener.onOutput(completeEvent3)
        listener.onOutput(startEvent4)
        listener.onOutput(logEvent4)
        listener.onOutput(completeEvent4)

    def "consume correctly LogLevelChangeEvent"() {
        when:
        renderer.onOutput(new LogLevelChangeEvent(LogLevel.WARN))
        renderer.onOutput(event("lifecycle", LogLevel.LIFECYCLE))
        renderer.onOutput(event("warn", LogLevel.WARN))

        then:
        1 * listener.onOutput({it instanceof LogLevelChangeEvent})
        1 * listener.onOutput({it instanceof LogEvent && it.message == "warn"})
        0 * _
    }

        def firstComplete = complete("task1-done")
        when:
        generator.onOutput(firstStart)
        generator.onOutput(secondStart)
        generator.onOutput(firstComplete)
        generator.onOutput(secondProgress)
        generator.onOutput(secondComplete)

        then:
        1 * target.onOutput({ StyledTextOutputEvent event ->

        renderer.onOutput(start(id: 3, parentId: 2, status: ":two:one"))
        renderer.onOutput(updateNow())
        renderer.onOutput(complete(3))
        renderer.onOutput(updateNow())
        // start a second child for 2 while it's offscreen, and complete that child too
        renderer.onOutput(start(id: 4, parentId: 2, status: ":two:two"))
        renderer.onOutput(updateNow())

        when:
        renderer.onOutput(event1)
        renderer.onOutput(event2)
        renderer.onOutput(event3)

        then:
        0 * _

        when:
        renderer.onOutput(end)

        then:
        1 * listener.onOutput(event1)
        1 * listener.onOutput(event2)
        1 * listener.onOutput(event3)
        1 * listener.onOutput(end)
        0 * _
    }

        collector.onOutput(suite, new DefaultTestOutputEvent(StdOut, "suite-out"))
        collector.onOutput(testClass, new DefaultTestOutputEvent(StdErr, "err-1"))
        collector.onOutput(testClass, new DefaultTestOutputEvent(StdErr, "err-2"))

        then:
        1 * writer.onOutput(1, new DefaultTestOutputEvent(StdErr, "err-1"))
        1 * writer.onOutput(1, new DefaultTestOutputEvent(StdErr, "err-2"))
        0 * writer._
    }

        RenderableOutputEvent event2 = new StyledTextOutputEvent(tenAm, 'category', LogLevel.INFO, null, toNative('\n'))

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

        then:
        output.value == "${tenAmFormatted} [INFO] [category] message\n"
    }