if (stage.stageName !in listOf(StageName.QUICK_FEEDBACK_LINUX_ONLY, StageName.QUICK_FEEDBACK)) {
            if (topLevelFunctionalTests.size + functionalTestProjects.size > 1) {
                buildType(
                    PartialTrigger(
                        "All Functional Tests for ${stage.stageName.stageName}",
                        "Stage_${stage.stageName.id}_FuncTests",
                        model,

import model.CIBuildModel
import model.Stage
import model.StageName
import model.Trigger
import projects.StageProject

val stageWithOsTriggers: Map<StageName, List<Os>> =
    mapOf(
        StageName.PULL_REQUEST_FEEDBACK to listOf(Os.LINUX, Os.WINDOWS),
        StageName.READY_FOR_NIGHTLY to listOf(Os.LINUX, Os.WINDOWS, Os.MACOS),
        StageName.READY_FOR_RELEASE to listOf(Os.LINUX, Os.WINDOWS, Os.MACOS),
    )

import projects.DEFAULT_FUNCTIONAL_TEST_BUCKET_SIZE
import projects.DEFAULT_LINUX_FUNCTIONAL_TEST_BUCKET_SIZE
import projects.DEFAULT_MACOS_FUNCTIONAL_TEST_BUCKET_SIZE

enum class StageName(
    val stageName: String,
    val description: String,
    val uuid: String,
) {
    QUICK_FEEDBACK_LINUX_ONLY(
        "Quick Feedback - Linux Only",
        "Run checks and functional tests (embedded executer, Linux)",

        model.stages
            .filter { it.stageName <= StageName.READY_FOR_RELEASE }
            .flatMap { it.functionalTests }
            .filter { it.os == os && !it.testType.crossVersionTests }
            .forEach {
                buildType(FlakyTestQuarantine(model, stage, it))
            }

        model.stages
            .filter { it.stageName <= StageName.READY_FOR_RELEASE }

                    (if (prevStage != null) 1 else 0) +
                    // flakyTestQuarantineTriggers
                    if (stage.stageName == StageName.READY_FOR_RELEASE) 3 else 0,
                it.dependencies.items.size,
                stage.stageName.stageName,
            )
        }
    }

    private val largeSubProjectRegex = """\((\w+(_\d+))\)""".toRegex()

    /**

private fun Stage.getBuildScanCustomValues(): List<String> =
    StageName
        .values()
        .slice(this.stageName.ordinal until StageName.READY_FOR_RELEASE.ordinal + 1)
        .map { it.uuid }

fun Stage.getBuildScanCustomValueParam(testCoverage: TestCoverage? = null): String {
    val customValues =

import common.VersionedSettingsBranch
import jetbrains.buildServer.configs.kotlin.triggers.schedule
import model.StageName

class PublishNightlyDocumentation(
    branch: VersionedSettingsBranch,
) : PublishGradleDistributionFullBuild(
        promotedBranch = branch.branchName,
        promoteTask = "publishBranchDocs",
        triggerName = StageName.PULL_REQUEST_FEEDBACK.uuid,
    ) {
    init {
        id("Promotion_NightlyDocumentation")

import jetbrains.buildServer.configs.kotlin.RelativeId
import jetbrains.buildServer.configs.kotlin.triggers.VcsTrigger
import jetbrains.buildServer.configs.kotlin.triggers.vcs
import model.CIBuildModel
import model.StageName

class GitHubMergeQueueCheckPass(
    model: CIBuildModel,
) : BaseGradleBuildType(init = {
        id("${model.projectId}_GitHubMergeQueueCheckPass")

        val previousCrossVersionTests: MutableList<BaseGradleBuildType> = mutableListOf()
        model.stages.forEach { stage ->
            if (isSecurityFork() && stage.stageName > StageName.READY_FOR_RELEASE) {
                return@forEach
            }
            val stageProject =
                StageProject(
                    model,
                    functionalTestBucketProvider,

import model.CIBuildModel
import model.JsonBasedGradleSubprojectProvider
import model.PerformanceTestCoverage
import model.PerformanceTestType
import model.Stage
import model.StageName
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
import java.io.File

class PerformanceTestBuildTypeTest {
    init {
        DslContext.initForTest()
    }