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

        when:
        def gradle = executer.withTasks('test', '--fail-fast').start()

        then:
        testExecution.waitForAllPendingCalls()

        when:
        testExecution.release('failingTest')

        then:
        gradle.waitForFailure()

        then:
        def result = new DefaultTestExecutionResult(testDirectory)

            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() {

        """

        when:
        def block = server.expectConcurrentAndBlock("lib1.jar", "lib2.jar")
        def build = executer.withTasks(":util:resolveRed").start()
        then:
        block.waitForAllPendingCalls()
        poll {
            RichConsoleStyling.assertHasWorkInProgress(build, "> Transforming lib1.jar (project :lib) with Red > Red lib1.jar")

         */
        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);
    }

        when:
        // Start the build then wait until the first configuration is resolved.
        executer.withTasks("assemble")
        def build = executer.start()
        block.waitForAllPendingCalls()

        // Change the head of the repo
        def javaFile = file('dep/src/main/java/Dep.java')
        javaFile.replace('class', 'interface')
        repo.commit('Changed Dep to an interface')

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