}
        for (DataReporter<CrossVersionPerformanceResults> reporter : reporters) {
            reporter.report(results);
        }
    }

    @Override
    public void close() throws IOException {
        for (DataReporter<CrossVersionPerformanceResults> reporter : reporters) {
            reporter.close();
        }
    }

        def location = InstallationLocation.userDefined(new File("jdkHome"), "test")
        def metadata = Mock(JvmInstallationMetadata)
        def reporter = Mock(BiConsumer)
        def delegate = Mock(JvmMetadataDetector)

        def detector = new ReportingJvmMetadataDetector(delegate, reporter)

        when:
        def actual1 = detector.getMetadata(location)
        def actual2 = detector.getMetadata(location)

        then:

	}
	return warnings, errorList
}

// addOSValidator adds a new OSValidator
func addOSValidator(validators []system.Validator, reporter *system.StreamReporter) []system.Validator {
	validators = append(validators, &system.OSValidator{Reporter: reporter}, &system.CgroupsValidator{Reporter: reporter})
	return validators
}

// addIPv6Checks adds IPv6 related checks
func addIPv6Checks(checks []Checker) []Checker {

    final Action<ExecutionListener> target = Mock()
    final ExecutionListener listener = Mock()
    final Action<Throwable> reporter = Mock()
    final LoggingOutputInternal loggingOutput = Mock()
    final ExceptionReportingAction action = new ExceptionReportingAction(reporter, loggingOutput, target)

    def "executes Action"() {
        when:
        action.execute(listener)

        then:

java.testResultsDir = layout.buildDirectory.dir("my-test-results")

tasks.register("showDirs") {
    val rootDir = project.rootDir
    val reportsDir = project.reporting.baseDirectory
    val testResultsDir = project.java.testResultsDir

    doLast {
        logger.quiet(rootDir.toPath().relativize(reportsDir.get().asFile.toPath()).toString())
        logger.quiet(rootDir.toPath().relativize(testResultsDir.get().asFile.toPath()).toString())
    }
}

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

package distribution

import (
	"gopkg.in/yaml.v2"
)

type Report struct {
	Reporter            string         `json:"reporter"`
	DataPlaneCount      int            `json:"dataPlaneCount"`
	InProgressResources map[string]int `json:"inProgressResources"`
}

func ReportFromYaml(content []byte) (Report, error) {

		{
			Name:     "HTTP Traffic",
			PortName: "http",
			Expected: Expected{
				Query: prometheus.Query{
					Metric:      "istio_requests_total",
					Aggregation: "sum",
					Labels: map[string]string{
						"reporter":                 "source",
						"destination_service_name": "BlackHoleCluster",
						"response_code":            "502",
					},
				},
				StatusCode: http.StatusBadGateway,
			},
		},
		{

        ));
        DirectoryProperty reportsDir = extension.getReportsDirectory();
        reportTask.getReports().all(action(report -> {
            if (report.getOutputType().equals(Report.OutputType.DIRECTORY)) {
                ((DirectoryReport)report).getOutputLocation().convention(reportsDir.dir(reportTask.getName() + "/" + report.getName()));
            } else {

        {
          "datasource": {
            "type": "prometheus",
            "uid": "${datasource}"
          },
          "expr": "sum(rate(istio_requests_total{reporter=\"source\", response_code!~\"5.*\"}[1m])) / sum(rate(istio_requests_total{reporter=\"source\"}[1m]))",
          "format": "time_series",
          "intervalFactor": 1,
          "refId": "A",
          "step": 4
        }
      ],

import org.gradle.api.problems.Problems;

public interface InternalProblems extends Problems {

    /**
     * Returns a reporter then provides additional problem service functionality specific for Gradle internals.
     * <p>
     *
     * @return The reporter.
     */
    InternalProblemReporter getInternalReporter();

    Multimap<Throwable, Problem> getProblemsForThrowables();