def 'can cancel token'() {
        when:
        def token = new DefaultBuildCancellationToken()

        then:
        !token.cancellationRequested

        when:
        token.cancel()

        then:
        token.cancellationRequested
    }

    def 'cancel notifies callbacks'() {
        def token = new DefaultBuildCancellationToken()

        def callback1 = Mock(Runnable)

        expect:
        source.token().token != null
    }

    def 'can cancel'() {
        expect:
        !source.token().cancellationRequested

        when:
        source.cancel()

        then:
        source.token().cancellationRequested
    }

    def "runs action when not cancelled"() {
        when:
        connection.run(action)

        then:
        _ * cancellationToken.cancellationRequested >> false
        _ * action.parameters >> params
        _ * params.cancellationToken >> cancellationToken
        1 * delegate.run(action)
        0 * _._
    }

        given:
        cancellationToken.cancellationRequested >>> [false, false, false, false, true]

        when:
        populateAndExecute([a, b])

        then:
        failures.empty
        executedTasks == [a, b]
    }

    def "does not fail with exception when build is cancelled and no tasks scheduled"() {
        given:
        cancellationToken.cancellationRequested >>> [true]

        when:

        and:
        operations.empty
    }

    void "fails when build has been cancelled"() {
        when:
        evaluate()

        then:
        1 * cancellationToken.cancellationRequested >> true
        0 * delegate._

        and:
        thrown(BuildCancelledException)
    }

    void "evaluates the project firing all necessary listeners and updating the state"() {
        when:

        result.getModel() == model
    }

    def "throws an exception when cancel was requested"() {
        given:
        _ * workerThreadRegistry.workerThread >> true
        _ * cancellationToken.cancellationRequested >> true
        def target = Stub(GradleProjectIdentity)

        when:
        controller.getModel(target, modelId)

        then:
        thrown(BuildCancelledException)
    }

        1 * connection.dispatch({ it instanceof Cancel })
        1 * connection.dispatch({ it instanceof CloseInput })
        1 * connection.dispatch({ it instanceof Finished })
        1 * cancellationToken.cancellationRequested >> true
        1 * cancellationToken.removeCallback(_)
        1 * connection.stop()
        0 * _
    }

    def "tries to find a different daemon if connected to a stale daemon address"() {

        1 * command1.run() >> {
            instant.running
            thread.block()
        }
        1 * command2.run() >> {
            assert notStopped
            assert !coordinator.cancellationToken.cancellationRequested
        }
        2 * onFinishCommand.run()
        0 * _._
    }

    def "idle millis is 0 if daemon is busy"() {
        given:
        Runnable command = Mock()

        when: