}
                }
            """
        }
        def numWorkers = (parallelTaskCount / 2) + 2 as int

        when:
        server.expectConcurrent(numWorkers, ["parallel-task-done"] * parallelTaskCount + ["before-interrupt"] as String[])
        fails('parallelTask', '--parallel', ':interrupting', "--console=plain", "--max-workers=${numWorkers}", '--continue')

            }
        }

        task build2(type:BuildSrcTask) {
            doLast {
                ${server.callFromBuild('build2')}
            }
        }
        """

        server.expectConcurrent("build1", "build2")

        when:
        // https://github.com/gradle/gradle-private/issues/3639 warmup to avoid potential timeout.
        executer.withTasks("warmup").run()

                }
            """
            )
            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)

            }
        });
    }

    /**
     * Expects the given requests to be made concurrently. Blocks each request until they have all been received then releases them all.
     */
    public void expectConcurrent(String... expectedRequests) {
        List<ResourceExpectation> expectations = new ArrayList<>();
        for (String request : expectedRequests) {
            expectations.add(doGet(request));
        }

                doLast {
                    new URL("${getUrl('started')}\${buildNum.get()}").text
                }
            }
        """

        when:
        server.expectConcurrent("started1", "started2")
        def gradle1 = executer.withTasks("block").withArguments("--debug", "-PbuildNum=1").start()
        def gradle2 = executer.withTasks("block").withArguments("--debug", "-PbuildNum=2").start()

                    throw new RuntimeException("broken")
                }
            }
            processResources.dependsOn(broken)
        """
        server.expectConcurrent("buildA", "buildB")

        when:
        fails(buildA, "assemble")

        then:
        result.assertTaskExecuted(":broken")
        result.assertTaskExecuted(":buildB:broken")

        then:
        handle.waitForAllPendingCalls()
        assertOutputContains(gradle, "longRunning has started...")

        when:
        server.expectConcurrent('longRunningFinish', 'task2')
        handle.releaseAll()
        result = gradle.waitForFinish()

        then:
        result.groupedOutput.task(':a:longRunning').outputs.size() == 1