this.confidence = confidence;
            this.difference = difference;
            if (confidence != null) {
                this.background = confidence.stream().flatMap(data -> data.data.stream()).map(BackgroundColor::ofConfidence).filter(Objects::nonNull).collect(Collectors.toList());
            }
        }

        public List<ExecutionLabel> getExecutionLabels() {
            return executionLabels;
        }

    def current = new BaselineVersion("7.6")

    def "does consider changes with high confidence"() {
        baseline.results.addAll([millis(100)] * 10)
        current.results.addAll([millis(115)] * 10)
        def confidence = calculateConfidence(baseline, current)
        def minConfidence = confidence - 0.01

        expect:
        baseline.significantlyFasterThan(current.results, minConfidence)

        FAILED("FAILED", "badge badge-danger", "Regression confidence > 99.9% despite retries."),
        NEARLY_FAILED("NEARLY-FAILED", "badge badge-warning", "Regression confidence > 90%, we're going to fail soon."),
        REGRESSED("REGRESSED", "badge badge-danger", "Regression confidence > 99.9% despite retries."),
        IMPROVED("IMPROVED", "badge badge-success", "Improvement confidence > 90%, rebaseline it to keep this improvement! :-)"),

        )
    }

    private PerformanceReportScenario createHighConfidenceImprovedData() {
        // 95% confidence -50% difference
        return createResult('highConfidenceImproved', [2, 2, 2], [1, 1, 1])
    }

    private PerformanceReportScenario createLowConfidenceImprovedData() {
        // 68% confidence -50% difference
        return createResult('lowConfidenceImproved', [2], [1])
    }

// than another pair of tags. First, we determine a rough confidence level. If the
// levels are different, the one with the highest confidence wins.
// Second, if the rough confidence levels are identical, we use a set of tie-breaker
// rules.
//
// The confidence level of matching a pair of tags is determined by finding the
// lowest confidence level of any matches of the corresponding subtags (the

	}
	return t, nil

}

// Confidence indicates the level of certainty for a given return value.
// For example, Serbian may be written in Cyrillic or Latin script.
// The confidence level indicates whether a value was explicitly specified,
// whether it is typically the only possible value, or whether there is
// an ambiguity.
type Confidence int

const (
	No    Confidence = iota // full confidence that there was no match

                        .style("font-size: smaller")
                        .title("The confidence with which these two data series are different. E.g. 90% means they're different with 90% confidence. Currently we fail the test if the confidence > 99.9%.")
                        .text("Confidence");
                            i().classAttr("fa fa-info-circle").text(" ").end()
                    .end();

        then:
        noExceptionThrown()
    }

    def "tooling api restores java logging at end of build"() {
        //(SF) checking if the logger level was not overridden.
        //this gives some confidence that the LogManager was not reset
        given:
        LogManager.getLogManager().getLogger("").setLevel(OFF);
        buildFile << "task hey"

        when:
        assertJavaUtilLoggingNotModified()

import java.util.function.BiPredicate

import static PrettyCalculator.toMillis

/**
 * Allows comparing one Gradle version's results against another, using the Mann–Whitney U test with a minimum confidence of 999%.
 *
 * We prefer the Mann-Whitney U test over Student's T test, because performance data often has a non-normal distribution.

                if(testHistory instanceof CrossVersionPerformanceTestHistory) {
                    charts.add(new Chart("confidence", "confidence", "%", "confidenceChart", false));
                    charts.add(new Chart("difference", "difference", "%", "differenceChart", true));
                }

                charts.forEach(chart -> {