}
        for (DataReporter<CrossVersionPerformanceResults> reporter : reporters) {
            reporter.report(results);
        }
    }

    @Override
    public void close() throws IOException {
        for (DataReporter<CrossVersionPerformanceResults> reporter : reporters) {
            reporter.close();
        }
    }

    def mockLogger = Mock(Logger)

    def 'reporter logs only invalid installations'() {
        given:
        def reporter = new InvalidInstallationWarningReporter(mockLogger)
        def location = InstallationLocation.userDefined(new File("_"), "_")
        def metadata = Mock(JvmInstallationMetadata) {
            isValidInstallation() >> isValid
        }

        when:
        reporter.accept(location, metadata)

        then:

// A reporter reports output, warnings, and errors.
type reporter struct {
	prev  <-chan *reporterState
	state *reporterState
}

// reporterState carries the state of a reporter instance.
//
// Only one reporter at a time may have access to a reporterState.
type reporterState struct {
	out, err io.Writer
	exitCode int
}

// getState blocks until any prior reporters are finished with the reporter

    @Nonnull
    private final BiConsumer<InstallationLocation, JvmInstallationMetadata> reporter;

    public ReportingJvmMetadataDetector(@Nonnull JvmMetadataDetector delegate, @Nonnull BiConsumer<InstallationLocation, JvmInstallationMetadata> reporter) {
        this.delegate = delegate;
        this.reporter = reporter;
    }

    @Override

    }

    def doesNothingWhenBuildIsSuccessful() {
        expect:
        reporter.buildFinished(result(null))
        output.value == ''
    }

    def reportsBuildFailure() {
        GradleException exception = new GradleException(MESSAGE);

        expect:
        reporter.buildFinished(result(exception))
        output.value == """

// into a watch.Interface.
type StreamWatcher struct {
	sync.Mutex
	source   Decoder
	reporter Reporter
	result   chan Event
	done     chan struct{}
}

// NewStreamWatcher creates a StreamWatcher from the given decoder.
func NewStreamWatcher(d Decoder, r Reporter) *StreamWatcher {
	sw := &StreamWatcher{
		source:   d,
		reporter: r,
		// It's easy for a consumer to add buffering via an extra

    final Action<ExecutionListener> target = Mock()
    final ExecutionListener listener = Mock()
    final Action<Throwable> reporter = Mock()
    final LoggingOutputInternal loggingOutput = Mock()
    final ExceptionReportingAction action = new ExceptionReportingAction(reporter, loggingOutput, target)

    def "executes Action"() {
        when:
        action.execute(listener)

        then:

			continue
		}
		var distributionState Progress
		for reporter, w := range fractions {
			// check for stale data here
			if c.clock.Since(c.ObservationTime[reporter]) > c.StaleInterval {
				scope.Warnf("Status reporter %s has not been heard from since %v, deleting report.",
					reporter, c.ObservationTime[reporter])
				staleReporters = append(staleReporters, reporter)
			} else {
				distributionState.PlusEquals(w)
			}

class TaskExecutionStatisticsReporterTest extends Specification {
    def textOutputFactory = new TestStyledTextOutputFactory()
    def reporter = new TaskExecutionStatisticsReporter(textOutputFactory)

    def "does not report statistics given 0 tasks"() {
        when:
        reporter.buildFinished(new TaskExecutionStatistics(0, 0, 0))

        then:
        (textOutputFactory as String) == ""
        0 * _
    }

        def location = InstallationLocation.userDefined(new File("jdkHome"), "test")
        def metadata = Mock(JvmInstallationMetadata)
        def reporter = Mock(BiConsumer)
        def delegate = Mock(JvmMetadataDetector)

        def detector = new ReportingJvmMetadataDetector(delegate, reporter)

        when:
        def actual1 = detector.getMetadata(location)
        def actual2 = detector.getMetadata(location)

        then: