}
        """
        blockingHttpServer.expectConcurrent("taskAction1")
        blockingHttpServer.expectConcurrent("taskAction2")
        blockingHttpServer.expectConcurrent("taskAction3")
        blockingHttpServer.expectConcurrent("taskAction4")
        blockingHttpServer.expectConcurrent("taskAction5")
        blockingHttpServer.expectConcurrent("taskAction6")

        expect:
        args("--max-workers=3")

        expect:
        blockingServer.expectConcurrent(":a:aSerialPing")
        blockingServer.expectConcurrent(":b:aPing", ":b:bPing")
        run ":a:aSerialPing", ":b:aPing", ":b:bPing"

        // when configuration is loaded from configuration cache, all tasks are executed in parallel
        if (GradleContextualExecuter.configCache) {
            blockingServer.expectConcurrent(":a:aSerialPing", ":b:aPing", ":b:bPing")

                    assert artifacts.artifactFiles.collect { it.name } == ['test-1.3.jar.txt', 'test2-2.3.jar.txt', 'test3-3.3.jar.txt']
                }
            }
        """

        server.expectConcurrent("test-1.3.jar", "test2-2.3.jar", "test3-3.3.jar")

        when:
        succeeds ":resolve"

        then:
        outputContains("Transforming test-1.3.jar to test-1.3.jar.txt")

        server.expect("configure-a")
        server.expect("configure-b")
        run()

        given:
        server.expect("configure-root")
        server.expectConcurrent("model-root", "configure-a", "configure-b")
        server.expectConcurrent("model-a", "model-b")

        when:
        executer.withArguments(ENABLE_CLI)
        def model = runBuildAction(new FetchCustomModelForEachProjectInParallel())

    }

    def "succeeds when expected concurrent requests are made"() {
        given:
        server.expectConcurrent("a", "b", "c")
        server.start()

        when:
        async {
            start { succeeds("a") }
            start { succeeds("b") }
            start { succeeds("c") }
        }

            }
"""

        given:
        blockingServer.expectConcurrent(
            blockingServer.get(m1.pom.path).sendFile(m1.pom.file),
            blockingServer.get(m2.pom.path).sendFile(m2.pom.file),
            blockingServer.get(m3.pom.path).sendFile(m3.pom.file),
            blockingServer.get(m4.pom.path).sendFile(m4.pom.file))
        blockingServer.expectConcurrent(

                }
            """
            )
            withPrecompiledKotlinScript("some.gradle.kts", """plugins { id("applied-output") }""")

            server.expectConcurrent("blockStart", "unblockStart")
            server.expectConcurrent("blockStop", "unblockStop")

            build(":concurrentTask", ":compileKotlin").apply {

            task log { }
        """

        def runs = GradleContextualExecuter.isConfigCache() ? 2 : 1
        runs.times {
            barrier.expectConcurrent("child-build-started", "1-started", "2-started")
            barrier.expectConcurrent("child-build-finished", "1-finished", "2-finished")
        }

        when:
        runs.times {
            executer.withArgument("--parallel")

            }

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

        when:
        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection ->

        def generate = rootBuild.task('generate').dependsOn(generateBar).dependsOn(generateFoo)

        server.start()

        writeAllFiles()

        expect:
        2.times {
            server.expectConcurrent(cleanFoo.path, cleanBarLocal.path)

            args '--parallel', '--max-workers=2'
            succeeds(clean.path, cleanBarLocal.path, generate.path)