val id = "Util_RerunFlakyTest${os.asName()}${arch.asName()}"
    name = "Rerun Flaky Test - ${os.asName()} ${arch.asName()}"
    description = "Allows you to rerun a selected flaky test 10 times"
    id(id)
    val testJvmVendorParameter = "testJavaVendor"
    val testJvmVersionParameter = "testJavaVersion"
    val testTaskParameterName = "testTask"
    val testNameParameterName = "testName"

            ?: ""

    operator fun get(className: String) =
        classes.computeIfAbsent(className) {
            val outputClassName = if (unshadedPackages.matches(className)) className else shadowPackagePrefix + className
            ClassDetails(outputClassName).also { classDetails ->
                if (keepPackages.matches(className) && !ignorePackages.matches(className)) {
                    entryPoints.add(classDetails)

    classpath.from(tasks.named<JavaCompile>("compileJava"))
    classpath.from(tasks.named<GroovyCompile>("compileGroovy"))
    destinationFile = project.layout.buildDirectory.file(
        moduleIdentity.baseName.map { "generated-resources/$it-parameter-names/$it-parameter-names.properties" }
    )
}

main.output.dir(
    parameterNamesIndex.map { it.destinationFile.get().asFile.parentFile }

    functionalTestBucketProvider: FunctionalTestBucketProvider,
    val testCoverage: TestCoverage,
    val stage: Stage
) : Project({
    this.id(testCoverage.asId(model))
    this.name = testCoverage.asName()
}) {
    val functionalTests: List<BaseGradleBuildType> = functionalTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)
    init {
        functionalTests.forEach(this::buildType)
    }

abstract class PerformanceTestProject(model: CIBuildModel, val spec: PerformanceTestProjectSpec, val performanceTests: List<PerformanceTest>) : Project({
    this.id(spec.asConfigurationId(model))
    this.name = spec.asName()
}) {
    init {
        performanceTests.forEach(this::buildType)
    }
}

                    subprojects {
                        apply(plugin = "gradlebuild.module-identity")
                        apply(plugin = "kotlin")
                        the<ModuleIdentityExtension>().baseName.set("api-module")
                        repositories {
                            mavenCentral()
                        }
                        dependencies {

            performanceSubProject = "performance",
            bucketIndex = bucketIndex,
            extraParameters = "--profiler $profiler --tests \"${performanceScenario.scenario.className}.${performanceScenario.scenario.scenario}\"",
            testProjects = listOf(performanceScenario.testProject),

    configureGradleTestEnvironment()
    addSetUpAndTearDownActions()
}

fun executerRequiresDistribution(taskName: String) =
    !taskName.startsWith("embedded") || taskName.contains("CrossVersion") // <- Tooling API [other-version]->[current]

fun executerRequiresFullDistribution(taskName: String) =
    taskName.startsWith("noDaemon")

fun DistributionTest.addSetUpAndTearDownActions() {
    cachesCleaner = cachesCleanerService

    val defaultExecuter = "embedded"

    // For all the other executers, add an executer specific task
    testType.executers.forEach { executer ->
        val taskName = "$executer${prefix.capitalize()}Test"
        val testTask = createTestTask(taskName, executer, sourceSet, testType) {}
        if (executer == defaultExecuter) {
            // The test task with the default executer runs with 'check'

                buildProjectClassTimes[it.asId(MASTER_CHECK_CONFIGURATION)]
            }?.also {
                println("No test statistics found for ${testCoverage.asName()} (${testCoverage.uuid}), re-using the data from ${foundTestCoverage.asName()} (${foundTestCoverage.uuid})")
            }
        }
    }
}

fun onlyNativeSubprojectsForIntelMacs(
    testCoverage: TestCoverage,
    subprojectName: String