val expected = """
            LocalValue [indexes: 0..9, line/column: 1/1..1/10, file: test] (
                name = a
                rhs = IntLiteral [indexes: 8..9, line/column: 1/9..1/10, file: test] (1)
            )
            LocalValue [indexes: 10..19, line/column: 2/1..2/10, file: test] (
                name = b
                rhs = IntLiteral [indexes: 18..19, line/column: 2/9..2/10, file: test] (2)
            )

            Script '${script.canonicalPath}' line: 1
            """
        }
    }

    @Test
    fun `location of exception thrown from buildscript block is reported`() {

        val script = withBuildScript("buildscript { $boom }")

        assertFailingBuildOutputOf("help") {
            """
            * Where:
            Build file '${script.canonicalPath}' line: 1
            """
        }
    }

        psOutput.forEach(line -> {
            Matcher commandLineArgsMatcher = commandLineArgsPattern.matcher(line);
            Matcher pidMatcher = pidPattern.matcher(line);
            if (commandLineArgsMatcher.find() && pidMatcher.find()) {
                String pid = pidMatcher.group(1);
                if (!MY_PID.equals(pid)) {
                    action.accept(pid, line);
                }
            }

            scriptCompilationErrors.filter { it.location != null }
                .sortedBy { it.location!!.line }
    }

    init {
        require(scriptCompilationErrors.isNotEmpty())
    }

    val firstErrorLine
        get() = errors.asSequence().mapNotNull { it.location?.line }.firstOrNull()

    override val message: String
        get() = (

fi

# Use "xargs" to parse quoted args.
#
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
#
# In Bash we could simply go:
#
#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
#   set -- "${ARGS[@]}" "$@"
#
# but POSIX shell has neither arrays nor command substitution, so instead we
# post-process each arg (as a line of input to sed) to backslash-escape any

        }
    }

    fun assertSingleLineWarningReport(message: String, line: Int) {
        assertSingleEditorReport()
        reports.single().let { report ->
            assertThat(report.severity, equalTo(ReportSeverity.WARNING))
            assertThat(report.position, notNullValue())
            assertThat(report.position!!.line, equalTo(line))
            assertThat(report.message, equalTo(message))
        }
    }
}

            if (file.endsWith(".gradle.kts")) {
                withProblem("Settings file '${relativePath(file)}': external process started")
            } else {
                withProblem("Settings file '${relativePath(file)}': line 5: external process started")
            }
        }

        where:
        snippetsFactory             | file
        exec().groovy               | "included/settings.gradle"

System_Ext(kotlinTools, "Kotlin Toolchain", "kotlinc, Gradle plugin etc...")

System_Ext(buildCache, "Gradle Build Cache", "Local, Develocity Build Cache Node, etc...")

Rel(dev, gradle, "Uses", "Command Line")
Rel(gradleKotlinDsl, kotlinTools, "Uses")
Rel(gradleKotlinDsl, buildCache, "Uses")

Rel(dev, ide, "Uses", "GUI")
Rel_U(ide, gradle, "Uses", "Tooling API")
Rel(ide, gradleKotlinDsl, "Uses")

        then:
        output.indexOf('initscript2!') < output.indexOf('initscript1!')
        configurationCache.assertStateStored()
    }

    def "invalidates cache upon adding init script to command line"() {

        given:
        def initScript1 = file('initscript1.gradle.kts').tap {
            text = 'println("initscript1!")'
        }
        def initScript2 = file('initscript2.gradle').tap {

    text(
        "profiler",
        defaultProfiler,
        display = ParameterDisplay.PROMPT,
        allowEmpty = false,
        description = "Command line option for the performance test task to enable profiling. For example `async-profiler`, `async-profiler-heap`, `async-profiler-all` or `jfr`. Use `none` for benchmarking only."
    )
}