override fun createFunctionalTestsFor(stage: Stage, testCoverage: TestCoverage): List<FunctionalTest> {
        return when {
            testCoverage.testType == TestType.quickFeedbackCrossVersion -> quickCrossVersionTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)
            testCoverage.testType == TestType.allVersionsCrossVersion -> allCrossVersionTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)

import jetbrains.buildServer.configs.kotlin.buildSteps.script
import model.CIBuildModel
import model.Stage

/**
 * Build a Gradle distribution (dogfood-first) and use this distribution to build a distribution again (dogfood-second).
 * Use `dogfood-second` to run `test sanityCheck`.
 */
class Gradleception(
    model: CIBuildModel,
    stage: Stage,
    buildJvm: Jvm,
    jvmDescription: String,
    bundleGroovy4: Boolean = false,

package configurations

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

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

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

class StagePasses(model: CIBuildModel, stage: Stage, prevStage: Stage?, stageProject: StageProject) : BaseGradleBuildType(init = {
    id(stageTriggerId(model, stage))
    uuid = stageTriggerUuid(model, stage)
    name = stage.stageName.stageName + " (Trigger)"
    type = Type.COMPOSITE

package configurations

import common.Os.LINUX
import model.CIBuildModel
import model.Stage

class BuildDistributions(model: CIBuildModel, stage: Stage) : BaseGradleBuildType(stage = stage, init = {
    id("${model.projectId}_BuildDistributions")
    name = "Build Distributions"
    description = "Creation and verification of the distribution and documentation"

    applyDefaults(
        model,
        this,
        "packageBuild",

package configurations

import model.CIBuildModel
import model.Stage

class CompileAll(model: CIBuildModel, stage: Stage) : BaseGradleBuildType(stage = stage, init = {
    id(buildTypeId(model))
    name = "Compile All"
    description = "Compiles all production/test source code and warms up the build cache"

    features {
        publishBuildStatusToGithub(model)
    }

    applyDefaults(
        model,
        this,

import common.killProcessStep
import common.skipConditionally
import jetbrains.buildServer.configs.kotlin.BuildSteps
import model.CIBuildModel
import model.Stage

class TestPerformanceTest(model: CIBuildModel, stage: Stage) : BaseGradleBuildType(stage, init = {
    val os = Os.LINUX
    val buildTypeThis = this
    val testProject = "smallJavaMultiProject"

    fun BuildSteps.gradleStep(tasks: List<String>) {

node(jenkinsEnv.nodeSelection(osNode)) {
    dir('build') {
        stage('Checkout') {
            checkout scm
        }

        def WORK_DIR=pwd()
        def MAVEN_GOAL='verify'

        stage('Configure deploy') {
           if (env.BRANCH_NAME in ['master', 'maven-3.8.x', 'maven-3.9.x']){
               MAVEN_GOAL='deploy'
           }
        }

        stage('Build / Unit Test') {

    override
    fun createPerformanceTestsFor(model: CIBuildModel, stage: Stage, performanceTestCoverage: PerformanceTestCoverage, bucketIndex: Int): PerformanceTest = createPerformanceTest(
        model,
        performanceTestCoverage,
        stage,
        bucketIndex,
        "Performance tests for $testProject",
        mapOf(testProject to scenarios)
    )
}

    val testCoverage: TestCoverage,
    stage: Stage,
    parallelizationMethod: ParallelizationMethod = ParallelizationMethod.None,
    subprojects: List<String> = listOf(),
    extraParameters: String = "",
    maxParallelForks: String = "%maxParallelForks%",
    extraBuildSteps: BuildSteps.() -> Unit = {},
    preBuildSteps: BuildSteps.() -> Unit = {}
) : BaseGradleBuildType(stage = stage, init = {
    this.name = name