private final StartParameterInternal startParameter;
    private final boolean runsTasks;
    private final Supplier<HashCode> payloadHashProvider;

    public AbstractToolingModelRequirements(
        StartParameterInternal startParameter,
        boolean runsTasks,
        Supplier<HashCode> payloadHashProvider
    ) {
        this.startParameter = startParameter;
        this.runsTasks = runsTasks;

    private val cache: BuildTreeConfigurationCache,
    private val taskGraph: BuildTreeWorkGraphController,
    private val stateTransitionControllerFactory: StateTransitionControllerFactory,
    private val startParameter: StartParameter,
    private val configurationCacheStartParameter: ConfigurationCacheStartParameter,
    private val buildStateRegistry: BuildStateRegistry,
) : BuildTreeLifecycleControllerFactory {
    private

import org.gradle.api.specs.AndSpec
import spock.lang.Specification

class DefaultTaskExecutionModeResolverTest extends Specification {

    def startParameter = new StartParameter()
    def repository = new DefaultTaskExecutionModeResolver(startParameter)
    def inputs = Stub(TaskInputsInternal)
    def outputs = Stub(TaskOutputsInternal)
    def taskProperties = Mock(TaskProperties)
    def task = Stub(TaskInternal)

        where:
        unique << [true, false]
    }

    def 'can load lockfile as prefer constraints in update mode (Unique: #unique)'() {
        given:
        startParameter = Mock()
        startParameter.isWriteDependencyLocks() >> true
        startParameter.getLockedDependenciesToUpdate() >> ['org:foo']
        provider = newProvider()
        writeLockFile(['org:bar:1.3', 'org:foo:1.0'], unique)

        when:

    public File getRootDir() {
        return rootProjectDescriptor.getProjectDir();
    }

    @Override
    public StartParameter getStartParameter() {
        return startParameter;
    }

    public void setStartParameter(StartParameter startParameter) {
        this.startParameter = startParameter;
    }

    @Override
    public File getSettingsDir() {
        return settingsDir;
    }

        StartParameterInternal startParameter = new StartParameterInternal();

        List<InternalLaunchable> launchables = parameters.getLaunchables();
        if (launchables != null) {
            startParameter.setTaskRequests(unpack(launchables));
        } else if (parameters.getTasks() != null) {
            startParameter.setTaskNames(parameters.getTasks());
        }

package org.gradle.util.internal;

import org.gradle.StartParameter;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.BuildTree.class)
public class BuildCommencedTimeProvider {
    private final long fixedTime;

    public BuildCommencedTimeProvider(StartParameter startParameter) {

    @Inject
    public DefaultBuildFeatures(StartParameterInternal startParameter, BuildModelParameters buildModelParameters) {
        this.configurationCache = Lazy.atomic().of(() -> createConfigurationCache(startParameter, buildModelParameters));
        this.isolatedProjects = Lazy.atomic().of(() -> createIsolatedProjects(startParameter, buildModelParameters));
    }

    @Override

    private final StartParameterInternal startParameter;
    private final SerializedPayload action;
    private final boolean runTasks;

    public ClientProvidedBuildAction(StartParameterInternal startParameter, SerializedPayload action, boolean runTasks, BuildEventSubscriptions clientSubscriptions) {
        super(clientSubscriptions);
        this.startParameter = startParameter;
        this.action = action;

        val startParameter = StartParameterInternal().apply(configure)
        return ConfigurationCacheKey(
            ConfigurationCacheStartParameter(
                BuildLayout(
                    file("root"),
                    file("settings"),
                    null,
                    null
                ),
                startParameter,
                DefaultInternalOptions(mapOf()),