then:
        result.failures.empty

        1 * workerLeaseService.currentWorkerLease >> workerLease

        then:
        1 * cancellationHandler.isCancellationRequested() >> false
        1 * workerLease.tryLock() >> true
        1 * workSource.executionState() >> WorkSource.State.MaybeWorkReadyToStart
        1 * workSource.selectNext() >> WorkSource.Selection.of(node)

            cancellationToken.addCallback(interrupt);
            return delegate.execute(work, context);
        } finally {
            cancellationToken.removeCallback(interrupt);
            if (cancellationToken.isCancellationRequested()) {
                Thread.interrupted();
                throw new BuildCancelledException("Build cancelled while executing " + work.getDisplayName());
            }
        }
    }

/**
 * Cancellation token passed from consumer to provider to propagate cancellation events.
 * @since 2.1-rc-1
 */
public interface InternalCancellationToken {
    boolean isCancellationRequested();

    /**
     * Adds a callback that will be executed when cancel event is triggered.
     * It can be run synchronously if the token is already cancelled.
     *

                        if (!operationToken.isCancellationRequested()) {
                            fileEventCollector.reportChanges(logger);
                        }
                    });
                }
            } finally {
                fileChangeListeners.removeListener(fileEventCollector);
            }

            if (cancellationToken.isCancellationRequested()) {
                break;
            } else {

        throws BuildExceptionVersion1, InternalUnsupportedModelException {
        assertCanQuery();
        if (cancellationToken.isCancellationRequested()) {
            throw new BuildCancelledException(String.format("Could not build '%s' model. Build cancelled.", modelIdentifier.getName()));
        }

                } else {
                    return BuildActionResult.of(payloadSerializer.serialize(result.getClientResult()));
                }
            }
            if (requestContext.getCancellationToken().isCancellationRequested()) {
                return BuildActionResult.cancelled(payloadSerializer.serialize(result.getBuildFailure()));
            }

    }

    @Override
    public void evaluate(final ProjectInternal project, final ProjectStateInternal state) {
        if (state.isUnconfigured()) {
            if (cancellationToken.isCancellationRequested()) {
                throw new BuildCancelledException();
            }
            buildOperationRunner.run(new EvaluateProject(project, state));
        }
    }

        }

        if (result instanceof Failure) {
            Throwable failure = ((Failure) result).getValue();
            if (failure instanceof DaemonStoppedException && cancellationToken.isCancellationRequested()) {
                return BuildActionResult.cancelled(new BuildCancelledException("Daemon was stopped to handle build cancel request.", failure));
            }

                selected = MutableReference.empty();
                coordinationService.withStateLock(resourceLockState -> {
                    stats.finishWaitingForNextItem();
                    if (cancellationToken.isCancellationRequested()) {
                        queue.cancelExecution();
                    }

                    WorkSource.State state = queue.executionState();