class SlowTask extends DefaultTask {

                private final String projectName = project.name

                @TaskAction
                def go() {
                    ${server.callFromBuildUsingExpression("projectName")}
                }
            }

            subprojects {
                tasks.create('slow', SlowTask)
            }
            project(':a') {

    }

    def "projects are configured and models created in parallel when project scoped model is queried concurrently"() {
        withSomeToolingModelBuilderPluginInBuildSrc("""
            ${server.callFromBuildUsingExpression("'model-' + project.name")}
        """)
        settingsFile << """
            include("a")
            include("b")
            rootProject.name = "root"
        """
        apply(testDirectory)

                @Override
                void onFinish(FinishEvent event) {
                    if (event instanceof TaskFinishEvent) {
                        ${server.callFromBuildUsingExpression("parameters.prefix.get() + event.descriptor.taskPath")}
                    } else {
                        throw new IllegalArgumentException()
                    }
                }
            }

        given:
        server.start()
        buildFile << """
            @ParallelizableTask
            class ParTask extends DefaultTask {
                @TaskAction zzz() { ${server.callFromBuildUsingExpression('name')} }
            }

            task para1(type:ParTask)
            task para2(type:ParTask)
            task parallelTasks(dependsOn:[para1,para2])
        """

                    def finishEvent = project.name + "-finished"
                    doFirst {
                        ${barrier.callFromBuildUsingExpression('startEvent')}
                    }
                    doLast {
                        ${barrier.callFromBuildUsingExpression('finishEvent')}
                    }
                }
            }
            task otherBuild(type:GradleBuild) {

                    apply plugin: 'java'
                    compileJava {
                        def projectName = project.name
                        doLast {
                            ${server.callFromBuildUsingExpression('projectName')}
                        }
                    }
                }
            """
        }
        (1..maxWorkers).each {
            dependency "org.test:sub${it}:1.0"

        settingsFile << """
            include 'A', 'B', 'C', 'D'
        """
        buildFile << """
            subprojects {
                tasks.resolve.doFirst {
                    ${httpServer.callFromBuildUsingExpression("project.name")}
                }
            }
        """

        when:
        // Wait for each project to list versions concurrently
        httpServer.expectConcurrent("A", "B", "C", "D")

        """
        buildFile << """
            allprojects {
                task ping {
                    def projectName = project.name
                    doLast {
                        ${blockingServer.callFromBuildUsingExpression("projectName")}
                    }
                }
            }
        """
    }

    @ToBeFixedForIsolatedProjects(because = "allprojects")

                    void transform(TransformOutputs outputs) {
                        def input = inputArtifact.get().asFile
                        ${server.callFromBuildUsingExpression("input.name")}
                        if (input.name.startsWith("bad")) {
                            throw new RuntimeException("Transform Failure: " + input.name)
                        }

            allprojects {
                apply plugin: CustomPlugin
                apply plugin: 'java'

                configurations.runtimeClasspath.incoming.beforeResolve {
                    ${server.callFromBuildUsingExpression('project.name')}
                }
            }
            dependencies {
                implementation project('a')
                implementation project('b')
            }
        """