// InvertStages subtracts the given array of stages from all stages
func InvertStages(stages []audit.Stage) []audit.Stage {
	s := ConvertStagesToStrings(stages)
	a := AllStages()
	a.Delete(s...)
	return ConvertStringSetToStages(a)
}

// ConvertStagesToStrings converts an array of stages to a string array
func ConvertStagesToStrings(stages []audit.Stage) []string {
	s := make([]string, len(stages))
	for i, stage := range stages {

)

func TestInvertStages(t *testing.T) {
	for _, test := range []struct {
		desc           string
		stages         []audit.Stage
		expectedStages []audit.Stage
	}{
		{
			desc: "should remove one",
			stages: []audit.Stage{
				audit.StageResponseStarted,
			},
			expectedStages: []audit.Stage{
				audit.StageRequestReceived,
				audit.StageResponseComplete,
				audit.StagePanic,
			},
		},
		{

cleanup() {
    rm -rf "${DOWNLOAD_DIR}"
    rm -rf "${STAGING_DIR}"
    cd "${CWD}"
}

# Delete temporary directories on exit
trap cleanup EXIT

mkdir "${ACI_DIR}"

# Convert docker image to aci and stage it
echo "Downloading docker2aci ${DOCKER2ACI_VERSION}"
wget "https://github.com/appc/docker2aci/releases/download/${DOCKER2ACI_VERSION}/docker2aci-${DOCKER2ACI_VERSION}.tar.gz" >/dev/null 2>&1

        assertProgramOf(
            source,
            Program.Buildscript(source.fragment(1..11, 13..34))
        )
    }

    @Test
    fun `non-empty Stage 1 with non-empty Stage 2 parse to Stage 1 followed by Stage 2`() {

        val source = ProgramSource(
            "/src/fragment.gradle.kts",
            "\r\n\r\nplugins {\r\n  java\r\n}\r\nprintln(\"Stage 2\")\r\n\r\n"
        )

import org.junit.Test


class ProgramParserAnnotationErasureTest {

    @Test
    fun `empty Stage 1 with non-empty Stage 2 parse to Stage 2 with Stage 1 fragments erased`() {
        val scriptOnlySource =
            programSourceWith("""
                @Suppress("unused_variable")
                println("Stage 2")""".trimIndent())

        assertProgramOf(
            scriptOnlySource,

            "stage 1 buildscript\nstage 1 plugins\n"
        )
    }

    @Test
    fun `pluginManagement then buildscript then plugins`() {
        val source = ProgramSource(
            "settings.gradle.kts",
            """
            pluginManagement { println("stage 1 pluginManagement") }
            buildscript { println("stage 1 buildscript") }
            plugins { println("stage 1 plugins") }

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

        )
    }

    var prevStage: Stage? = null
    val previousPerformanceTestPasses: MutableList<PerformanceTestsPass> = mutableListOf()
    model.stages.forEach { stage ->
        if (isSecurityFork() && stage.stageName > StageName.READY_FOR_RELEASE) {
            return@forEach
        }
        val stageProject = StageProject(model, functionalTestBucketProvider, performanceTestBucketProvider, stage, previousPerformanceTestPasses)

         * */
        String getLanguage();

        /**
         * The compile stage as a descriptive String.
         * Build scripts can be processed in multiple stages, depending on the language.
         * Groovy backed build scripts are processed in two stages.
         * Kotlin backed build scripts are processed in three stages
         * */
        String getStage();
    }

    public interface Result {
    }

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

class FlakyTestQuarantine(model: CIBuildModel, stage: Stage, os: Os, arch: Arch = Arch.AMD64) : BaseGradleBuildType(stage = stage, init = {
    id("${model.projectId}_FlakyQuarantine_${os.asName()}_${arch.asName()}")
    name = "Flaky Test Quarantine - ${os.asName()} ${arch.asName()}"