* limitations under the License.
 */

package org.gradle.api.tasks.testing;

/**
 * Standard output or standard error message logged during the execution of the test
 */
public interface TestOutputEvent {

    /**
     * Destination of the message
     */
    Destination getDestination();

    /**
     * Message content
     */
    String getMessage();

    /**

 * <p>
 * A new test output event instance is created for each line of text printed by the test.
 *
 * @since 6.0
 */
public interface TestOutputEvent extends ProgressEvent {

    @Override
    TestOutputDescriptor getDescriptor();

        long testId
        TestOutputEvent testOutputEvent

        BuildableOutputEvent(long testId, TestOutputEvent testOutputEvent) {
            this.testId = testId
            this.testOutputEvent = testOutputEvent
        }
    }

    class BuildableTestClassResult extends TestClassResult {
        List<BuildableOutputEvent> outputEvents = []

        long duration = 1000

        events.find { TestOutputEvent event -> event.descriptor.message == "err1" && event.descriptor.destination == Destination.StdErr }
        events.find { TestOutputEvent event -> event.descriptor.message == "out2" && event.descriptor.destination == Destination.StdOut }
        events.find { TestOutputEvent event -> event.descriptor.message == "err2" && event.descriptor.destination == Destination.StdErr }
    }

        1 * provider1.writeTestOutput(12, 11, TestOutputEvent.Destination.StdOut, writer)
        1 * provider1.writeNonTestOutput(12, TestOutputEvent.Destination.StdOut, writer)

        when:
        provider.hasOutput(2, TestOutputEvent.Destination.StdOut)
        provider.writeAllOutput(2, TestOutputEvent.Destination.StdOut, writer)

        then:

            }
        });
        return hasOutput[0];
    }

    @Override
    public boolean hasOutput(long classId, long testId, TestOutputEvent.Destination destination) {
        return false;
    }

    @Override
    public void writeAllOutput(final long classId, final TestOutputEvent.Destination destination, final Writer writer) {
        withReader(new Action<TestOutputStore.Reader>() {
            @Override

        this.redirector = redirector;
        this.outForwarder = new Forwarder(processor, TestOutputEvent.Destination.StdOut);
        this.errForwarder = new Forwarder(processor, TestOutputEvent.Destination.StdErr);
    }

    public void startRedirecting() {
        assert outForwarder.outputOwner != null;
        assert errForwarder.outputOwner != null;

        redirector.redirectStandardOutputTo(outForwarder);

    public void writeNonTestOutput(long classId, TestOutputEvent.Destination destination, Writer writer) {
        for (DelegateProvider delegateProvider : classOutputProviders.get(classId)) {
            delegateProvider.provider.writeNonTestOutput(delegateProvider.id, destination, writer);
        }
    }

    @Override
    public void writeTestOutput(long classId, long testId, TestOutputEvent.Destination destination, Writer writer) {

     *
     * Writes all output for the test class.
     */
    void writeAllOutput(long classId, TestOutputEvent.Destination destination, Writer writer);

    void writeNonTestOutput(long classId, TestOutputEvent.Destination destination, Writer writer);

    /**
     * Writes the output of the given test to the given writer. This method must be called only after {@link #visitClasses(org.gradle.api.Action)}.

package org.gradle.tooling.events.test.internal;

import org.gradle.tooling.events.test.TestOutputDescriptor;
import org.gradle.tooling.events.test.TestOutputEvent;

/**
 * Implementation of the {@code TestOutputEvent} interface.
 */
public final class DefaultTestOutputEvent implements TestOutputEvent {

    private final long eventTime;
    private final TestOutputDescriptor descriptor;