sftpServer.expectLstat("/")
        def sync = coordinator.expectAndBlock('sync')

        when:
        def gradle = executer.withTasks('reuseClient').withArgument("--info").start()
        sync.waitForAllPendingCalls()

        then:
        sftpServer.clearSessions()
        sftpServer.expectLstat("/")
        sleep(1000)

        when:
        sync.releaseAll()

        then:

            connection.newBuild().forTasks('test').addProgressListener({ ProgressEvent event ->
                result << event
                if (!killed) {
                    sync.waitForAllPendingCalls()
                    sync.releaseAll()
                    toolingApi.daemons.daemon.kill()
                    killed = true
                }
            }, EnumSet.of(OperationType.TEST)).run()
        }

        given:
        setupCancellationBuild()
        def sync = server.expectAndBlock('sync')

        when:
        runBuild {
            sync.waitForAllPendingCalls()
            cancellationTokenSource.cancel()
            sync.releaseAll()
        }

        then:
        assert buildResult.failure instanceof BuildCancelledException

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

        handle.waitForAllPendingCalls()

        // Complete one of the downloads and one of the local files
        handle.release("a.jar")
        handle.release(m1.artifact.path)

        // Download has completed, transforming the result. Other artifact is still downloading
        transform1.waitForAllPendingCalls()
        transform1.releaseAll()

        handle.releaseAll()

        // Gradle has detected the changes to inputFile
        def pending = server.expectAndBlock("pending")
        // Make some file system changes to inputFile
        inputFile.text = "changed"
        pending.waitForAllPendingCalls()
        pending.releaseAll()
        and:
        // command the gate keeper to open the gate and shutdown
        command.releaseAll()
        server.expect(server.get("command").send("stop"))

        def handle = server.expectConcurrentAndBlock('longRunningStart', 'task1')
        def gradle = executer.withArgument('--parallel').withTasks('longRunning', 'task2').start()

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

        when:
        server.expectConcurrent('longRunningFinish', 'task2')
        handle.releaseAll()

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

            }
        """

        when:
        def handler = server.expectConcurrentAndBlock("block", "beep")
        def gradle = executer.withTasks("block").start()

        then:
        handler.waitForAllPendingCalls()
        handler.release("beep")

        when:
        ConcurrentTestUtil.poll {
            def newOutput = gradle.standardOutput - lastOutput
            lastOutput = gradle.standardOutput

            connection.model(GradleBuild).setJvmArguments(buildJvmArguments).get()
        }
        toolingApi.daemons.daemon.assertIdle()

        def build = daemonExecutor().withTasks("slow").start()
        sync.waitForAllPendingCalls()
        toolingApi.daemons.daemon.assertBusy()

        when:
        toolingApi.close()

        then:
        toolingApi.daemons.daemon.assertBusy()

        when:
        sync.releaseAll()