stage.flameGraphs.map { createFlameGraphs(model, stage, it) }

        val (topLevelCoverage, allCoverage) = stage.functionalTests.partition { it.testType == TestType.SOAK }
        val topLevelFunctionalTests =
            topLevelCoverage
                .map { FunctionalTest(model, it.asConfigurationId(model), it.asName(), it.asName(), it, stage = stage) }
        topLevelFunctionalTests.forEach(this::buildType)

    fun hasTestsOf(testType: TestType) =
        (unitTests && testType.unitTests) ||
            (functionalTests && testType.functionalTests) ||
            (crossVersionTests && testType.crossVersionTests)
}

data class Stage(
    val stageName: StageName,
    val specificBuilds: List<SpecificBuild> = emptyList(),
    val functionalTests: List<TestCoverage> = emptyList(),
    val docsTests: List<DocsTestCoverage> = emptyList(),

        val result = mutableMapOf<TestCoverage, List<SmallSubprojectBucket>>()
        for (stage in model.stages) {
            for (testCoverage in stage.functionalTests) {
                if (testCoverage.testType !in
                    listOf(TestType.ALL_VERSIONS_CROSS_VERSION, TestType.QUICK_FEEDBACK_CROSS_VERSION, TestType.SOAK)
                ) {

                        StageName.QUICK_FEEDBACK,
                        StageName.PULL_REQUEST_FEEDBACK,
                        StageName.READY_FOR_NIGHTLY,
                    )
            }.flatMap { it.functionalTests }
            .filter { it.os == os }
            .forEach {
                buildType(FlakyTestQuarantine(model, stage, it))
            }
    })

class FlakyTestQuarantine(
    model: CIBuildModel,

        stage: Stage,
        testCoverage: TestCoverage,
        bucketIndex: Int,
    ): FunctionalTest {
        val parallelizationMethod =
            when (testCoverage.os) {
                Os.LINUX -> ParallelizationMethod.TestDistribution
                else -> ParallelizationMethod.None
            }

        return FunctionalTest(
            model,
            testCoverage.getBucketUuid(model, bucketIndex),

) {
    val triggers: List<BaseGradleBuildType>

    init {
        triggers = mutableListOf()
        val allDependencies =
            stageProject.specificBuildTypes + stageProject.performanceTests + stageProject.functionalTests + stageProject.docsTestTriggers
        triggers.add(StageTrigger(model, stage, prevStage, null, allDependencies))

        stageWithOsTriggers.getOrDefault(stage.stageName, emptyList()).forEach { targetOs ->

            str
        }

    override fun createFunctionalTestsFor(
        model: CIBuildModel,
        stage: Stage,
        testCoverage: TestCoverage,
        bucketIndex: Int,
    ): FunctionalTest =
        FunctionalTest(
            model,
            testCoverage.getBucketUuid(model, bucketIndex),
            getName(testCoverage),
            getDescription(testCoverage),
            testCoverage,
            stage,

 * limitations under the License.
 */

package common

import common.KillProcessMode.KILL_ALL_GRADLE_PROCESSES
import configurations.CompileAll
import configurations.FunctionalTest
import configurations.branchesFilterExcluding
import configurations.checkCleanDirUnixLike
import configurations.checkCleanDirWindows
import configurations.enablePullRequestFeature