label := util.ExtractLabelFromSelectorString(sel.String())
			if line, ok := util.ErrorLine(rs, fmt.Sprintf(util.TelemetrySelector, label)); ok {
				m.Line = line
			}

			c.Report(gvk.Telemetry, m)
		}

		return true
	})

	for p, sList := range podsToTelemetries {
		if len(sList) == 1 {
			continue
		}

		sNames := getNames(sList)
		for _, rs := range sList {

	TypeErrors   []types.Error  // type errors (only if Analyzer.RunDespiteErrors)

	// Report reports a Diagnostic, a finding about a specific location
	// in the analyzed source code such as a potential mistake.
	// It may be called by the Run function.
	Report func(Diagnostic)

	// ResultOf provides the inputs to this analysis pass, which are

	"cmd/go/internal/web"
	"cmd/go/internal/work"
)

var CmdBug = &base.Command{
	Run:       runBug,
	UsageLine: "go bug",
	Short:     "start a bug report",
	Long: `
Bug opens the default browser and starts a new bug report.
The report includes useful system information.
	`,
}

func init() {
	CmdBug.Flag.BoolVar(&cfg.BuildV, "v", false, "")
	base.AddChdirFlag(&CmdBug.Flag)
}

// under the race detector and is otherwise benign.
func doRace() {
	var x int
	c1 := make(chan bool)
	go func() {
		x = 1 // racy write
		c1 <- true
	}()
	_ = x // racy read
	<-c1
}

func TestRaceReports(t *testing.T) {
	if os.Getenv("GO_WANT_HELPER_PROCESS") == "1" {
		// Generate a race detector report in a sub test.

 * limitations under the License.
 */

plugins {
    id("gradlebuild.distribution.implementation-kotlin")
    id("gradlebuild.kotlin-dsl-sam-with-receiver")
}

description = "Base utilities and services to report and track configuration problems"

dependencies {
    api(projects.baseServices)
    api(projects.stdlibJavaExtensions)
    api(projects.logging)
    api(projects.problemsApi)

    api(libs.kotlinStdlib)

                }
            }
        """

        when:
        succeeds("jacocoTestCoverageVerification")

        then:
        def report = new JacocoReportXmlFixture(file("build/reports/jacoco/test/jacocoTestReport.xml"))
        report.assertHasClassCoverage("test.gradle.MyPlugin")
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


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

description = "Contains the Test Report Aggregation plugin"

dependencies {
    api(projects.stdlibJavaExtensions)
    api(project(":core-api"))
    api(project(":platform-jvm"))

    api(libs.inject)

    implementation(project(":base-services"))

    }

    // currently not supported, variants are ambiguous without further information
    def "reports of multiple targets cannot be aggregated"() {
        setupBasicTestingProject(['test-report-aggregation'])
        buildFile << """
            testing {
                suites {
                    test {
                        useJUnit()
                        targets {

$ gradle projects
----

You also get a project report within https://scans.gradle.com/[Build Scans].

[[sec:listing_tasks]]
=== Listing tasks
Running `gradle tasks` gives you a list of the main tasks of the selected project. This report shows the default tasks for the project, if any, and a description for each task:

----
$ gradle tasks
----

By default, this report shows only those tasks assigned to a task group.

import org.gradle.api.problems.internal.Problem;
import org.gradle.internal.operations.OperationIdentifier;

import javax.annotation.Nullable;

/**
 * Interface used between the worker and the daemon to report problems.
 */
public interface WorkerProblemProtocol {
    void reportProblem(Problem problem, @Nullable OperationIdentifier id);