// in ITs test we need only reports from test itself
                                    // test projects can contain reports with tested failed builds
                                    junit testResults: '**/core-it-suite/target/surefire-reports/*.xml,**/core-it-support/**/target/surefire-reports/*.xml', allowEmptyResults: true

	FirstClass   bool
	Broken       bool
}

// CgoSupported reports whether goos/goarch supports cgo.
func CgoSupported(goos, goarch string) bool {
	return distInfo[OSArch{goos, goarch}].CgoSupported
}

// FirstClass reports whether goos/goarch is considered a “first class” port.
// (See https://go.dev/wiki/PortingPolicy#first-class-ports.)
func FirstClass(goos, goarch string) bool {

        ["html", "xml", "txt"].each {
            assert report("main", it).exists()
        }
        // HTML report is sortable
        report("main").text.contains("Sort by")
    }

    def "reports HTML report over text or XML report in failure message"() {
        badCode()
        buildFile << """
            codenarcTest.reports {
                xml.required = true
                text.required = true

plugins {
    id("gradlebuild.incubation-report-aggregation")
}

description = "The project to aggregate incubation reports from all subprojects"

dependencies {
    reports(platform(project(":distributions-full")))

    val locatedExceptions =
        exceptions.findLocationAwareExceptions()

    val reports =
        mutableListOf<EditorReport>()

    reportExceptionsNotLocatedIn(scriptFile, locatedExceptions, reports)

    reportRuntimeExceptionsLocatedIn(scriptFile, locatedExceptions, locationAwareHints, reports)

    return reports
}


private
fun reportExceptionsNotLocatedIn(
    scriptFile: File,

        errorprone.enabled = false
    }
}

val reports by configurations.creating
val flamegraph by configurations.creating
configurations.compileOnly { extendsFrom(flamegraph) }

repositories {
    googleApisJs()
}

dependencies {
    reports("jquery:jquery.min:3.5.1@js")
    reports("flot:flot:0.8.1:min@js")

    api(project(":base-services"))
    api(project(":core"))

import java.util.SortedSet;

/**
 * A container of {@link Report} objects, that represent potential reports.
 * <p>
 * Things that produce reports (typically tasks) expose a report container that contains {@link Report} objects for each
 * possible report that they can produce. Each report object can be configured individually, including whether or not it should
 * be produced by way of its {@link Report#getRequired()} required} property.
 * <p>

                @Nested
                TaskReportContainer reports = project.services.get(org.gradle.internal.reflect.Instantiator).newInstance(TestTaskReportContainer, this)

                @TaskAction
                def doStuff() {
                    reports.enabled.each {
                         if (it.outputType == Report.OutputType.FILE) {

class ParsedCommandLineOptionSpec extends Specification {

    final option = new ParsedCommandLineOption();

    def "reports no value"() {
        when:
        option.getValue()

        then:
        thrown(IllegalStateException)
        !option.hasValue()
    }

    def "reports single value"() {
        when:
        option.addArgument("foo")

        then:
        option.hasValue()

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