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

    }) {
    val functionalTests: List<BaseGradleBuildType> = functionalTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)

    init {
        functionalTests.forEach(this::buildType)
    }

            .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 }

import common.buildToolGradleParameters
import common.gradleWrapper
import common.javaHome
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.buildFeatures.freeDiskSpace
import vcsroots.useAbsoluteVcs

object WarmupEc2Agent : BuildType({
    name = "Warmup EC2 Agent"
    id("Util_WarmupEc2Agent")

    vcs.useAbsoluteVcs(VersionedSettingsBranch.fromDslContext().vcsRootId())

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

class AutomaticallySplitPerformanceTestProject(
    model: CIBuildModel,
    performanceTestBucketProvider: PerformanceTestBucketProvider,
    stage: Stage,

package configurations

import common.Os
import jetbrains.buildServer.configs.kotlin.BuildType
import model.Stage

open class BaseGradleBuildType(
    open val stage: Stage? = null,
    open val failStage: Boolean = true,
    init: BaseGradleBuildType.() -> Unit = {},
) : BuildType() {
    init {
        this.init()
    }
}

open class OsAwareBaseGradleBuildType(
    val os: Os,
    override val stage: Stage? = null,

import common.VersionedSettingsBranch
import common.gradleWrapper
import common.requiresOs
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.triggers.vcs
import vcsroots.useAbsoluteVcs

// Gradle_Master_Promotion_SanityCheck
object SanityCheck : BuildType({
    id("Promotion_SanityCheck")
    name = "SanityCheck"
    description = "Sanity check for promotion project"

                useGradleWrapper = true
            }
        }

        if (vcsBranch.isRelease) {
            triggers {
                finishBuildTrigger {
                    buildType =
                        "Gradle_${vcsBranch.branchName.uppercase()}_${NIGHTLY_SNAPSHOT_BUILD_ID}"
                    successfulOnly = true
                    branchFilter = "+:*"
                }
            }

        name = "Smoke Test"
        description = "Smoke tests against third-party plugins, Gradle build, and IDE sync"
    }) {
    init {
        smokeBuildTypes.forEach(this::buildType)
    }

    companion object {
        /**
         * Specific builds shown under the "Smoke Test" subproject in Pull Request Feedback.
         */
        val pullRequestFeedbackSmokeBuilds: Set<SpecificBuild> =

        id(buildTypeId(model) + suffix)
        name = "Smoke Ide Tests$suffix"
        description = "Tests against IDE sync process"

        applyTestDefaults(
            model = model,
            buildType = this,
            gradleTasks = ":smoke-ide-test:smokeIdeTest",
            extraParameters =
                listOf(
                    stage.getBuildScanCustomValueParam(),