.select("span")
            .text()
            .substringBefore(" If you did this intentionally")
    }


private
fun Document.scrapeMessagesForSeverity(severity: String): List<ReportMessage> =

    select("tr.severity-$severity").map { tr ->
        val entry = tr.select("td")[1]
        ReportMessage(
            entry.select("span")
                .text().substringBefore(" If you did this intentionally"),

import java.util.concurrent.Callable
import javax.xml.parsers.DocumentBuilderFactory


object Config {
    const val performanceTestReportsDir = "performance-tests/report"
    const val performanceTestResultsJsonName = "perf-results.json"
    const val performanceTestResultsJson = "performance-tests/$performanceTestResultsJsonName"

    // Android Studio Jellyfish 2023.3.1
    // Find all references here https://developer.android.com/studio/archive

            documentationSection = DocumentationSection.NotYetImplementedBuildServiceInFingerprint
        ) {
            text(" BuildServiceProvider of service ")
            reference(value.serviceDetails.implementationType)
            text(" with name ")
            reference(value.serviceDetails.name)
            text(" used at configuration time")
        }
    }

    }

    def "can load artifact from cache"() {
        def srcFile = tempDir.file("cached.zip")
        srcFile.text = "Data"
        server.expectGet("/cache/${key.hashCode}", srcFile)

        when:
        def receivedInput = null
        cache.load(key) { input ->
            receivedInput = input.text
        }

        then:
        receivedInput == "Data"
    }

                        outputFile = target.layout.buildDirectory.file('out')
                    }
                    flowScope.always(PrintAction) {
                        parameters.text = producer.flatMap { it.outputFile }.map { it.asFile.text }
                    }
                }
            }

            abstract class Producer extends DefaultTask {
                @OutputFile abstract RegularFileProperty getOutputFile()

                    text("subprojects")
                    if (relativeToAnother) {
                        text(" of project ")
                        reference(access.relativeTo)
                    }
                }

                ALLPROJECTS -> {
                    text("subprojects")
                    if (relativeToAnother) {
                        text(" of project ")

    val unixScript = """
mkdir -p test-splits
rm -rf test-splits/*-test-classes.properties
cat > test-splits/$action-test-classes.properties << EOL
${testClasses.joinToString("\n")}
EOL
echo "Tests to be ${action}d in this build"
cat test-splits/$action-test-classes.properties
"""

    val linesWithEcho = testClasses.joinToString("\n") { "echo $it" }

    val windowsScript = """
mkdir test-splits

                println("Stage 2")""".trimIndent())

        assertProgramOf(
            emptyBuildscriptSource,
            Program.Script(
                emptyBuildscriptSource.map {
                    text("               \n@Suppress(\"unused_variable\")\nprintln(\"Stage 2\")")
                }
            )
        )
    }

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

                println("##teamcity[buildStatus text='{build.status.text}: ${this.buildScanUri}']")
            }
            buildFinished {
                println("##teamcity[setParameter name='env.GRADLE_RUNNER_FINISHED' value='true']")
                if (failures.isEmpty()) {
                    println("##teamcity[buildStatus status='SUCCESS' text='Retried build succeeds']")
                }
            }

            inputName == 'gradle.properties'
        )

        given:
        def configurationCache = newConfigurationCacheFixture()
        file("buildSrc/build.gradle.kts").text = """

            interface Params: $ValueSourceParameters.name {
                val value: Property<String>
            }

            abstract class IsCi : $ValueSource.name<String, Params> {