}
        }

        @Override
        public void close() {
            output.close();
            writeIndex();
        }

        public void onOutput(long classId, TestOutputEvent outputEvent) {
            onOutput(classId, 0, outputEvent);
        }

        public void onOutput(long classId, long testId, TestOutputEvent outputEvent) {

        OutputEventListener outputEventListener = context.getOutputEventListener();
        try {
            outputEventListener.onOutput(logEvent);
        } catch (Throwable e) {
            // fall back to standard out
            e.printStackTrace(System.out);
        }
    }

            testListener.afterSuite(test, result);
        } else {
            testListener.afterTest(test, result);
        }
    }

    @Override
    public void output(TestDescriptorInternal test, TestOutputEvent event) {
        testOutputListener.onOutput(test, event);
    }

    private final Closeable closeable;

    /**
     * Creates a text output which forwards text to the given listener.
     * @param listener The listener.
     */
    public StreamingStyledTextOutput(StandardOutputListener listener) {
        this(listener, listener);
    }

    /**
     * Creates a text output which writes text to the given appendable.
     * @param appendable The appendable.
     */

        redirector.errForwarder.outputOwner == "2"
    }

    def "passes output events"() {
        def f = new TestOutputRedirector.Forwarder(processor, TestOutputEvent.Destination.StdErr)
        f.outputOwner = "5"

        when: f.onOutput("ala")

        then:
        1 * processor.output("5", { DefaultTestOutputEvent e ->
            e.destination == TestOutputEvent.Destination.StdErr

    }

    @Override
    public void onOutput(OutputEvent event) {
        queue.add(event);

        if (event instanceof UpdateNowEvent) {
            renderNow();
        } else if (event instanceof EndOutputEvent) {
            progressArea.setVisible(false);
        }

        listener.onOutput(event);
    }

            System.err.println "before"

            def output = new CollectingListener()
            def error = new CollectingListener()
            logging.addStandardOutputListener(output)
            logging.addStandardErrorListener(error)

            System.out.println "output 1"
            assert output.toString().readLines() == ["output 1"]
            System.err.println "error 1"

        spans.add(new StyledTextOutputEvent.Span(this.style, buffer.toString()));
        buffer.setLength(0);
        OperationIdentifier buildOperationId = CurrentBuildOperationRef.instance().getId();
        listener.onOutput(new StyledTextOutputEvent(clock.getCurrentTime(), category, logLevel, buildOperationId, spans));
        spans = new ArrayList<StyledTextOutputEvent.Span>();
    }

    private final TestStyledTextOutput output = new TestStyledTextOutput()

    def onOutputWritesText() {
        when:
        output.onOutput('some message')

        then:
        output.value == 'some message'
    }

    def writesNullText() {
        when:
        output.text(null)

        then:
        output.value == 'null'
    }

    def writesEndOfLine() {

        }

        @Override
        public void onOutput(CharSequence output) {
            if (outputOwner == null) {
                throw new RuntimeException("Unable send output event from test executor. Please report this problem. Destination: " + dest + ", event: " + output.toString());
            }
            processor.output(outputOwner, new DefaultTestOutputEvent(dest, output.toString()));
        }
    }