given:
        def testOutputEvent = new TestOutputEvent()

        when:
        renderer.onOutput(testOutputEvent)

        then:
        0 * console._
        1 * listener.onOutput(testOutputEvent)
        renderer.eventQueue.empty
    }

    private static class TestOutputEvent extends OutputEvent {
        @Override
        LogLevel getLogLevel() {

package org.gradle.api.internal.tasks.testing

import org.gradle.api.tasks.testing.TestOutputEvent

class MethodTestOutputEvent {
    String testMethodName
    TestOutputEvent testOutputEvent

    MethodTestOutputEvent(String testMethodName, TestOutputEvent testOutputEvent) {
        this.testMethodName = testMethodName
        this.testOutputEvent = testOutputEvent
    }

                        .characters("");
                    resultsProvider.writeAllOutput(classId, TestOutputEvent.Destination.StdOut, htmlWriter);
                        htmlWriter.endElement()
                    .endElement();
                }
            });
        }
        if (resultsProvider.hasOutput(classId, TestOutputEvent.Destination.StdErr)) {
            addTab("Standard error", new ErroringAction<SimpleHtmlWriter>() {

 * limitations under the License.
 */

package org.gradle.api.internal.tasks.testing.junit.result;

import org.gradle.api.Action;
import org.gradle.api.tasks.testing.TestOutputEvent;

import java.io.Writer;

public class InMemoryTestResultsProvider extends TestOutputStoreBackedResultsProvider {
    private final Iterable<TestClassResult> results;

import org.gradle.api.internal.tasks.testing.TestDescriptorInternal
import org.gradle.api.tasks.testing.TestOutputEvent
import org.gradle.test.fixtures.file.WorkspaceTest

import static org.gradle.api.tasks.testing.TestOutputEvent.Destination.StdErr
import static org.gradle.api.tasks.testing.TestOutputEvent.Destination.StdOut

class TestOutputStoreSpec extends WorkspaceTest {

        given:
        def testOutputEvent = new TestOutputEvent()

        when:
        renderer.onOutput(testOutputEvent)

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

    private static class TestOutputEvent extends OutputEvent {
        @Override
        LogLevel getLogLevel() {

        when:
        redirector.setOutputOwner("1")
        redirector.startRedirecting()

        then:
        1 * redir.redirectStandardErrorTo({ it.dest == TestOutputEvent.Destination.StdErr })
        1 * redir.redirectStandardOutputTo({ it.dest == TestOutputEvent.Destination.StdOut })

        then:
        1 * redir.start()
        0 * _
    }

    def "disallows starting redirecting if test owner not provided"() {

            writeIndex();
        }

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

        public void onOutput(long classId, long testId, TestOutputEvent outputEvent) {
            boolean stdout = outputEvent.getDestination() == TestOutputEvent.Destination.StdOut;
            mark(classId, testId, stdout);

                writeOutputs(writer, classId, !options.outputPerTestCase, TestOutputEvent.Destination.StdOut);
                writer.endElement();
            }

            if (options.includeSystemErrLog) {
                writer.startElement("system-err");
                writeOutputs(writer, classId, !options.outputPerTestCase, TestOutputEvent.Destination.StdErr);
                writer.endElement();
            }

    }

    def stderr(String output) {
        outputEvents << new MethodTestOutputEvent(name, new DefaultTestOutputEvent(TestOutputEvent.Destination.StdErr, output))
    }

    def stdout(String output) {
        outputEvents << new MethodTestOutputEvent(name, new DefaultTestOutputEvent(TestOutputEvent.Destination.StdOut, output))
    }

    static class TestResultException extends Exception {