"-Porg.gradle.performance.db.username" to "%performance.db.username%"
).map { (key, value) -> os.escapeKeyValuePair(key, value) }

const val individualPerformanceTestArtifactRules = """
testing/*/build/test-results-*.zip => results
testing/*/build/tmp/**/log.txt => failure-logs
testing/*/build/tmp/**/profile.log => failure-logs
testing/*/build/tmp/**/daemon-*.out.log => failure-logs
"""

// to avoid pathname too long error

 */
plugins {
    `java-library`
    `java-test-fixtures`
    groovy
    id("gradlebuild.dependency-modules")
}

// The below mimics what the java-library plugin does, but creating a library of test fixtures instead.

sourceSets.matching { it.name.endsWith("Test") }.all {
    // the 'test' (with lower case 't') source set is already configured to use test fixtures by the JavaTestFixturesPlugin

	quarkus/test-framework/h2/pom.xml
quarkus/integration-tests/kubernetes-client/pom.xml
	quarkus/extensions/resteasy-classic/resteasy-jackson/runtime/pom.xml
	quarkus/extensions/kubernetes-config/runtime/pom.xml
	quarkus/extensions/openshift-client/runtime/pom.xml
	quarkus/test-framework/junit5/pom.xml
	quarkus/test-framework/junit5-internal/pom.xml
	quarkus/test-framework/kubernetes-client/pom.xml

API changes
-----------

We make changes to Guava's public [APIs][], including adding new APIs, very
carefully. Because of this, if you're interested in seeing a new feature in
Guava, the best approach is to create an [issue][] (or comment on an existing
issue if there is one) requesting the feature and describing specific use cases
for it.

If the feature has merit, it will go through a thorough process of API design

import org.junit.Assert.assertTrue
import org.junit.Test
import java.util.Locale


class GroovyInteroperabilityTest {

    @Test
    fun `can use closure with single argument call`() {
        val list = arrayListOf<Int>()
        closureOf<MutableList<Int>> { add(42) }.call(list)
        assertEquals(42, list.first())
    }

    @Test
    fun `can use closure with single nullable argument call`() {

go test -c ./pkg/...
exists -exec pkg1.test$GOEXE
exists -exec pkg2.test$GOEXE

! go test -c -o $WORK/bin/test/bin.test.exe ./pkg/...
stderr '^with multiple packages, -o must refer to a directory or '$devnull

! go test -c ./...
stderr '^cannot write test binary pkg1.test for multiple packages:\nexample/anotherpkg/pkg1\nexample/pkg/pkg1'

! go test -c -o $WORK/bin/test/ ./...

            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)
            )
            ErroneousStatement (

# Regression test for https://go.dev/issue/64282.
#
# 'go install' and 'go run' with pkg@version arguments should make
# a best effort to parse flags relevant to downloading modules
# (currently only -modcacherw) before actually downloading the module
# to identify which toolchain version to use.
#
# However, the best-effort flag parsing should not interfere with
# actual flag parsing if we don't switch toolchains. In particular,

go list -pgo=auto -deps ./a ./b ./nopgo
stdout 'test/dep \[test/a\]'
stdout 'test/dep \[test/b\]'
stdout 'test/dep$'

# Here we have 3 main packages, a, b, and nopgo, where a and b each has
# its own default.pgo profile, and nopgo has none.
# All 3 main packages import dep and dep2, both of which then import dep3
# (a diamond-shape import graph).
-- go.mod --
module test
go 1.20
-- a/a.go --
package main

mkdir test-splits
del /f /q test-splits\include-test-classes.properties
del /f /q test-splits\exclude-test-classes.properties
(
$linesWithEcho
) > test-splits\$action-test-classes.properties
echo "Tests to be ${action}d in this build"
type test-splits\$action-test-classes.properties
"""

    return {
        script {
            name = "PREPARE_TEST_CLASSES"
            executionMode = BuildStep.ExecutionMode.ALWAYS