}

    /**
     * Sets the single configuration (by name) to generate the report for.
     *
     * @param configurationName name of the configuration to generate the report for
     */
    @Option(option = "configuration", description = "The configuration to generate the report for.")
    public void setConfiguration(String configurationName) {

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;

import static org.gradle.performance.results.report.FlakinessDetectionPerformanceExecutionDataProvider.isFlaky;
import static org.gradle.performance.results.report.Tag.FixedTag.FLAKY;

public class FlakinessIndexPageGenerator extends AbstractTablePageGenerator {

import org.gradle.profiler.BenchmarkResultCollector;
import org.gradle.profiler.InvocationSettings;
import org.gradle.profiler.report.AbstractGenerator;
import org.gradle.profiler.report.BenchmarkResult;
import org.gradle.profiler.report.CsvGenerator;
import org.gradle.profiler.report.Format;
import org.gradle.profiler.report.HtmlGenerator;

import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;

import gradlebuild.basics.googleApisJs

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

description = "Report type classes and plugins for reporting (build dashboard, report container)"

errorprone {
    disabledChecks.addAll(
        "EqualsUnsafeCast", // 1 occurrences
    )
}

val implementationResources: Configuration by configurations.creating

repositories {
    googleApisJs()
}

dependencies {

     * that the output is generated in a stable order rather than in an order based on the order that implementations
     * are discovered.
     */
    String getId();

    /**
     * Notifies the build user of whatever problems have been collected. May report problems to the console, or generate a report

				fmt.Fprintf(&buf, "%s: ", p.pos)
			}
		}
		buf.WriteString(p.msg)
	}
	return buf.String()
}

// report reports the error err, setting check.firstError if necessary.
func (err *error_) report() {
	if err.empty() {
		panic("no error")
	}

	// Cheap trick: Don't report errors with messages containing
	// "invalid operand" or "invalid type" as those tend to be

        when:
        configurationCacheRun(":help", "--profile")

        then:
        configurationCache.assertStateStored()
        def report = findReport()

        and:
        report.delete()

        when:
        configurationCacheRun(":help", "--profile")

        then:
        configurationCache.assertStateLoaded()
        findReport()
    }

== Profile report

If you prefer not to use build scans, you can generate an HTML report in the
`build/reports/profile` directory of your root project. To generate this report,
use the `--profile` command-line option:

[listing.terminal]
----
$ gradle --profile <tasks>
----

Each profile report has a timestamp in its name to avoid overwriting existing ones.

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

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