"Unexpected operation `$description`!"
        }
    }

    private
    fun operationDescription(stage: CachedScript.CompilationStage) =
        "Compile script ${stage.file.name} (${descriptionOf(stage)})"

    private
    fun descriptionOf(stage: CachedScript.CompilationStage) =
        if (stage.stage == "stage1") "CLASSPATH" else "BODY"

            val source: Program.Plugins? = null
        ) : StageTransition, Instruction()

        /**
         * An instruction that marks the transition from stage 1 to stage 2 by causing the
         * target scope to be closed thus making the resolved classpath available to stage 2.
         *
         * A valid [Static] program must contain one and only one [StageTransition] instruction.
         */
        interface StageTransition

private
fun pluginsBlockOf(program: Program): Program.Plugins? =
    when (program) {
        is Program.Plugins -> program
        is Program.Stage1Sequence -> program.plugins
        is Program.Staged -> pluginsBlockOf(program.stage1)
        else -> null
    }


private
fun parse(scriptPlugin: PrecompiledScriptPlugin): Program = ProgramParser.parse(
    ProgramSource(scriptPlugin.scriptFileName, scriptPlugin.scriptText),

    }
}


@VisibleForTesting
fun templateIdFor(programTarget: ProgramTarget, programKind: ProgramKind, stage: String): String =
    programTarget.name + "/" + programKind.name + "/" + stage


private
fun classLoaderScopeIdFor(scriptPath: String, stage: String) =
    "kotlin-dsl:$scriptPath:$stage"


private

            if (smokeTests.size > 1) {
                buildType(PartialTrigger("All Smoke Tests for ${stage.stageName.stageName}", "Stage_${stage.stageName.id}_SmokeTests", model, smokeTests))
            }
            if (crossVersionTests.size > 1) {
                buildType(PartialTrigger("All Cross-Version Tests for ${stage.stageName.stageName}", "Stage_${stage.stageName.id}_CrossVersionTests", model, crossVersionTests))
            }

// 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,
			},
		},
		{

	test(t, "namespaced", audit.LevelNone, stages, stages, "serviceAccounts")
	test(t, "namespaced", audit.LevelRequestResponse, stages, stages, "getPods")
	test(t, "namespaced", audit.LevelNone, stages, stages, "getClusterRoles")
	test(t, "namespaced", audit.LevelNone, stages, stages, "getLogs")
	test(t, "namespaced", audit.LevelNone, stages, stages, "getMetrics")

image1.png...

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