"durations" : [ {
    "testProject" : "largeEmptyMultiProjectDeclarativeDsl",
    "linux" : 8
  } ]
}, {
  "scenario" : "org.gradle.performance.experiment.declarativedsl.DeclarativeDslFirstUsePerformanceTest.cold daemon",
  "durations" : [ {
    "testProject" : "largeEmptyMultiProjectDeclarativeDsl",
    "linux" : 8
  } ]
}, {

/**
 * Used for generating performance-test-durations.json by Jackson.
 */
@CompileStatic
class PerformanceScenarioDurations {
    String scenario
    List<TestProjectDuration> durations

    PerformanceScenarioDurations(String scenario, List<TestProjectDuration> durations) {
        this.scenario = scenario
        this.durations = durations
    }

	"testing"
	"time"

	clocktesting "k8s.io/utils/clock/testing"
)

func TestLatencyTrackersFrom(t *testing.T) {
	type testCase struct {
		Durations    []time.Duration
		SumDurations time.Duration
		MaxDuration  time.Duration
	}
	tc := testCase{
		Durations:    []time.Duration{100, 200, 300, 200, 400, 300, 100},
		SumDurations: 1600,
		MaxDuration:  400,
	}
	t.Run("TestLatencyTrackersFrom", func(t *testing.T) {

  }

  static class DurationSpec {
    private final long duration;
    private final TimeUnit unit;

    private DurationSpec(long duration, TimeUnit unit) {
      this.duration = duration;
      this.unit = unit;
    }

    public static DurationSpec of(long duration, TimeUnit unit) {
      return new DurationSpec(duration, unit);
    }

    @Override
    public int hashCode() {

	// again with the same metric for a specific converter (e.g. 'webhook').
	durations   map[string]*metrics.HistogramVec
	factoryLock sync.Mutex
}

func newConverterMetricFactory() *converterMetricFactory {
	return &converterMetricFactory{durations: map[string]*metrics.HistogramVec{}, factoryLock: sync.Mutex{}}
}

var _ crConverterInterface = &converterMetric{}

    }

    def "can convert between units"() {
        expect:
        Duration.millis(45000) == Duration.seconds(45)
        Duration.seconds(0.98) == Duration.millis(980)
        Duration.seconds(120) == Duration.minutes(2)
        Duration.seconds(30) == Duration.minutes(0.5)
        Duration.hours(30) == Duration.millis(30 * 60 * 60 * 1000)
    }

        val durations = JSON.parseArray(performanceTestDurationsJson.readText(StandardCharsets.UTF_8))
        val pairs = durations.flatMap { it ->
            val scenarioDurations = it as JSONObject
            val scenario = Scenario.fromTestId(scenarioDurations["scenario"] as String)
            (scenarioDurations["durations"] as JSONArray).flatMap {
                val duration = it as JSONObject

}

// record adds the given duration to the distribution.
//
// Disallow preemptions and stack growths because this function
// may run in sensitive locations.
//
//go:nosplit
func (h *timeHistogram) record(duration int64) {
	// If the duration is negative, capture that in underflow.
	if duration < 0 {
		h.underflow.Add(1)
		return
	}
	// bucketBit is the target bit for the bucket which is usually the

	tests := []struct {
		initial *Backoff
		want    []time.Duration
	}{
		{initial: nil, want: []time.Duration{0, 0, 0, 0}},
		{initial: &Backoff{Duration: time.Second, Steps: -1}, want: []time.Duration{time.Second, time.Second, time.Second}},
		{initial: &Backoff{Duration: time.Second, Steps: 0}, want: []time.Duration{time.Second, time.Second, time.Second}},

	if len(*i) > 0 {
		return errors.New("interval flag already set")
	}
	for _, dt := range strings.Split(value, ",") {
		duration, err := time.ParseDuration(dt)
		if err != nil {
			return err
		}
		*i = append(*i, duration)
	}
	return nil
}

// Define a flag to accumulate durations. Because it has a special type,
// we need to use the Var function and therefore create the flag during
// init.