result.baseline("1.0").results << operation(totalTime: 100)
        result.baseline("1.0").results << operation(totalTime: 100)
        result.baseline("1.0").results << operation(totalTime: 100)
        result.baseline("1.0").results << operation(totalTime: 100)
        result.baseline("1.0").results << operation(totalTime: 100)
        result.baseline("1.0").results << operation(totalTime: 100)

    ) {
        def myTime = results.totalTime
        def otherTime = other.totalTime
        return myTime && myTime.median < otherTime.median && differenceSignificantCheck.test(myTime, otherTime)
    }

    boolean significantlySlowerThan(MeasuredOperationList other, double minConfidence = MINIMUM_CONFIDENCE) {
        def myTime = results.totalTime
        def otherTime = other.totalTime

        return FormatSupport.getFormattedDifference(baseVersion.totalTime, currentVersion.totalTime)
    }

    double getDifferencePercentage() {
        return FormatSupport.getDifferencePercentage(baseVersion, currentVersion).doubleValue()
    }

    double getConfidencePercentage() {
        return 100.0 * DataSeries.confidenceInDifference(baseVersion.totalTime, currentVersion.totalTime)
    }

    String getFormattedDifferencePercentage() {

public class MeasuredOperationList extends LinkedList<MeasuredOperation> {
    String name

    DataSeries<Duration> getTotalTime() {
        return new DataSeries<Duration>(this.collect { it.totalTime })
    }

    String getSpeedStats() {
        format(totalTime)
    }

    private String format(DataSeries<?> measurement) {

        return results
    }

    MeasuredOperation operation(Map<String, Object> args = [:]) {
        def operation = new MeasuredOperation()
        operation.totalTime = args.totalTime instanceof Amount ? args.totalTime : Duration.millis(args?.totalTime ?: 120)
        operation.exception = args?.failure
        return operation
    }

    BuildDisplayInfo buildDisplayInfo(String displayName) {

        private List<ExecutionLabel> executionLabels;
        private List<ExecutionData> totalTime;
        private List<ExecutionData> confidence;
        private List<ExecutionData> difference;
        private List<BackgroundColor> background;

        AllExecutionData(List<ExecutionLabel> executionLabels, List<ExecutionData> totalTime, List<ExecutionData> confidence, List<ExecutionData> difference) {

class SubprojectTestClassTime(
    val subProject: GradleSubproject,
    testClassTimes: List<TestClassTime> = emptyList()
) {
    val totalTime: Int = testClassTimes.sumOf { it.buildTimeMs }

    override fun toString(): String {
        return "SubprojectTestClassTime(subProject=${subProject.name}, totalTime=$totalTime)"
    }
}

class FunctionalTestBucketGenerator(private val model: CIBuildModel, testTimeDataJson: File) {

        baselineResults.results.name = name
        def rawResults = results.buildResult(name)
        def shift = rawResults.totalTime.median.value * maxPercentageShift / 100
        baselineResults.results.addAll(rawResults.collect {
            new MeasuredOperation([totalTime: Amount.valueOf(it.totalTime.value + shift, it.totalTime.units), exception: it.exception])
        })
        return baselineResults
    }

				NonOverlappingStats: nonOverlappingStats,
				HasRangeTime:        totalRangeTime != 0,
			})
			name = summary.Name
			execTime += summary.ExecTime
			if maxTotalTime < summary.TotalTime {
				maxTotalTime = summary.TotalTime
			}
		}

		// Compute the percent of total execution time these goroutines represent.
		execTimePercent := ""
		if totalExecTime > 0 {

    private double calculateConfidence(BaselineVersion first, BaselineVersion second) {
        DataSeries.confidenceInDifference(first.results.getTotalTime(), second.results.totalTime)
    }

    MeasuredOperation millis(long millis) {
        new MeasuredOperation(totalTime: Duration.millis(millis))
    }