/**
 * When run from a Continuous Integration environment, we only want to archive a subset of reports, mostly for
 * failing tasks only, to not use up unnecessary disk space on Team City. This also improves the performance of
 * artifact publishing by reducing the artifacts and packaging reports that consist of multiple files.
 *
 * Reducing the number of reports also makes it easier to find the important ones when analysing a failed build in
 * Team City.

}

// Run generates and uploads reports
func (u *uploader) Run() error {
	if telemetry.DisabledOnPlatform {
		return nil
	}
	todo := u.findWork()
	ready, err := u.reports(&todo)
	if err != nil {
		u.logger.Printf("Error building reports: %v", err)
		return fmt.Errorf("reports failed: %v", err)
	}
	u.logger.Printf("Uploading %d reports", len(ready))
	for _, f := range ready {

 */

package org.gradle.api.problems;

import org.gradle.api.Action;
import org.gradle.api.Incubating;

/**
 * Defines different ways to report problems.
 *
 * @since 8.6
 */
@Incubating
public interface ProblemReporter {

    /**
     * Configures and reports a new problem.
     * <p>
     * The spec must specify the problem label and the category. Any additional configuration is optional.
     *

// tag::configure-location-task[]
tasks.test {
    reports {
        junitXml.outputLocation = layout.buildDirectory.dir("test-junit-xml")
    }
}
// end::configure-location-task[]

// tag::configure-location-convention[]
java.testResultsDir = layout.buildDirectory.dir("junit-xml")
// end::configure-location-convention[]

// tag::configure-content[]
tasks.test {
    reports {
        junitXml.apply {

    def setup() {
        toolingApi.withConnector { connector -> connector.useDistribution(distroZip) }
        settingsFile.touch()
    }

    def "tooling api reports an error when requesting a model using a gradle version that does not implement the tooling api"() {
        when:
        toolingApi.withConnection { ProjectConnection connection -> connection.getModel(GradleProject.class) }

	// 
	func RunExamples(examples []InternalExample) (ok bool)

	// 
	func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool)

	// Short reports whether the -test.short flag is set. 
	func Short() bool


TYPES
	// B is a type passed to Benchmark functions to manage benchmark ...
	type B struct {
		N int
		// contains filtered or unexported fields
	}

    def "can configure logging output inclusion in xml reports"() {
        given:
        buildFile.text = buildFile.text.replace("reports.junitXml.outputPerTestCase = true", """reports.junitXml {
            outputPerTestCase = true
            $includeSystemOutConf
            $includeSystemErrConf
        }""".stripIndent())

                def message = "CodeNarc rule violations were found."

                // Find all reports that produced a file
                def reportsWithFiles = reports.findAll { it.name.get() != 'console' }
                // a report file was generated
                if (!reportsWithFiles.isEmpty()) {
                    def humanReadableReport = reportsWithFiles.find { it.name.get() == 'html' }

uploads reports. There will be only one report, named YYYY-MM-DD.json,
for a given day.

First phase. Look at the localdir (os.UserConfigdir()/go/telemetry/local)
and find all .count and .json files. Find the count files that are no
longer active by looking at their metadata.

Second phase. Group the inactive count files by their expiry date, and
for each date generate the local report and the upload report. (The upload

// license that can be found in the LICENSE file.

//go:build windows

// Package sysdll is an internal leaf package that records and reports
// which Windows DLL names are used by Go itself. These DLLs are then
// only loaded from the System32 directory. See Issue 14959.
package sysdll

// IsSystemDLL reports whether the named dll key (a base name, like
// "foo.dll") is a system DLL which should only be loaded from the
// Windows SYSTEM32 directory.