* 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")

    public String getTaskPath() {
        return taskPath;
    }

    public static TaskDetailsModel from(String taskPath, BuildTaskSelector.BuildSpecificSelector taskSelector, OptionReader optionReader) {
        try {
            Stream<Task> selectedTasks = taskSelector.resolveTaskName(taskPath).getTasks().stream();
            List<TaskDetails> tasks = selectedTasks.map(t -> TaskDetails.from(t, optionReader))

    }

    private void assertTaskFailureDescription(String taskSelector) {
        if (GradleContextualExecuter.configCache) {
            failureDescriptionContains("Configuration cache state could not be cached:")
            failureDescriptionContains(taskSelector)
        } else {
            def description = "Execution failed for task '${taskSelector}'."
            failure.assertHasDescription(description)
        }

import org.gradle.tooling.model.Model;
import org.gradle.tooling.model.ProjectIdentifier;
import org.gradle.tooling.model.ProjectModel;
import org.gradle.tooling.model.Task;
import org.gradle.tooling.model.TaskSelector;

/**
 * A model providing access to {@link org.gradle.tooling.model.Launchable} instances that can be used
 * to initiate Gradle build.
 *