package org.gradle.performance.measure

import groovy.transform.CompileStatic
import groovy.transform.ToString

@ToString(includeNames = true)
@CompileStatic
class MeasuredOperation {
    Amount<Duration> totalTime
    Exception exception

        })
        .entries
        .map { TestProjectDuration(it.key, it.value) }
        .sortedBy { -it.totalTime }
    return splitIntoBuckets(
        LinkedList(testProjectDurations),
        TestProjectDuration::totalTime,
        { largeElement: TestProjectDuration, size: Int -> largeElement.split(size) },
        { list: List<TestProjectDuration> -> MultipleTestProjectBucket(list) },

	SchedWaitTime     time.Duration
	BlockTimeByReason map[string]time.Duration
	SyscallTime       time.Duration
	SyscallBlockTime  time.Duration

	// TotalTime is the duration of the goroutine's presence in the trace.
	// Necessarily overlaps with other stats.
	TotalTime time.Duration

	// Total time the goroutine spent in certain ranges; may overlap
	// with other stats.
	RangeTime map[string]time.Duration
}

                    id: '1450575490',
                    branch: 'master',
                    date: '1970-01-01',
                    commits: ['123456']
                ]
            ],
            totalTime: [
                [
                    label: '5.0-mockbaseline-1',
                    data: [[0, 1]]
                ],
                [
                    label: '5.0-mockbaseline-2',

					UserRegionSummary:   r,
					Goroutine:           g.ID,
					NonOverlappingStats: nonOverlappingStats,
					HasRangeTime:        totalRangeTime != 0,
				})
				if maxTotal < r.TotalTime {
					maxTotal = r.TotalTime
				}
			}
		}

		// Sort.
		sortBy := r.FormValue("sortby")
		if _, ok := validNonOverlappingStats[sortBy]; ok {
			slices.SortFunc(regions, func(a, b region) int {

        try (PreparedStatement statement = connection.prepareStatement("insert into testOperation(testExecution, displayName, tasks, args, gradleOpts, daemon, totalTime, cleanTasks) values (?, ?, ?, ?, ?, ?, ?, ?)")) {
            for (BuildDisplayInfo displayInfo : results.getBuilds()) {
                addOperations(statement, executionId, displayInfo, results.buildResult(displayInfo));

        try (PreparedStatement statement = connection.prepareStatement(insertStatement("testOperation", "testExecution", "version", "totalTime"))) {
            addOperations(statement, testId, null, results.getCurrent());
            for (BaselineVersion baselineVersion : results.getBaselineVersions()) {

	}
	if stats.SyscallTime < 0 {
		t.Error("found negative SyscallTime")
	}
	if stats.SyscallBlockTime < 0 {
		t.Error("found negative SyscallBlockTime")
	}
	if stats.TotalTime < 0 {
		t.Error("found negative TotalTime")
	}
	for reason, dt := range stats.BlockTimeByReason {
		if dt < 0 {
			t.Errorf("found negative BlockTimeByReason for %s", reason)
		}
	}
	for name, dt := range stats.RangeTime {

        }

        final PathMappingHelper pathMappingHelper = ComponentUtil.getPathMappingHelper();
        final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
        final long totalTime = systemHelper.getCurrentTimeAsLong();

        final CrawlingInfoHelper crawlingInfoHelper = ComponentUtil.getCrawlingInfoHelper();

        try {

	// Update cumulative scavenge CPU stats.
	s.ScavengeAssistTime += scavAssistCpu
	s.ScavengeBgTime += scavBgCpu
	s.ScavengeTotalTime += scavAssistCpu + scavBgCpu

	// Update total CPU.
	s.TotalTime = sched.totaltime + (now-sched.procresizetime)*int64(gomaxprocs)
	s.IdleTime += sched.idleTime.Load()

	// Compute userTime. We compute this indirectly as everything that's not the above.
	//