N report = getInstantiator().newInstance(clazz, constructionArgs);
        String name = report.getName();
        if (name.equals("enabled")) {
            throw new InvalidUserDataException("Reports that are part of a ReportContainer cannot be named 'enabled'");
        }
        getStore().add(report);
        index();
        return report;
    }

    @Override

import org.gradle.internal.configuration.problems.DecoratedPropertyProblem
import java.io.Writer


/**
 * Writes the configuration cache html report.
 *
 * The report is laid out in such a way as to allow extracting the pure JSON model
 * by looking for the `// begin-report-data` and `// end-report-data` markers.
 */
internal
class HtmlReportWriter(val writer: Writer) {

    private
    val jsonModelWriter = JsonModelWriter(writer)

                            <report>index</report>
                            <report>dependency-info</report>
                            <report>modules</report>
                            <report>license</report>
                            <report>project-team</report>
                            <report>scm</report>
                            <report>issue-tracking</report>

- Build configuration time.
- Task execution time.
- Heap consumption at the end of the build.
- Total heap usage during the build

### Report

A `performance:report` task generates a static HTML report from the contents of the database in `~/.gradle-performance-test-data`. This report allows the results over
time to be visualized.

The reports for the most recent test suite run against master can be found at:

}

type CounterConfig struct {
	Name  string
	Rate  float64 // If X <= Rate, report this counter
	Depth int     `json:",omitempty"` // for stack counters
}

// A Report is what's uploaded (or saved locally)
type Report struct {
	Week     string  // first day this report covers (YYYY-MM-DD)
	LastWeek string  // Week field from latest previous report uploaded

     * The created problem can be later reported with {@link #report(Problem)}.
     *
     * @param action The problem configuration.
     * @return The new problem.
     */
    Problem create(Action<InternalProblemSpec> action);

    /**
     * Reports the target problem.
     *
     * @param problem The problem to report.
     */
    void report(Problem problem);

    /**

  QuantizationReport report{};
  report.AddQuantizationResult(std::move(result));

  // Check that the report string is equivalent to the textproto representation
  // of the `QuantizationResults`.
  std::string result_str{};
  TextFormat::PrintToString(report.GetQuantizationResults(), &result_str);

  EXPECT_THAT(report.ToString(), HasSubstr("Quantization Report"));

)

func TestReportSerialization(t *testing.T) {
	in := Report{
		Reporter:       "Me",
		DataPlaneCount: 10,
		InProgressResources: map[string]int{
			(&status.Resource{
				Name:      "water",
				Namespace: "default",
			}).String(): 1,
		},
	}
	outbytes, err := yaml.Marshal(in)
	RegisterTestingT(t)
	Expect(err).To(BeNil())
	out := Report{}
	err = yaml.Unmarshal(outbytes, &out)
	Expect(err).To(BeNil())

// tag::test-report[]
// A resolvable configuration to collect test reports data
plugins {
    id 'reporting-base'
}

configurations {
    testReportData {
        canBeConsumed = false
        attributes {
            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.DOCUMENTATION))
            attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType, 'test-report-data'))
        }
    }
}

dependencies {

    java
}

// tag::test-report[]
val testReportData by configurations.creating {
    isCanBeConsumed = false
    attributes {
        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.DOCUMENTATION))
        attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named("test-report-data"))
    }
}

dependencies {
    testReportData(project(":core"))