}

configurations {
    create("gradleScriptsElements") {
        isVisible = false
        isCanBeResolved = false
        isCanBeConsumed = true
        attributes.attribute(Usage.USAGE_ATTRIBUTE, objects.named("start-scripts"))
        outgoing.artifact(startScripts)
    }

        )
    }
}


private
fun <T> Parser<T>.consumeFrom(input: String): String {
    val kotlinLexer = KotlinLexer()
    val result = kotlinLexer.let { lexer ->
        lexer.start(input)
        this(lexer)
    }
    if (result is ParserResult.Failure) {
        throw Exception(result.reason)
    }
    return input.substring(0, kotlinLexer.currentPosition.offset)
}

    fun blockAnnotations(fragment: ProgramSourceFragment?, allAnnotations: List<IntRange>): List<IntRange> {
        val start = fragment?.let { it.section.firstAnnotationStart }
        val end = fragment?.let { it.section.wholeRange.first }
        if (start != null && end != null) {
            val annotationRangeForBlock = start until end - 1
            return allAnnotations.filter {

        StartScriptTemplateBindingFactory.windows(),
        FileCollectionBackedTextResource(temporaryFileProvider, windowsScriptTemplate, StandardCharsets.UTF_8)
    )

    /**
     * Modifies the start script injecting -javaagent flags. The start script file is updated in-place by appending Java agent switches to 'DEFAULT_JVM_OPTS' variable declaration.
     */
    private
    fun File.injectAgentOptions(separator: String) {

fun CharSequence.linePreservingSubstring_(range: IntRange): Pair<Int, String> {
    val lineCount = take(range.start).count { it == '\n' }
    return lineCount to "\n".repeat(lineCount) + substring(range)
}


internal
fun CharSequence.linePreservingBlankRanges(ranges: List<IntRange>): String =
    ranges
        .sortedByDescending { it.start }
        .fold(this, CharSequence::linePreservingBlankRange)
        .toString()


private

object StartReleaseCycleTest : BasePromotionBuildType(vcsRootId = gradlePromotionBranches, cleanCheckout = false) {
    init {
        id("Promotion_AllBranchesStartReleaseCycleTest")
        name = "Start Release Cycle Test"
        description = "Test for Start Release Cycle pipeline"

        steps {
            gradleWrapper {
                name = "PromoteTest"
                tasks = "clean promoteStartReleaseCycle"

The build session state is managed by the `BuildSessionState` class.
An instance is created at the start of a Gradle invocation and discarded at the end of that invocation.

The build session state also includes "cross session" state that is shared with any "nested" sessions that need to be created.

                "The precompiled plugin (${
                "src/main/kotlin/org.gradle.my-plugin.gradle.kts".replace(
                    "/",
                    File.separator
                )
                }) cannot start with 'org.gradle' or be in the 'org.gradle' package."
            )
            .assertHasResolution(getPrecompiledPluginsLink())
    }

    @Test

            model.buildTypes.map { it.name }
        )
    }

    @Test
    fun `promotion project has expected build types for other branches`() {

object StartReleaseCycle : BasePromotionBuildType(vcsRootId = gradlePromotionMaster) {
    init {
        id("Promotion_StartReleaseCycle")
        name = "Start Release Cycle"
        description = "Promotes a successful build on master as the start of a new release cycle on the release branch"

        params {