private final BuildTaskSelector taskSelector;
    private final BuildState targetBuild;

    public CommandLineTaskParser(CommandLineTaskConfigurer commandLineTaskConfigurer, BuildTaskSelector taskSelector, BuildState targetBuild) {
        this.taskConfigurer = commandLineTaskConfigurer;
        this.taskSelector = taskSelector;
        this.targetBuild = targetBuild;
    }

    private final BuildTaskSelector.BuildSpecificSelector taskSelector;

    public TaskNameResolvingBuildTaskScheduler(CommandLineTaskParser commandLineTaskParser, BuildTaskSelector.BuildSpecificSelector taskSelector) {
        this.commandLineTaskParser = commandLineTaskParser;
        this.taskSelector = taskSelector;
    }

    @Override

import java.util.function.Consumer

class DefaultBuildTaskSelectorTest extends Specification {
    def buildRegistry = Mock(BuildStateRegistry)
    def taskSelector = Mock(TaskSelector)
    def selector = new DefaultBuildTaskSelector(buildRegistry, taskSelector, [new HelpBuiltInCommand()], new DefaultProblems(new NoOpProblemEmitter(), Mock(CurrentBuildOperationRef)))
    def root = rootBuild()
    def target = root.state

 * limitations under the License.
 */

package org.gradle.integtests.tooling.r112;

import org.gradle.tooling.BuildAction;
import org.gradle.tooling.BuildController;
import org.gradle.tooling.model.TaskSelector;
import org.gradle.tooling.model.gradle.BasicGradleProject;
import org.gradle.tooling.model.gradle.BuildInvocations;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

    }

    @Provides
    protected TaskSelector createTaskSelector(ProjectConfigurer projectConfigurer, ObjectFactory objectFactory) {
        return objectFactory.newInstance(DefaultTaskSelector.class, new TaskNameResolver(), projectConfigurer);
    }

    @Provides

@ServiceScope(Scope.BuildTree.class)
public interface BuildTreeWorkController {

    /**
     * Schedules and runs requested tasks based on the provided {@code taskSelector}.
     */
    ExecutionResult<Void> scheduleAndRunRequestedTasks(@Nullable EntryTaskSelector taskSelector);

) : BuildTreeWorkController {

    override fun scheduleAndRunRequestedTasks(taskSelector: EntryTaskSelector?): ExecutionResult<Void> {
        return taskGraph.withNewWorkGraph { graph: BuildTreeWorkGraph ->
            val finalizedGraph: BuildTreeWorkGraph.FinalizedGraph = workPreparer.scheduleRequestedTasks(graph, taskSelector)
            workExecutor.execute(finalizedGraph)
        }
    }

    private val startParameter: ConfigurationCacheStartParameter,
) : BuildTreeWorkController {

    override fun scheduleAndRunRequestedTasks(taskSelector: EntryTaskSelector?): ExecutionResult<Void> {
        val scheduleTaskSelectorPostProcessing: BuildTreeWorkGraphBuilder? = taskSelector?.let { selector ->
            { rootBuildState ->
                addFinalization(rootBuildState, selector::postProcessExecutionPlan)
            }

        def excluded = Stub(Task)
        def notExcluded = Stub(Task)
        def selectionResult = Stub(TaskSelectionResult)

        when:
        def filter = selector.getFilter(new TaskSelector.SelectionContext(Path.path(":a:b"), "type"), project1, "b", false)

        then:
        1 * projectConfigurer.configure(projectModel1)
        1 * resolver.selectWithName("b", projectModel1, false) >> selectionResult

import org.gradle.tooling.internal.gradle.DefaultProjectIdentifier
import org.gradle.tooling.internal.gradle.TaskListingLaunchable
import org.gradle.tooling.internal.protocol.InternalLaunchable
import org.gradle.tooling.model.TaskSelector
import spock.lang.Specification

class ConsumerOperationParametersTest extends Specification {

    def builder = ConsumerOperationParameters.builder().setEntryPoint("entry-point")