def impl2 = loader.create(distribution2, loggerFactory, progressListener, params, cancellationToken)

        then:
        impl == connection1
        impl2 == connection2
        1 * target.create(distribution1, loggerFactory, progressListener, params, cancellationToken) >> connection1
        1 * target.create(distribution2, loggerFactory, progressListener, params, cancellationToken) >> connection2

        Object results = connection.run(action, buildCancellationToken, providerParameters);
        return new ProviderBuildResult<>(Cast.uncheckedNonnullCast(results));
    }

    /**
     * This is used by consumers 4.4 and later
     */
    @Override
    public <T> BuildResult<T> run(InternalBuildActionVersion2<T> action, InternalCancellationToken cancellationToken, BuildParameters operationParameters)

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

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

    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;

        return runClientAction(clientAction, cancellationToken, providerParameters);
    }

    @SuppressWarnings("overloads")
    public Object run(InternalBuildActionVersion2<?> clientAction, BuildCancellationToken cancellationToken, ProviderOperationParameters providerParameters) {

        PayloadSerializer payloadSerializer
    ) {
        this.workerThreadRegistry = workerThreadRegistry;
        this.controller = controller;
        this.cancellationToken = cancellationToken;
        this.buildStateRegistry = buildStateRegistry;
        this.parameterCarrierFactory = parameterCarrierFactory;
        this.buildEventConsumer = buildEventConsumer;
        this.sideEffectExecutor = sideEffectExecutor;

            if (installedDistribution == null) {
                final DistributionInstaller installer = new DistributionInstaller(progressLoggerFactory, progressListener, clock);
                File installDir;
                try {
                    cancellationToken.addCallback(new Runnable() {
                        @Override

        0 * _
    }

    def "fails with an exception when build is cancelled and daemon is forcefully stopped"() {
        def cancellationToken = Mock(BuildCancellationToken)
        def buildRequestContext = Stub(ClientBuildRequestContext) {
            getCancellationToken() >> cancellationToken
        }

        when:
        def result = client.execute(Stub(BuildAction), Stub(BuildActionParameters), buildRequestContext)

import org.gradle.util.Path
import spock.lang.Specification

import java.util.function.Consumer
import java.util.function.Supplier

class DefaultBuildControllerTest extends Specification {
    def cancellationToken = Stub(BuildCancellationToken)
    def modelId = Stub(ModelIdentifier) {
        getName() >> 'some.model'
    }
    def modelScope = Mock(ToolingModelScope)
    def buildStateRegistry = Mock(BuildStateRegistry)

            fingerprintController: ConfigurationCacheFingerprintController,
            cancellationToken: BuildCancellationToken
        ): ProjectEvaluator {
            val evaluator = VintageModelProvider().createProjectEvaluator(buildOperationRunner, cachingServiceLocator, scriptPluginFactory, cancellationToken)
            return ConfigurationCacheAwareProjectEvaluator(evaluator, fingerprintController)
        }
    }