private final MavenSession mavenSession;
    private final MavenRepositorySystem mavenRepositorySystem;
    private final RuntimeInformation runtimeInformation;
    private final Map<String, Project> allProjects = new ConcurrentHashMap<>();

    @SuppressWarnings("checkstyle:ParameterNumber")
    public DefaultSession(
            @Nonnull MavenSession session,
            @Nonnull RepositorySystem repositorySystem,

    def setup() {
        buildB = multiProjectBuild("buildB", ['b1', 'b2']) {
            file("buildSrc/src/main/java/Thing.java") << "class Thing { }"
            buildFile << """
                allprojects {
                    apply plugin: 'java'
                }
            """
        }
        includedBuilds << buildB
    }

    def "includes build identifier in logging output with #display"() {

        event.parent.descriptor.name == "ThingTest"
    }

    def javaProjectWithTests() {
        buildFile << """
            allprojects {
                apply plugin: 'java'
                ${mavenCentralRepository()}
                dependencies { ${testImplementationConfiguration} 'junit:junit:4.13' }
            }
"""

        and:
        createDirs("projectA", "projectB")
        settingsFile << "include 'projectA', 'projectB'"

        buildFile << """
allprojects {
    apply plugin: 'java-library'

    repositories {
        maven { url '$mavenRepo.uri' }
    }
}

project(':projectA') {
    dependencies {

    @Issue("gradle/performance#502")
    def "local component selection harness test: thread-safety"() {
        given:
        buildFile << '''
             def usage = Attribute.of('usage', String)
             allprojects {

                dependencies {
                    attributesSchema {
                        attribute(usage)
                    }
                }
                configurations {

        given:
        settingsFile << """
            include 'a', 'b'
        """
        buildFile << """
            println "root project"
            // Some nested build operations
            allprojects {
                println "configure \$path"
            }
            tasks.register("thing") {
                println "create \$path"
            }
            tasks.thing.description = "does something"

        def subprojects = []
        projectCount.times {
            subprojects << "sub" + it
        }
        multiProjectBuild("root", subprojects) {
            buildFile << """
                allprojects {
                    apply plugin: 'java'

                    // ~25MB
                    ext.memoryHog = new byte[1024*1024*25]

                    tasks.withType(JavaCompile).configureEach {

        this.buildFile = buildFile
        this.config = config
    }

    void prepare(String config = this.config) {
        buildFile << """
            allprojects {
                tasks.register("checkDeps") {
                    if (${GradleContextualExecuter.configCache}) {
                        def files = configurations.${config}
                        doLast {

                </tr>
            </thead>
            <tr>
                <td>modules</td>
                <td><literal>project.allprojects.idea.module</literal></td>
                <td/>
            </tr>
            <tr>
                <td>vcs</td>
                <td/>
                <td/>
            </tr>
            <tr>

        delegate.rootProject(action.withCrossProjectModelAccessCheck())
    }

    override fun allprojects(action: Action<in Project>) {
        // Use the delegate's implementation of `rootProject` to ensure that the action is only invoked once the rootProject is available
        delegate.rootProject {
            // Instead of the rootProject's `allProjects`, collect the projects while still tracking the current referrer project