connection.action(new FetchTaskSelectorsBuildAction('b')).run()
        }
        TaskSelector selectorT1 = rootSelectors.taskSelectors.find { it.name == 't1' }
        TaskSelector selectorBT1 = bSelectors.taskSelectors.find { it.name == 't1' }
        TaskSelector selectorBT3 = bSelectors.taskSelectors.find { it.name == 't3' }
        def result = withBuild { BuildLauncher it ->

            if (!taskSelectors.containsKey(task.getName())) {
                LaunchableGradleTaskSelector taskSelector = new LaunchableGradleTaskSelector()
                    .setDescription(task.getDescription()).setPath(task.getPath());
                taskSelectors.put(task.getName(), taskSelector);
            } else {
                LaunchableGradleTaskSelector taskSelector = taskSelectors.get(task.getName());

        then:
        assert model.taskSelectors.find { it.name == 't1' }.description == 'T1 from root'
        assert model.taskSelectors.find { it.name == 't2' }.description == null
        assert model.taskSelectors.find { it.name == 't3' }.description == 'T3 from child'
        assert model.taskSelectors.find { it.name == 't4' }.description == 'T4 from grand child 1'
    }

        }

        then:
        buildInvocations != null
        buildInvocations.taskSelectors.find { it.name == 'alpha' }.description == 'ALPHA from root project'
        buildInvocations.taskSelectors.find { it.name == 'beta' }.description == null
        buildInvocations.taskSelectors.find { it.name == 'gamma' }.description == 'GAMMA from sub'
    }

        def invocations = withConnection {
            action(new FetchIncludedBuildInvocations()).run()
        }
        def includedTask = invocations[0].tasks[0]
        def includedSelector = invocations[0].taskSelectors[0]

        when:
        withBuild { BuildLauncher launcher ->
            launcher.forLaunchables(includedSelector)
        }

        then:
        thrown(BuildException)

        when:

            connection.getModel(BuildInvocations)
        }

        then:
        model.tasks.every { Task t -> publicTasks.contains(t.name) == t.public }
        model.taskSelectors.every { TaskSelector ts -> publicSelectors.contains(ts.name) == ts.public }
    }

 * roughly equivalent to running `gradle <task-name>` from the command-line.
 *
 * @since 1.12
 */
public interface TaskSelector extends Launchable {
    /**
     * Returns the name that will be used to select tasks.
     *
     * @return The name used by this selector.
     */
    String getName();

import org.gradle.api.specs.Spec;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.util.Path;

@ServiceScope(Scope.BuildTree.class)
public interface TaskSelector {
    Spec<Task> getFilter(SelectionContext context, ProjectState project, String taskName, boolean selectAllMatching);

    private final BuildStateRegistry buildRegistry;
    private final TaskSelector taskSelector;
    private final List<BuiltInCommand> commands;
    private final InternalProblems problemsService;

    @Inject
    public DefaultBuildTaskSelector(BuildStateRegistry buildRegistry, TaskSelector taskSelector, List<BuiltInCommand> commands, InternalProblems problemsService) {
        this.buildRegistry = buildRegistry;

    private final BuildTaskSelector taskSelector;
    private final BuildStateRegistry buildRegistry;

    public DefaultBuildTreeWorkGraphPreparer(BuildStateRegistry buildRegistry, BuildTaskSelector taskSelector) {
        this.buildRegistry = buildRegistry;
        this.taskSelector = taskSelector;
    }

    @Override