import model.PerformanceTestType
import model.Stage

class PerformanceTest(
    model: CIBuildModel,
    stage: Stage,
    performanceTestBuildSpec: PerformanceTestBuildSpec,
    description: String,
    performanceSubProject: String,
    val testProjects: List<String>,
    val bucketIndex: Int,
    extraParameters: String = "",
    performanceTestTaskSuffix: String = "PerformanceTest",
    preBuildSteps: BuildSteps.() -> Unit = {}

                }
            }
            performanceTestProject.performanceTests.forEachIndexed { index, performanceTest ->
                if (performanceTest.testProjects.isNotEmpty()) {
                    artifacts(performanceTest.id!!) {
                        id = "ARTIFACT_DEPENDENCY_${performanceTest.id!!}"
                        cleanDestination = true

                ).joinToString(" "),
            performanceTest.getGradleStep("GRADLE_RUNNER").gradleParams!!.trim()
        )
        assertEquals(BuildStep.ExecutionMode.DEFAULT, performanceTest.getGradleStep("GRADLE_RUNNER").executionMode)
    }

    @Test
    fun `create correct PerformanceTest build type for Windows`() {
        val performanceTest = PerformanceTest(
            buildModel,
            Stage(

    }

    private
    fun createFlameGraphBuild(model: CIBuildModel, stage: Stage, flameGraphGenerationBuildSpec: FlameGraphGeneration.FlameGraphGenerationBuildSpec, bucketIndex: Int): PerformanceTest = flameGraphGenerationBuildSpec.run {
        PerformanceTest(
            model,
            stage,
            flameGraphGenerationBuildSpec,

    val descriptionWithMaybeBucketIndex = if (performanceTestCoverage.type == PerformanceTestType.flakinessDetection)
        "$description - index $bucketIndex"
    else
        description
    return PerformanceTest(
        model,
        stage,
        performanceTestCoverage,

package projects

import configurations.PerformanceTest
import jetbrains.buildServer.configs.kotlin.Project
import model.CIBuildModel
import model.PerformanceTestBucketProvider
import model.PerformanceTestCoverage
import model.PerformanceTestProjectSpec
import model.Stage

abstract class PerformanceTestProject(model: CIBuildModel, val spec: PerformanceTestProjectSpec, val performanceTests: List<PerformanceTest>) : Project({

 */
import gradlebuild.basics.BuildEnvironment
import gradlebuild.docs.FindBrokenInternalLinks
import gradlebuild.integrationtests.tasks.DistributionTest
import gradlebuild.performance.tasks.PerformanceTest
import gradlebuild.testcleanup.extension.TestFilesCleanupBuildServiceRootExtension
import gradlebuild.binarycompatibility.JapicmpTask

if (BuildEnvironment.isCiServer && project.name != "gradle-kotlin-dsl-accessors") {

    artifactRules = """
        build/report-*-performance-tests.zip => .
        build/report-*-performance.zip => $hiddenArtifactDestination
        build/report-*PerformanceTest.zip => $hiddenArtifactDestination
    """.trimIndent()
    detectHangingBuilds = false
    requirements {
        requiresNotEc2Agent()
        requiresNotSharedHost()
    }
    params {

    fun asConfigurationId(model: CIBuildModel, bucket: String) =
        "${asConfigurationId(model)}$bucket"

    override
    fun asConfigurationId(model: CIBuildModel) =
        "${model.projectId}_${oldUuid ?: "PerformanceTest$uuid"}"

    override
    fun asName(): String =
        "${type.displayName} - ${os.asName()}${if (withoutDependencies) " without dependencies" else ""}"

    override
    fun channel() =

    const val MAX_TEST_DISTRIBUTION_LOCAL_EXECUTORS = "maxTestDistributionLocalExecutors"
    const val PERFORMANCE_BASELINES = "performanceBaselines"
    const val PERFORMANCE_TEST_VERBOSE = "performanceTest.verbose"
    const val PERFORMANCE_DB_PASSWORD = "org.gradle.performance.db.password"
    const val PERFORMANCE_DB_PASSWORD_ENV = "PERFORMANCE_DB_PASSWORD_TCAGENT"
    const val PERFORMANCE_CHANNEL_ENV = "PERFORMANCE_CHANNEL"