}

    def "BuildInvocations model is accepted"() {
        given:
        def builder = new BuildInvocationsBuilder(new DefaultProjectTaskLister())

        when:
        def canBuild = builder.canBuild(BuildInvocations.name)

        then:
        canBuild
    }

    @Unroll("tasks and selectors for #startProject")

          }
        '''

        when:
        def buildInvocations = withConnection { ProjectConnection connection ->
            connection.getModel(BuildInvocations.class)
        }

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

        then:
        gradleBuild.projects*.projectIdentifier.toSet().size() == 3
    }

    def "Applies BuildInvocations compatibility mapping"() {
        when:
        def buildInvocations = withConnection {
            action(new FetchBuildInvocations()).run()
        }
        then:
        buildInvocations
    }

        def publicSelectors = rootProjectImplicitSelectors - rootProjectImplicitInvisibleSelectors + ['t1', 't2']

        when:
        BuildInvocations model = withConnection { connection ->
            connection.getModel(BuildInvocations)
        }

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

    def "provide getGroup on Task using BuildInvocations shouldn't fail if group is null"() {
        file("build.gradle") << '''
task test1()
task test2()
'''

        when:
        def buildInvocations = withConnection { ProjectConnection connection ->
            connection.getModel(BuildInvocations)
        }

        then:
        buildInvocations != null

        then:
        result.result.assertTasksExecuted(':b:c:t1')
    }

    def "can run build using task selectors from connection"() {
        when:
        BuildInvocations model = withConnection { connection ->
            connection.getModel(BuildInvocations)
        }
        TaskSelector selector = model.taskSelectors.find { TaskSelector it ->
            it.name == 't1'
        }

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

public class FetchBuildInvocations implements BuildAction<BuildInvocations> {

    @Override
    public BuildInvocations execute(BuildController controller) {
        return controller.getModel(BuildInvocations.class);
    }

import org.gradle.tooling.model.gradle.BuildInvocations;
import org.gradle.tooling.model.gradle.GradleBuild;

import java.util.ArrayList;
import java.util.List;

public class FetchIncludedBuildInvocations implements BuildAction<List<BuildInvocations>> {

    @Override
    public List<BuildInvocations> execute(BuildController controller) {
        List<BuildInvocations> invocations = new ArrayList<BuildInvocations>();

        singleProjectBuildInSubfolder("includedBuild")

        when:
        withConnection(toolingApi.connector().forProjectDirectory(projectDir.file('sub1')).searchUpwards(true)) {
            BuildInvocations invocations = getModel(BuildInvocations)
            def task = invocations.tasks.find { it.name.contains 'tasks' }
            def selector = invocations.taskSelectors.find { it.name.contains 'tasks' }

        Map<String, Set<String>> model = new HashMap<String, Set<String>>();
        for (BasicGradleProject project: controller.getBuildModel().getProjects()) {
            BuildInvocations entryPointsForProject = controller.getModel(project, BuildInvocations.class);
            Set<String> selectorNames = new HashSet<String>();
            for (TaskSelector selector : entryPointsForProject.getTaskSelectors()) {