val startReleaseCycle = model.findBuildTypeByName("Start Release Cycle")

        val steps = startReleaseCycle.steps.items
        assertEquals(1, steps.size)

        val step = gradleStep(steps, 0)
        step.assertTasks("clean promoteStartReleaseCycle")

        sampleDirectory = generateSampleTask.flatMap { it.target }
        displayName = "Building $languageDisplayName $capKind$multiProjectSuffix"
        description = "Setup a $languageDisplayName $kind project$multiProjectSuffix step-by-step."
        category = language.toString()
    }
}

fun BuildSteps.customGradle(init: GradleBuildStep.() -> Unit, custom: GradleBuildStep.() -> Unit): GradleBuildStep =
    GradleBuildStep(init)
        .apply(custom)
        .also {
            step(it)
        }

/**
 * Adds a [Gradle build step](https://confluence.jetbrains.com/display/TCDL/Gradle)
 * that runs with the Gradle wrapper.
 *
 * @see GradleBuildStep
 */

  - If there are any errors, read the error and fix your code.
  - IMPORTANT NOTE: if the first import fails, you have to select and apply `Synchronization disabled`, then repeat the step above.
    Otherwise, TeamCity complains "Can't find the previous revision, please commit current settings first".

* Existing usages of Java serialization should be migrated to use it.
* It is ok for Serializer to be used as a replacement for Java serialization as a migration step.

        requiresNotSharedHost()
    }

    features {
        publishBuildStatusToGithub(model)
    }

    dependencies {
        // If SanityCheck fails, Gradleception will definitely fail because the last build step is also sanityCheck
        dependsOn(RelativeId(SanityCheck.buildTypeId(model)))
    }

    /*
     To avoid unnecessary rerun, what we do here is a bit complicated:

         * Only kill local Gradle processes (classpath in checkout directory).
         * Not clean up global Gradle processes (i.e. classpath in ~/.gradle/...).
         * Because the step is not guaranteed to run (e.g. build timeout), we need `KILL_LEAKED_PROCESSES_FROM_PREVIOUS_BUILDS` mode.
         */
        KILL_PROCESSES_STARTED_BY_GRADLE,
        /**

            const unescaped = p2.replace(/\\\*/g, '[^\\/]*')
            return p1 + unescaped
        }
    ],

    [
        // unescape, revert step 3 except for back slash
        // For example, if a user escape a '\\*',
        // after step 3, the result will be '\\\\\\*'
        /\\\\\\(?=[$.|*+(){^])/g,
        () => ESCAPE
    ],

    [
        // '\\\\' -> '\\'
        /\\\\/g,

    )

    @BeforeEach
    fun setUp() {
        val stepsCapturer = slot<BuildSteps.() -> Unit>()
        every { buildType.steps } returns steps
        every {
            buildType.steps(capture(stepsCapturer))
        } answers {
            stepsCapturer.captured(steps)
            mockk()
        }
    }

    @Test
    fun `can apply defaults to configurations`() {

    maxParallelForks: String = "%maxParallelForks%",
    extraSteps: BuildSteps.() -> Unit = {}, // the steps after runner steps
    daemon: Boolean = true,
    preSteps: BuildSteps.() -> Unit = {} // the steps before runner steps
) {
    buildType.applyDefaultSettings(os, timeout = timeout, buildJvm = buildJvm, arch = arch)

    buildType.steps {
        preSteps()
    }