public class TaskPathProjectEvaluator implements ProjectConfigurer {
    private final BuildCancellationToken cancellationToken;

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

    @Override
    public void configure(ProjectInternal project) {
        project.getOwner().ensureConfigured();
    }

    private final BuildCancellationToken cancellationToken;

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

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

    @Override

                    }
                });
                listeners.add(listener);
            }
        }

        public void setCancellationToken(CancellationToken cancellationToken) {
            this.cancellationToken = cancellationToken;
        }

        public void setStreamedValueListener(StreamedValueListener streamedValueListener) {
            this.streamedValueListener = streamedValueListener;

        _ * params.cancellationToken >> cancellationToken
        1 * delegate.run(action)
        0 * _._
    }

    def doesNotInvokeActionRunWhenCancellationRequested() {
        when:
        connection.run(action)

        then:
        _ * cancellationToken.cancellationRequested >> true
        _ * action.parameters >> params
        _ * params.cancellationToken >> cancellationToken
        0 * _._

        and:

        ClassPath classpath = distribution.getToolingImplementationClasspath(progressLoggerFactory, progressListener, connectionParameters, cancellationToken);

        try {
            return connections.get(classpath, new ConsumerConnectionCreator(distribution, progressLoggerFactory, progressListener, connectionParameters, cancellationToken));
        } catch (ExecutionException e) {

                waitForDeployments(action, requestMetaData, buildSession, cancellationToken, cancellableOperationManager);
            }
        }
    }

    private CancellableOperationManager createCancellableOperationManager(BuildRequestMetaData requestContext, BuildCancellationToken cancellationToken) {

    def params = Mock(ConnectionParameters)
    def cancellationToken = Mock(BuildCancellationToken)
    def target = Mock(ToolingImplementationLoader)
    def loader = new SynchronizedToolingImplementationLoader(target)

    def "blocks and reports progress when busy"() {
        when:
        start {
            loader.create(distro, factory, _ as InternalBuildProgressListener, params, cancellationToken)
        }
        async {

    private final BuildCancellationToken cancellationToken;

    public DefaultCancellableOperationManager(ExecutorService executorService, DisconnectableInputStream input, BuildCancellationToken cancellationToken) {
        this.executorService = executorService;
        this.input = input;
        this.cancellationToken = cancellationToken;
    }

    @Override

    private final BuildCancellationToken cancellationToken;

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

    @Override
    public void monitorInput(Action<? super BuildCancellationToken> operation) {
        operation.execute(cancellationToken);
    }

    @Override
    public void closeInput() {

    private final boolean interactive;
    private final BuildCancellationToken cancellationToken;
    private final BuildEventConsumer eventConsumer;

    public ClientBuildRequestContext(
        GradleLauncherMetaData client,
        long startTime,
        boolean interactive,
        BuildCancellationToken cancellationToken,
        BuildEventConsumer eventConsumer
    ) {
        this.client = client;