addToIncoming(new StreamFailureMessage(e));
                            continue;
                        }
                        if (message == null || message instanceof EndOfStream) {
                            return;
                        }
                        addToIncoming(message);
                    }
                } finally {
                    lock.lock();

        private OutputListener destination;

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

        @Override
        public void endOfStream(@Nullable Throwable failure) {
        }

        public void setDestination(OutputListener destination) {
            this.destination = destination;
        }
    }

     * cannot be reopened.
     */
    @Override
    public void close() throws IOException {
        hasBeenClosed = true;
        flush();
        handler.endOfStream(null);
    }

    /**
     * Writes the specified byte to this output stream. The general contract for <code>write</code> is that one byte is

    public void close() {
        PrintStream currentStream = maybeGetStream();
        if (currentStream != null) {
            stream.remove();
            currentStream.close();
        } else {
            handler.endOfStream(null);
        }
    }

    @Override
    public void flush() {
        PrintStream stream = maybeGetStream();
        if (stream != null) {
            stream.flush();
        }
    }

import org.gradle.internal.remote.internal.hub.protocol.ChannelIdentifier
import org.gradle.internal.remote.internal.hub.protocol.ChannelMessage
import org.gradle.internal.remote.internal.hub.protocol.EndOfStream
import org.gradle.internal.remote.internal.hub.protocol.InterHubMessage
import org.gradle.test.fixtures.concurrent.ConcurrentSpec
import spock.lang.Timeout

import java.util.concurrent.BlockingQueue

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

        @Override
        public void endOfStream(@Nullable Throwable failure) {
        }
    });
    private PrintStreamDestination original;
    private boolean enabled;
    private LogLevel logLevel;
    private final StandardOutputListener listener;

                    }
                }
            }
        }
    }

    @Override
    public void endOfStream(@Nullable Throwable failure) {
        if (failure != null) {
            synchronized (testDescriptors) {
                Object testId;
                if (!testDescriptors.isEmpty()) {

Class <org.gradle.internal.remote.internal.hub.protocol.EndOfStream> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (EndOfStream.java:0)