StreamingStyledTextOutput output = new StreamingStyledTextOutput(listener)

        when:
        output.text('text')

        then:
        1 * listener.onOutput('text')
    }

    def forwardsTextToAnAppendable() {
        Appendable appendable = Mock()
        StreamingStyledTextOutput output = new StreamingStyledTextOutput(appendable)

        when:
        output.text('text')

        then:

        when:
        bridge.onOutput(eventWithBuildOperationId)

        then:
        1 * buildOperationProgressEventEmitter.emit(_, _, _) >> { OperationIdentifier operationIdentifier, long timestamp, Object details ->
            assert operationIdentifier == testOperationId
            assert details == eventWithBuildOperationId
        }


        when:
        bridge.onOutput(eventWithFallbackBuildOperationId)

                        useJUnitJupiter()
                    }
                }
            }
            tasks.test {
                onOutput(
                    KotlinClosure2<TestDescriptor, TestOutputEvent, Any>({ descriptor, event ->
                        println("onOutput:" + descriptor.displayName + ":" + event.message)
                    })
                )
            }

        this.stdoutChain = stdoutChain;
        this.stderrChain = stderrChain;
    }

    @Override
    public void onOutput(OutputEvent event) {
        if (event.getLogLevel() == null) {
            dispatch(event, stdoutChain);
            dispatch(event, stderrChain);
        } else if (event.getLogLevel() == LogLevel.ERROR) {

        }

        TestMethodResult methodResult = currentTestMethods.get(testDescriptor);
        if (methodResult == null) {
            outputWriter.onOutput(classResult.getId(), outputEvent);
        } else {
            outputWriter.onOutput(classResult.getId(), methodResult.getId(), outputEvent);
        }
    }

    private static String findEnclosingClassName(TestDescriptor testDescriptor) {

        this.delegate = delegate;
        this.console = console;
    }

    @Override
    public void onOutput(OutputEvent event) {
        delegate.onOutput(event);
        if (event instanceof UpdateNowEvent || event instanceof EndOutputEvent) {
            console.flush();
        }
    }

    public <T> T forwardInput(Function<StdinHandler, T> action) {
        final StdInStream stdInStream = new StdInStream(new OutputEventListener() {
            @Override
            public void onOutput(OutputEvent event) {
                eventDispatch.onOutput(event);
            }
        });
        inputReader.startInput();

        StdinHandler stdinHandler = new StdinHandler() {
            @Override

        @Override
        public void onOutput(CharSequence output) {
        }
    }

    private static class WriteAction implements TextStream {
        private OutputListener destination;

        @Override
        public void text(String message) {
            destination.onOutput(message);
        }

        @Override

            if (interrupted.get()) {
                return null;
            }

            if (!hasPrompted) {
                eventDispatch.onOutput(new UserInputRequestEvent());
                hasPrompted = true;
            }

            eventDispatch.onOutput(prompt);
            while (true) {
                UserInputReader.UserInput input = userInputReader.readInput();

/**
 * <p>A {@code StandardOutputListener} receives text written by Gradle's logging system to standard output or
 * error.</p>
 */
public interface StandardOutputListener {
    /**
     * Called when some output is written by the logging system.
     *
     * @param output The text.
     */
    void onOutput(CharSequence output);