when:
        action.scheduleRequestedTasks(gradle, selector, plan)

        then:
        1 * delegate.scheduleRequestedTasks(gradle, selector, plan)
    }

    def "proceeds when no task requests specified in StartParameter"() {
        given:
        _ * startParameter.taskRequests >> []

        when:
        action.scheduleRequestedTasks(gradle, selector, plan)

        then:

        this.buildModelParameters = buildModelParameters;
    }

    @Override
    public void scheduleRequestedTasks(GradleInternal gradle, @Nullable EntryTaskSelector selector, ExecutionPlan plan) {
        gradle.getOwner().getProjects().withMutableStateOfAllProjects(() -> {
            buildTaskScheduler.scheduleRequestedTasks(gradle, selector, plan);

            if (buildModelParameters.isConfigureOnDemand() && gradle.isRootBuild()) {

        def startParameters = Mock(StartParameterInternal)

        when:
        _ * gradle.getStartParameter() >> startParameters
        _ * startParameters.getTaskRequests() >> []

        action.scheduleRequestedTasks(gradle, null, executionPlan)

        then:
        0 * executionPlan._
    }

    def "expand task parameters to tasks"() {
        def startParameters = Mock(StartParameterInternal)

        if (!maybeLoadFromCache()) {
            delegate.prepareToScheduleTasks()
        } // Else, already done
    }

    override fun scheduleRequestedTasks(selector: EntryTaskSelector?, plan: ExecutionPlan) {
        if (!maybeLoadFromCache()) {
            delegate.scheduleRequestedTasks(selector, plan)
        } // Else, already scheduled
    }

    private
    fun maybeLoadFromCache(): Boolean {

package org.gradle.execution;

import org.gradle.api.internal.GradleInternal;
import org.gradle.execution.plan.ExecutionPlan;

import javax.annotation.Nullable;

public interface BuildTaskScheduler {
    void scheduleRequestedTasks(GradleInternal gradle, @Nullable EntryTaskSelector selector, ExecutionPlan plan);

    public void prepareToScheduleTasks() {
        prepareSettings();
        prepareProjects();
    }

    @Override
    public void scheduleRequestedTasks(@Nullable EntryTaskSelector selector, ExecutionPlan plan) {
        state.inState(Stage.Configured, () -> taskExecutionPreparer.scheduleRequestedTasks(gradle, selector, plan));
    }

    private void prepareSettings() {

        this.projectConfigurer = projectConfigurer;
        this.builtInCommands = builtInCommands;
        this.delegate = delegate;
    }

    @Override
    public void scheduleRequestedTasks(GradleInternal gradle, @Nullable EntryTaskSelector selector, ExecutionPlan plan) {
        StartParameter startParameter = gradle.getStartParameter();

    /**
     * Prepares the given work graph for execution. May configure the build model and calculate the task graph from this, or may load a cached task graph if available.
     */
    BuildTreeWorkGraph.FinalizedGraph scheduleRequestedTasks(BuildTreeWorkGraph graph, @Nullable EntryTaskSelector selector);

 *
 * <p>This includes resolving the entry tasks and calculating the task graph.</p>
 */
public interface TaskExecutionPreparer {
    void scheduleRequestedTasks(GradleInternal gradle, @Nullable EntryTaskSelector selector, ExecutionPlan plan);

        return taskGraph.withNewWorkGraph { graph: BuildTreeWorkGraph ->
            val finalizedGraph: BuildTreeWorkGraph.FinalizedGraph = workPreparer.scheduleRequestedTasks(graph, taskSelector)
            workExecutor.execute(finalizedGraph)
        }
    }