buildType(PartialTrigger("All Functional Tests for ${stage.stageName.stageName}", "Stage_${stage.stageName.id}_FuncTests", model, functionalTests))
            }
            val smokeTests = specificBuildTypes.filterIsInstance<SmokeTests>()
            if (smokeTests.size > 1) {

    buildType(SanityCheck)
    buildType(PublishNightlySnapshot(branch))
    buildType(PublishNightlySnapshotFromQuickFeedback(branch))
    buildType(PublishNightlySnapshotFromQuickFeedbackStepCheckReady(branch))
    buildType(PublishNightlySnapshotFromQuickFeedbackStepUpload(branch))
    buildType(PublishNightlySnapshotFromQuickFeedbackStepPromote(branch))
    buildType(PublishBranchSnapshotFromQuickFeedback)

    )

    @BeforeEach
    fun setUp() {
        val stepsCapturer = slot<BuildSteps.() -> Unit>()
        every { buildType.steps } returns steps
        every { buildType.stage } returns buildModel.stages[2]
        every {
            buildType.steps(capture(stepsCapturer))
        } answers {
            stepsCapturer.captured(steps)
            mockk()
        }
    }

    @Test

        }
        skipConditionally(buildType)
    }
}

fun BuildStep.onlyRunOnGitHubMergeQueueBranch() {
    conditions {
        matches("teamcity.build.branch", "(pre-test/.*)|(gh-readonly-queue/.*)")
    }
}

fun BuildStep.skipConditionally(buildType: BuildType? = null) {
    // we need to run CompileALl unconditionally because of artifact dependency
    if (buildType !is CompileAll) {
        conditions {

    buildType.killProcessStep(KILL_PROCESSES_STARTED_BY_GRADLE, os, arch, executionMode = ExecutionMode.ALWAYS)

    buildType.steps {
        extraSteps()
        checkCleanM2AndAndroidUserHome(os, buildType)
    }

    applyDefaultDependencies(model, buildType, dependsOnQuickFeedbackLinux)
}

fun applyDefaultDependencies(model: CIBuildModel, buildType: BuildType, dependsOnQuickFeedbackLinux: Boolean) {

    buildTypes: Iterable<T>,
    snapshotConfig: SnapshotDependency.(T) -> Unit = {}
) {
    buildTypes.forEach { buildType ->
        dependency(buildType.id!!) {
            snapshot {
                if (!buildType.failStage) {
                    onDependencyFailure = FailureAction.IGNORE
                    onDependencyCancel = FailureAction.IGNORE
                } else {

        stageTriggers.triggers.forEach(::buildType)
        subProject(stageProject)

        prevStage = stage
        previousPerformanceTestPasses.addAll(stageProject.performanceTests)
        previousCrossVersionTests.addAll(stageProject.crossVersionTests)
    }

    buildType(GitHubMergeQueueCheckPass(model))

    buildTypesOrder = buildTypes

    this.name = testCoverage.asName()
}) {
    val functionalTests: List<BaseGradleBuildType> = functionalTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)
    init {
        functionalTests.forEach(this::buildType)
    }

import common.removeSubstDirOnWindows
import common.substDirOnWindows
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.ParameterDisplay
import jetbrains.buildServer.configs.kotlin.ParametrizedWithType

abstract class AdHocPerformanceScenario(os: Os, arch: Arch = Arch.AMD64) : BuildType({
    val id = "Util_Performance_AdHocPerformanceScenario${os.asName()}${arch.asName()}"

import common.killProcessStep
import configurations.CompileAll
import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.ParameterDisplay

class RerunFlakyTest(os: Os, arch: Arch = Arch.AMD64) : BuildType({
    val id = "Util_RerunFlakyTest${os.asName()}${arch.asName()}"
    name = "Rerun Flaky Test - ${os.asName()} ${arch.asName()}"