assert details.projectPath == ':'
            assert parentId == configureBuildLogicBuild.id
        }

        def workGraphOps = operations.all(CalculateTreeTaskGraphBuildOperationType)
        assert workGraphOps.size() == 3

        def calculateWorkOps = operations.all(CalculateTaskGraphBuildOperationType)
        assert calculateWorkOps.size() == 3
        with(calculateWorkOps[0]) {

        }
}


class LazyEnvironmentVariable(private val callable: Callable<String>) {
    override fun toString(): String {
        return callable.call()
    }
}


private
fun Project.loadScenariosFromFile(testProject: String): List<String> {
    val scenarioFile = repoRoot().file("performance-test-splits/include-$testProject-performance-scenarios.csv").asFile

        build/tmp/teŝt files/** => $hiddenArtifactDestination/teŝt-files
        build/errorLogs/** => $hiddenArtifactDestination/errorLogs
        subprojects/internal-build-reports/build/reports/incubation/all-incubating.html => incubation-reports
        build/reports/dependency-verification/** => dependency-verification-reports
    """.trimIndent()

    paramsForBuildToolBuild(buildJvm, os, arch)
    params {

    const val GRADLE_INSTALL_PATH = "gradle_installPath"


    /**
     * Specify the flaky test quarantine strategy:
     *
     * -PflakyTests=include: run all tests, including flaky tests.
     * -PflakyTests=exclude: run all tests, excluding flaky tests.
     * -PflakyTests=only: run flaky tests only.
     *
     * Default value (if absent) is "include".
     */
    const val FLAKY_TEST = "flakyTests"

To stop running Daemon processes, use the following command:

----
$ gradle --stop
----

This terminates all Daemon processes started with the same version of Gradle used to execute the command.

You can also kill Daemons manually with your operating system.
To find the PIDs for all Daemons regardless of Gradle version, see <<gradle_daemon.adoc#find_all_daemons,Find Daemons>>.

[[sec:daemon_jvm_criteria]]

        def parent2Edge = edge(root, false)
        def parent1 = parent1Edge.targetComponent.nodes[0]
        def parent2 = parent2Edge.targetComponent.nodes[0]
        collectOwnStrictVersions(root, ['a']) //root, on all paths
        collectOwnStrictVersions(parent1, ['b', 'c'])
        collectOwnStrictVersions(parent2, ['b', 'd'])

        def child = nextNode()
        def edge1 = edge(parent1, false, null, child)

            displayName = "Aggregating test results of an application/distribution (Incubating)"
            description = "Report all test results using the application/distribution of a multi-module project."
            category = "Java"
            common {
                from(templates.javaApplicationAsSubproject)

                        preserved.add(serviceRegistration);
                    }
                }).rethrow();
            } finally {
                // Replace the entire container, rather than clear it, to discard all the service instances and because it may contain configuration actions and
                // other state that can affect the service instances when they are registered again

            equalTo("file 'displayNameOf(inputFile)' has been removed")
        )
    }

    @Test
    fun `build input file is replaced by directory`() {
        val inputFile = File("input.txt")
        // all we care is that it is changed from the original one
        val newDirectoryHash = TestHashCodes.hashCodeFrom(2)
        val originalFileHash = TestHashCodes.hashCodeFrom(1)
        assertThat(

        final Set<JavaVersion> remaining = Sets.newHashSet(versions);
        return getAvailableJdks(element -> remaining.remove(element.getLanguageVersion()));
    }

    /**
     * Returns all JDKs for the given java version.
     */
    public static List<Jvm> getAvailableJdks(final JavaVersion version) {
        return getAvailableJdks(element -> version.equals(element.getLanguageVersion()));
    }