setpd(a)

	a = a[0:10]
	res(sumpd(a), 0, 10)

	a = a[5:25]
	res(sumpd(a), 5, 25)

	a = a[30:95]
	res(sumpd(a), 35, 100)
}

// call ptr fixed with ptr fixed
func testpfpf() {
	var a [20]int

	setpf(&a)
	res(sumpf(&a), 0, 20)
}

// call ptr dynamic with ptr fixed from new
func testpdpf1() {
	a := new([40]int)
	setpd(a[0:])
	res(sumpd(a[0:]), 0, 40)

	b := (*a)[5:30]

		panic("fail")
	}
	if x := sumD(4, 5, 7); x != 16 {
		println("sumD 16", x)
		panic("fail")
	}
	if x := sumE(4, 5, 8); x != 17 {
		println("sumE 17", x)
		panic("fail")
	}
	if x := sumF(4, 5, 9)(); x != 18 {
		println("sumF 18", x)
		panic("fail")
	}
	if x := sum2(1, 2, 3); x != 2*6 {
		println("sum 6", x)
		panic("fail")
	}
	if x := sum2(); x != 2*0 {
		println("sum 0", x)
		panic("fail")
	}

        return noElementSplitFunction(expectedBucketNumber)
    }
    if (expectedBucketNumber == 1) {
        return listOf(smallElementAggregateFunction(list))
    }

    val expectedBucketSize = list.sumOf(toIntFunction) / expectedBucketNumber

    if (expectedBucketSize == 0) {
        // The elements in the list are so small that they can't even be divided into {expectedBucketNumber}.

        parallelizationMethod
    )
}

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)"
    }
}

}

data class TestProjectDuration(val testProject: String, val scenarioDurations: List<PerformanceTestDuration>) {
    val totalTime: Int = scenarioDurations.sumOf { it.durationInMs }

    fun split(expectedBucketNumber: Int): List<PerformanceTestBucket> {
        return if (expectedBucketNumber == 1 || scenarioDurations.size == 1) {