}
        }

        specificBuildTypes =
            stage.specificBuilds.map {
                it.create(model, stage)
            }
        specificBuildTypes.forEach(this::buildType)

        performanceTests =
            stage.performanceTests.map { createPerformanceTests(model, performanceTestBucketProvider, stage, it) } +
            stage.flameGraphs.map { createFlameGraphs(model, stage, it) }

            }
        skipConditionally(buildType)
    }
}

fun BuildStep.onlyRunOnGitHubMergeQueueBranch() {
    conditions {
        matches("teamcity.build.branch", "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)
}

fun applyDefaultDependencies(
    model: CIBuildModel,
    buildType: BuildType,
) {
    if (buildType !is CompileAll) {

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

 */

package common

import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.BuildSteps
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.buildSteps.script

fun BuildType.applyPerformanceTestSettings(
    os: Os = Os.LINUX,
    arch: Arch = Arch.AMD64,
    timeout: Int = 30,
) {
    applyDefaultSettings(os = os, arch = arch, timeout = timeout)

import common.Os
import common.VersionedSettingsBranch
import common.javaHome
import common.requiresOs
import common.toCapitalized
import jetbrains.buildServer.configs.kotlin.AbsoluteId
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.ParameterDisplay
import jetbrains.buildServer.configs.kotlin.buildSteps.exec
import jetbrains.buildServer.configs.kotlin.triggers.finishBuildTrigger

        name = "Docs Test - ${testJava.version.toCapitalized()} ${os.asName()}"
    }) {
    val docsTests = testTypes.map { DocsTest(model, stage, os, testJava, it) }

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

class DocsTestTrigger(
    model: CIBuildModel,
    docsTestProject: DocsTestProject,
) : OsAwareBaseGradleBuildType(os = docsTestProject.os, init = {

                        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,

  }

  compileOptions {
    targetCompatibility(JavaVersion.VERSION_11)
    sourceCompatibility(JavaVersion.VERSION_11)
  }

  kotlinOptions {
    jvmTarget = JavaVersion.VERSION_11.toString()
  }

  buildTypes {
    release {
      isShrinkResources = true
      isMinifyEnabled = true
      signingConfig = signingConfigs.getByName("debug")