allTestedVersions = testedVersions.map { VersionNumber.parse(it.gradleVersion().version) }
            .groupBy { "${it.major}.${it.minor}" }
            .map { (_, v) -> v.maxOrNull()!!.format() }

        // Limit to first and last release of each major version
        mainTestedVersions = testedVersions.map { VersionNumber.parse(it.gradleVersion().version) }
            .groupBy { it.major }

    private
    val taskPathReports: Map<String, List<File>>
        get() = parameters.taskPathToReports.get()

    private
    val rootBuildDir: File
        get() = parameters.rootBuildDir.get().asFile

    private
    val testPathToBinaryResultsDirs: Map<String, File>
        get() = parameters.testPathToBinaryResultsDirs.get()

                    entryPoints.add(classDetails)
                }
            }
        }

    fun getDependencies() = classes.map { it.value.outputClassFilename to it.value.dependencies.map { it.outputClassFilename } }.toMap()
}


class ClassDetails(val outputClassName: String) {
    var visited: Boolean = false
    val dependencies: MutableSet<ClassDetails> = linkedSetOf()

        }

        fun assertHasErrors(vararg errors: String) {
            assertThat("Has errors", richReport.errors.map { it.message }, CoreMatchers.equalTo(errors.toList()))
        }

        fun assertHasWarnings(vararg warnings: String) {
            assertThat("Has warnings", richReport.warnings.map { it.message }, CoreMatchers.equalTo(warnings.toList()))
        }

    private
    fun KtFile.isDocumentedAsSince(version: String, declaringClass: CtClass, constructor: CtConstructor): Boolean {
        val classFqName = declaringClass.name
        val ctorParamTypes = constructor.parameterTypes.map { it.name }
        return collectDescendantsOfType<KtConstructor<*>>()
            .firstOrNull { ktCtor ->
                val sameName = ktCtor.containingClassOrObject?.fqName?.asString() == classFqName

    fun BuildSteps.adHocPerformanceTest(tests: List<String>) {
        gradleStep(
            listOf(
                "clean",
                "performance:${testProject}PerformanceAdHocTest",
                tests.map { """--tests "$it"""" }.joinToString(" "),
                """--warmups 2 --runs 2 --checks none""",
                "-PtestJavaVersion=${os.perfTestJavaVersion.major}",
                "-PtestJavaVendor=${os.perfTestJavaVendor}",

    listOf("scripts", "scripts-remapped", "gradle-kotlin-dsl", "gradle-kotlin-dsl-accessors", "kotlin-dsl")


private
fun scriptsCacheDirsUnder(cacheDir: File) =
    scriptCacheDirNames
        .map { File(cacheDir, it) }
        .filter { it.isDirectory }


/**
 * Clean up cache files for older versions that aren't multi-process safe.
 */
fun FileSystemOperations.removeDodgyCacheFiles(dir: Directory) {

            testJvmVendorParameter,
            JvmVendor.openjdk.name,
            display = ParameterDisplay.PROMPT,
            description = "Java vendor to run the test with",
            options = JvmVendor.values().map { it.displayName to it.name }
        )
        text(
            testTaskOptionsParameterName,
            "",
            display = ParameterDisplay.PROMPT,
            allowEmpty = true,

    return (
        listOf(
            "-PtestJavaVersion=$testJvmVersion",
            "-PtestJavaVendor=$testJvmVendor"
        ) +
            listOf(buildScanTag(buildScanTag)) +
            buildScanValues.map { buildScanCustomValue(it.key, it.value) }
        ).filter { it.isNotBlank() }.joinToString(separator = " ")
}

fun functionalTestParameters(os: Os): List<String> {
    return listOf(

    private val buckets: Map<TestCoverage, List<SmallSubprojectBucket>> = buildBuckets(testTimeDataJson, model)

    fun generate(jsonFile: File) {
        jsonFile.writeText(
            JSON.toJSONString(
                buckets.map {
                    TestCoverageAndBucketSplits(it.key.uuid, it.value.map { it.toJsonBucket() })
                },