"""
        def handler = blockingHttpServer.expectAndBlock("between")

        when:
        def gradle = executer.withTasks("compileJava").start()

        then:
        handler.waitForAllPendingCalls()

        and:
        pidFile('other').exists()
        def pid1 = pidFile('other').text.strip() as long
        kill(pid1)

        when:
        handler.releaseAll()

}
"""
        executer.requireOwnGradleUserHomeDir().requireIsolatedDaemons()

        expect:
        def build = executer.withArguments('query:query', ':resolve:resolve', '--parallel').start()

        handler.waitForAllPendingCalls()
        handler.release('/sync')
        Thread.sleep(1000)
        handler.release(module.pom.path)

        build.waitForFinish()
    }

    @Issue('https://github.com/gradle/gradle/issues/11247')

        // Wait for all extracters to be ready
        waiting.waitForAllPendingCalls()

        def firstExtracter = server.expectAndBlock("extract")
        // release the extracters so they start trying to extract concurrently
        waiting.releaseAll()
        // wait for the first extracter to start extracting
        firstExtracter.waitForAllPendingCalls()

        def block = server.expectAndBlock("waiting")
        def build = executer.withTasks("doWork").start()
        block.waitForAllPendingCalls()

        // simulate another "build" that tries to initialize the cache as well before recognizing that it has been done already

            collectOutputs(builder)
            builder.setStreamedValueListener(listener)
            builder.run(handler)

            modelReceived.await()
            request.waitForAllPendingCalls()
            request.releaseAll()
            finished.await()
        }

        then:
        models.size() == 2
        models[0] instanceof GradleProject

        def handle = withWatchFs().executer.withTasks(task).start()
        def userInput = server.expectAndBlock(expectedCall)
        userInput.waitForAllPendingCalls()
        action()
        userInput.releaseAll()
        result = handle.waitForFinish()
    }

    int getProjectFilesInVfs() {

         */
        void waitForAllPendingCalls();

        /**
         * Waits for the expected number of concurrent requests to be received or until the given {@link FailureTracker} provides a
         * failure captured during execution which should be reported without waiting further.
         */
        void waitForAllPendingCalls(FailureTracker failureTracker);
    }

            }
        """)
        def handle = server.expectAndBlock("running")

        when:
        def longRunning = executer.withTasks("someLongRunningTask").start()
        handle.waitForAllPendingCalls()

        then:
        def before
        ConcurrentTestUtil.poll {
            // Output is delivered asynchronously, so wait until the details are available

        cleaningBarrier.waitForAllPendingCalls()

        when: 'transforming build is started'
        def transformBarrier = blockingHttpServer.expectAndBlock("transform")
        def transformingBuild = executer.withTasks("waitForTransformBarrier").start()

        then: 'transforming build starts artifact transform'
        transformBarrier.waitForAllPendingCalls()
        def cachedTransform = null