if (open) {
            delegate.text(text);
        } else {
            open = true;
        }
    }

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

        when:
        skipper.text("a")
        skipper.endOfStream(null)

        then:
        1 * delegate.endOfStream(null)
        0 * delegate._
    }

    def "does not skip EOS if before first"() {
        given:
        def delegate = Mock(TextStream)
        def skipper = new SkipFirstTextStream(delegate)

        when:
        skipper.endOfStream(null)

        then:
        1 * delegate.endOfStream(null)

        then:
        1 * action.text("text")
        1 * action.endOfStream(null)
        0 * action._
    }

    def closeDoesNothingWhenNothingWritten() {
        TextStream action = Mock()
        def outstr = new LinePerThreadBufferingOutputStream(action)

        when:
        outstr.close()

        then:
        1 * action.endOfStream(null)
        0 * action._
    }

        try {
            delegate.write(text);
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    @Override
    public void endOfStream(@Nullable Throwable failure) {
        try {
            delegate.close();
        } catch (IOException e) {
            if (failure == null) {
                throw UncheckedException.throwAsUncheckedException(e);

    void text(String text);

    /**
     * Called when the end of the stream is reached for some reason.
     *
     * @param failure The failure, if any, which caused the end of the stream.
     */
    void endOfStream(@Nullable Throwable failure);

        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();
        }
    }

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)