@ParameterizedTest
    @CsvSource(
        value = [
            "myParam, true,  '--daemon'",
            "''     , true,  '--daemon'",
            "myParam, false, '--no-daemon'",
            "''     , false, '--no-daemon'"
        ]
    )
    fun `can apply defaults to linux test configurations`(extraParameters: String, daemon: Boolean, expectedDaemonParam: String) {

    timeout: Int = 90,
    daemon: Boolean = true,
    buildJvm: Jvm = BuildToolBuildJvm,
    extraSteps: BuildSteps.() -> Unit = {}
) {
    buildType.applyDefaultSettings(os, timeout = timeout, buildJvm = buildJvm)

    buildType.killProcessStep(KILL_LEAKED_PROCESSES_FROM_PREVIOUS_BUILDS, os)
    buildType.gradleRunnerStep(model, gradleTasks, os, extraParameters, daemon)

    buildType.steps {

Each process, or "runtime", applies different constraints to the code that runs in that process.
For example, each process has different supported JVMs and a different set of services available for dependency injection.

    val testJvmVersionParameter = "testJavaVersion"
    val testTaskParameterName = "testTask"
    val testNameParameterName = "testName"
    val testTaskOptionsParameterName = "testTaskOptions"
    val daemon = true
    applyDefaultSettings(os, arch, buildJvm = BuildToolBuildJvm, timeout = 0)

    // Show all failed tests here, since that is what we are interested in
    failureConditions.supportTestRetry = false

        "-PmaxParallelForks=$maxParallelForks",
        pluginPortalUrlOverride,
        "-s",
        "--no-configuration-cache",
        "%additional.gradle.parameters%",
        if (daemon) "--daemon" else "--no-daemon",
        if (isContinue) "--continue" else ""
    )

fun Dependencies.dependsOn(buildTypeId: RelativeId) {
    dependency(buildTypeId) {
        snapshot {

# Build state model

The Gradle daemon tracks state for various elements. These are arranged in a hierarchy:

```mermaid
  graph TD

  process["build process"]
  
  session["build session"]
  process --> session
  
  build_tree["build tree"]
  session --> build_tree
  
  build1["root build"]
  build_tree --> build1
  
  project1["root project"]
  build1 --> project1
  
  project2["project"]
  build1 --> project2

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
fun BuildSteps.substDirOnWindows(os: Os) {
    if (os == Os.WINDOWS) {
        script {
            name = "SETUP_VIRTUAL_DISK_FOR_PERF_TEST"

    "groups" : [ {
      "testProject" : "largeJavaMultiProjectNoBuildSrc",
      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    } ]
  }, {
    "testId" : "org.gradle.performance.regression.java.JavaConfigurationCachePerformanceTest.assemble loading configuration cache state with hot daemon",
    "groups" : [ {

            + ").*";
    }

    static String generateLeakingProcessKillPattern(String rootProjectDir) {
        String kotlinCompilerDaemonPattern = "(?:" + quote("-Dkotlin.environment.keepalive") + ".+org\\.jetbrains\\.kotlin\\.daemon\\.KotlinCompileDaemon)";
        String quotedRootProjectDir = quote(rootProjectDir);
        String perfTestClasspathPattern = "(?:-cp.+\\\\build\\\\tmp\\\\performance-test-files.+?" + GRADLE_MAIN_CLASS_PATTERN_STR + ")";

It is made up of 3 architecture modules:

- **core-runtime**: Provides the runtimes or "containers" in which code runs. These runtimes include the Gradle client, the daemon and the worker processes. This is the base module on which all other architecture modules depend.