new MetricsHtml(writer) {{
            html();
                head();
                    headSection(this);
                    title().text("Flaky report for "+ history.getDisplayName()).end();
                end();
                body();
                    h2().text("Flaky report for " + history.getDisplayName()).end();
                    getGraphs(history).forEach(graph -> graph.render(this));
                end();
            end();

    }

    def "jacoco test report is skipped if no coverage data available"() {
        when:
        def executionResult = succeeds('jacocoTestReport')
        then:
        executionResult.assertTaskSkipped(':jacocoTestReport')
    }

    def "can use coverage data from previous run for coverage report"() {
        when:
        succeeds('jacocoTestReport')

        then:

		if err := processFile("standard input", true); err != nil {
			report(err)
		}
		os.Exit(exitCode)
	}

	for i := 0; i < flag.NArg(); i++ {
		path := flag.Arg(i)
		switch dir, err := os.Stat(path); {
		case err != nil:
			report(err)
		case dir.IsDir():
			walkDir(path)
		default:
			if err := processFile(path, false); err != nil {
				report(err)
			}
		}
	}

	os.Exit(exitCode)
}

						scope.Errorf("failed to properly clean up distribution report: %v", err)
					}
				}
				close(r.distributionEventQueue)
				return
			case <-t:
				// TODO, check if report is necessary?  May already be handled by client
				r.writeReport(ctx)
			}
		}
	}()
}

// build a distribution report to send to status leader
func (r *Reporter) buildReport() (Report, []status.Resource) {
	r.mu.RLock()

        task.getReports().all(action(report -> {
            report.getRequired().convention(providers.provider(() -> report.getName().equals(reportFormat.get())));
            report.getOutputLocation().convention(layout.getProjectDirectory().file(providers.provider(() -> {
                String fileSuffix = report.getName().equals("text") ? "txt" : report.getName();

            }

            else -> null
        }
    }

    /**
     * Writes the report to the given [reportDir] if any [diagnostics][DiagnosticKind] have
     * been reported in which case a warning is also logged with the location of the report.
     */
    override fun report(reportDir: File, validationFailures: ProblemConsumer) {
        val summary = summarizer.get()

    }

    void promptsForRerunToFindMoreConfigurations() {
        outputContains("Re-run this report with the '--all' flag to include legacy configurations (legacy = consumable and resolvable).")
    }

    void promptsForRerunToFindMoreVariants() {
        outputContains("Re-run this report with the '--all' flag to include legacy variants (legacy = consumable and resolvable).")
    }

                </tag>
              </tags>
            </configuration>
            <reportSets>
              <reportSet>
                <id>aggregate</id>
                <reports>
                  <report>aggregate</report>
                </reports>
                <inherited>false</inherited>
              </reportSet>
            </reportSets>
          </plugin>
          <plugin>

	p.mu.Unlock()
	p.report()
}

func (p *ManifestLog) ReportFinished() {
	if p == nil {
		return
	}
	p.mu.Lock()
	p.finished = true
	p.mu.Unlock()
	p.report()
}

func (p *ManifestLog) ReportWaiting(resources []string) {
	if p == nil {
		return
	}
	p.mu.Lock()
	p.waiting = resources
	p.mu.Unlock()
	p.report()
}

func (p *ManifestLog) waitingResources() []string {

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Contains project diagnostics or report tasks, e.g. help, project report, dependency report and similar"

errorprone {
    disabledChecks.addAll(
        "DefaultCharset", // 1 occurrences
        "InlineMeInliner", // 1 occurrences
        "MixedMutabilityReturnType", // 1 occurrences
        "NonApiType", // 5 occurrences
        "ProtectedMembersInFinalClass", // 1 occurrences