def logger

                public void onOutput(TestDescriptor descriptor, TestOutputEvent event) {
                    logger.lifecycle(descriptor.toString() + " " + event.destination + " " + event.message);
                }
            }

            class RemoveMeListener implements TestOutputListener {
                public void onOutput(TestDescriptor descriptor, TestOutputEvent event) {

    }

    @Override
    public void onOutput(OutputEvent event) {
        if (event.getLogLevel() != null && event.getLogLevel().compareTo(logLevel) < 0) {
            return;
        }
        if (event instanceof LogLevelChangeEvent) {
            LogLevelChangeEvent changeEvent = (LogLevelChangeEvent) event;
            logLevel = changeEvent.getNewLogLevel();
        }
        listener.onOutput(event);
    }

 * limitations under the License.
 */

package org.gradle.internal.logging.events;

public interface OutputEventListener {
    void onOutput(OutputEvent event);

    OutputEventListener NO_OP = new OutputEventListener() {
        @Override
        public void onOutput(OutputEvent event) {
        }
    };

    public AbstractUserInputRenderer(OutputEventListener delegate, GlobalUserInputReceiver userInput) {
        this.delegate = delegate;
        this.userInput = userInput;
    }

    @Override
    public void onOutput(OutputEvent event) {
        if (event instanceof UserInputRequestEvent) {
            handleUserInputRequestEvent();
            return;
        } else if (event instanceof UserInputResumeEvent) {

        @Override
        public String getName() {
            return path.getFileName().toString();
        }

        @Override
        public OutputStream openOutput() throws IOException {
            return AbstractFileAccessor.this.openOutput(path);
        }

        @Override
        public DataSource toSource() throws IOException {
            return new Source(path);
        }
    }

    private final OutputEventListener broadcaster = new OutputEventListener() {
        @Override
        public void onOutput(OutputEvent event) {
            renderer.onOutput(event);

            OutputEventListener otherRef = other;
            if (otherRef != null) {
                otherRef.onOutput(event);
            }
        }
    };

    public OutputEventListenerManager(OutputEventListener renderer) {

    private final DataTarget delegate;

    public DelegatingDataTarget(DataTarget delegate) {
        this.delegate = delegate;
    }

    @Override
    public OutputStream openOutput() throws IOException {
        return delegate.openOutput();
    }

    @Override
    public DataSource toSource() throws IOException {
        return delegate.toSource();
    }

    @Override
    public String getName() {

        delegate.pack(inputs, new DelegatingDataTarget(output) {
            @Override
            public OutputStream openOutput() throws IOException {
                return new FramedSnappyCompressorOutputStream(super.openOutput());
            }
        });
    }

    @Override
    public void unpack(DataSource input, DataTargetFactory targetFactory) throws IOException {

  ArgView output_arg = op_.OnlyOutput();
  Statement("int num_retvals = $0.size()", output_arg.VariableName());
  Statement("return " + Call(op_.VariableName(), "Execute",
                             {output_arg.VariableName(), "&num_retvals"}));
}

void OpImplementationRenderer::RenderExecutionSingleOutput() {
  ArgView output_arg = op_.OnlyOutput();
  Statement("int num_retvals = 1");

        } else if (!(event instanceof ProgressEvent)) {
            listener.onOutput(event);
        }
    }

    private void doOutput(RenderableOutputEvent event) {
        for (Operation operation : operations.values()) {
            operation.completeHeader();
        }
        listener.onOutput(event);
    }

    private void onComplete(ProgressCompleteEvent progressCompleteEvent) {