public BuildCancellationTokenAdapter(BuildCancellationToken cancellationToken) {
        this.cancellationToken = cancellationToken;
    }

    @Override
    public boolean isCancellationRequested() {
        return cancellationToken.isCancellationRequested();
    }

    @Override
    public boolean addCallback(Runnable cancellationHandler) {
        return cancellationToken.addCallback(cancellationHandler);
    }

    public InternalCancellationTokenAdapter(InternalCancellationToken cancellationToken) {
        this.cancellationToken = cancellationToken;
    }

    @Override
    public boolean isCancellationRequested() {
        return cancellationToken.isCancellationRequested();
    }

    @Override
    public boolean addCallback(Runnable cancellationHandler) {
        return cancellationToken.addCallback(cancellationHandler);
    }

        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)

            cancellationArrived.countDown();
        };
        if (cancellationToken.isCancellationRequested()) {
            return;
        }
        try {
            cancellationToken.addCallback(cancellationHandler);
            notifier.run();
            changeOrCancellationArrived.await();
            while (!cancellationToken.isCancellationRequested()) {
                Instant now = nowFromMonotonicClock();

        }

        @Override
        public BuildCancellationToken getToken() {
            return token;
        }

        @Override
        public boolean isCancellationRequested() {
            return token.isCancellationRequested();
        }
    }

            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());
            }
        }
    }

        project.getOwner().ensureConfigured();
    }

    @Override
    public void configureFully(ProjectState projectState) {
        projectState.ensureConfigured();
        if (cancellationToken.isCancellationRequested()) {
            throw new BuildCancelledException();
        }
        projectState.ensureTasksDiscovered();
    }

    @Override
    public void configureHierarchy(ProjectInternal project) {

        BuildCancellationToken cancellationToken = action.getParameters().getCancellationToken();
        if (cancellationToken.isCancellationRequested()) {
            throw new BuildCancelledException("Build cancelled");
        }
        return delegate.run(action);
    }

    @Override
    public void disconnect() {
        delegate.disconnect();

 */

package org.gradle.initialization;

/**
 * Propagates notification that the build should be cancelled.
 */
public interface BuildCancellationToken {

    boolean isCancellationRequested();

    void cancel();

    /**
     * @return current state of cancellation request before callback was added.
     */
    boolean addCallback(Runnable cancellationHandler);

    /**

/**
 * 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.
     *