John Howard <******@****.***> 1717524306 -0700

            listener.onOutput(event);
        }
    }

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

    private void onComplete(ProgressCompleteEvent progressCompleteEvent) {
        if (operations.isEmpty()) {
            return;
        }

                    LOGGER.debug("Exception while displaying output", t);
                }
            }
        }, throttleMs, throttleMs, TimeUnit.MILLISECONDS);
    }

    @Override
    public void onOutput(OutputEvent newEvent) {
        synchronized (lock) {
            queue.add(newEvent);

            if (queue.size() == 10000) {

                        useJUnitJupiter()
                    }
                }
            }
            tasks.test {
                onOutput(
                    KotlinClosure2<TestDescriptor, TestOutputEvent, Any>({ descriptor, event ->
                        println("onOutput:" + descriptor.displayName + ":" + event.message)
                    })
                )
            }

		"7:9: declared and not used: n",
		"7:12: declared and not used: err",
	}
	outStr := string(out)
	for _, want := range wantErrs {
		if !strings.Contains(outStr, want) {
			log.Fatalf("failed to match %q\noutput: %q", want, outStr)
		}
	}

        this.listener = listener;
        this.buildStatusLabel = buildStatusLabel;
        this.console = console;
        this.consoleMetaData = consoleMetaData;
    }

    @Override
    public void onOutput(OutputEvent event) {
        if (event instanceof ProgressStartEvent) {
            ProgressStartEvent startEvent = (ProgressStartEvent) event;
            if (startEvent.isBuildOperationStart()) {

        then:
        3 * stdErrListener.onOutput('[SEVERE] Test' + EOL)
        3 * stdErrListener.onOutput('[WARNING] Test' + EOL)
        3 * stdErrListener.onOutput('[INFO] Test' + EOL)
        2 * stdErrListener.onOutput('[CONFIG] Test' + EOL)
        2 * stdErrListener.onOutput('[FINE] Test' + EOL)
        2 * stdErrListener.onOutput('[FINER] Test' + EOL)
        1 * stdErrListener.onOutput('[FINEST] Test' + EOL)
        0 * _

        }

        @Override
        public void onOutput(CharSequence output) {
            if (outputOwner == null) {
                throw new RuntimeException("Unable send output event from test executor. Please report this problem. Destination: " + dest + ", event: " + output.toString());
            }
            processor.output(outputOwner, new DefaultTestOutputEvent(dest, output.toString()));
        }
    }

        redirector.errForwarder.outputOwner == "2"
    }

    def "passes output events"() {
        def f = new TestOutputRedirector.Forwarder(processor, TestOutputEvent.Destination.StdErr)
        f.outputOwner = "5"

        when: f.onOutput("ala")

        then:
        1 * processor.output("5", { DefaultTestOutputEvent e ->
            e.destination == TestOutputEvent.Destination.StdErr

        this(new OutputStreamWriter(outputStream, Charset.defaultCharset()));
    }

    @Override
    public void onOutput(CharSequence output) {
        try {
            appendable.append(output);
            flushable.flush();
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }