}

    public Stream<BuildStep> allPredecessors() {
        return preds(new HashSet<>()).stream();
    }

    private Set<BuildStep> preds(Set<BuildStep> preds) {
        if (preds.add(this)) {
            this.predecessors.forEach(n -> n.preds(preds));
        }
        return preds;
    }

    public boolean isSuccessorOf(BuildStep step) {
        return isSuccessorOf(new HashSet<>(), step);

                Map<String, BuildStep> steps = lifecycle
                        .allPhases()
                        .flatMap(phase -> {
                            BuildStep a = new BuildStep(BEFORE + phase.name(), project, phase);
                            BuildStep b = new BuildStep(phase.name(), project, phase);
                            BuildStep c = new BuildStep(AFTER + phase.name(), project, phase);

import common.Os
import common.PLUGINS_PORTAL_URL_OVERRIDE
import common.VersionedSettingsBranch
import configurations.BaseGradleBuildType
import configurations.PerformanceTest
import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.DslContext
import jetbrains.buildServer.configs.kotlin.buildSteps.GradleBuildStep
import model.CIBuildModel
import model.JsonBasedGradleSubprojectProvider

                "CHECK_CLEAN_M2_ANDROID_USER_HOME",
            ),
            steps.items.map(BuildStep::name),
        )
        verifyGradleRunnerParams(extraParameters, Os.WINDOWS)
    }

    private fun verifyGradleRunnerParams(
        extraParameters: String,
        os: Os = Os.LINUX,
    ) {
        assertEquals(BuildStep.ExecutionMode.DEFAULT, steps.getGradleStep("GRADLE_RUNNER").executionMode)

        assertEquals(

                onDependencyCancel = FailureAction.FAIL_TO_START
            }
        }

        if (******@****.***sk != null) {
            steps {
                buildStep(
                    ******@****.***arameters,
                    ******@****.***rName,
                    ******@****.***rEmail,

 * limitations under the License.
 */

import common.VersionedSettingsBranch
import common.toCapitalized
import jetbrains.buildServer.configs.kotlin.AbsoluteId
import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.DslContext
import jetbrains.buildServer.configs.kotlin.buildSteps.GradleBuildStep
import org.junit.jupiter.api.Assertions.assertEquals

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

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(

                        false,
                    )
            }
        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

package configurations

import common.applyDefaultSettings
import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.buildSteps.script

object DownloadGitRepoToEc2Agent : BuildType({
    val id = "Util_DownloadGitRepoToEc2Agent"
    name = "Download Git Repo to EC2 Agent"
    description = "Do nothing but downloading gradle/gradle repo to EC2 agents"

import common.BuildToolBuildJvm
import common.DefaultJvm
import common.JvmVendor
import common.JvmVersion
import common.Os
import common.applyDefaultSettings
import common.javaHome
import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.buildSteps.script
import model.CIBuildModel
import model.Stage

private val remoteProjectRefs =
    listOf(
        "androidSmokeTestProjectRef",