}

    @Override
    String getProjectPath() {
        "':' + projectName"
    }

    @Override
    String dependsOnMechanism(String projectName, String taskName) {
        "'$projectName:$taskName'"
    }

    @Override
    String declareDependency(String moduleName, String moduleVersion) {
        "project(':$moduleName')"
    }

    @Override

        Set<String> excludedTaskNames = targetBuild.getMutableModel().getStartParameter().getExcludedTaskNames();
        for (String taskName : excludedTaskNames) {
            BuildTaskSelector.Filter filter = taskSelector.resolveExcludedTaskName(targetBuild, taskName);
            workGraph.addFilter(filter.getBuild(), filter.getFilter());
        }
    }

            rootProject.name = 'broken'
            include("a")
        """
        buildFile """
        """

        when:
        fails(taskName)

        then:
        failure.assertHasDescription(message)

        where:
        taskName | message
        ""       | "Cannot locate matching tasks for an empty path. The path should include a task name (for example ':help' or 'help')."

    }

    @Override
    String getProjectPath() {
        "':'"
    }

    @Override
    String dependsOnMechanism(String projectName, String taskName) {
        "gradle.includedBuild('$projectName').task(':$taskName')"
    }

    @Override
    String declareDependency(String moduleName, String moduleVersion) {
        "'myorg:$moduleName:$moduleVersion'"
    }

    @Override

    def fixture = new WorkerExecutorFixture(temporaryFolder)

    def setup() {
        fixture.prepareTaskTypeUsingWorker()
    }

    void assertWorkerExecuted(String taskName) {
        fixture.list.each {
            outputFileDir.file(taskName).file(it).assertExists()
        }
    }

    void assertSameDaemonWasUsed(String task1, String task2) {
        fixture.list.each {

        _ * project.identityPath >> (parent == null ? Path.ROOT : Path.ROOT.child(name))
        _ * project.projectPath(_) >> { taskName -> Path.ROOT.child(taskName) }
        _ * project.identityPath(_) >> { taskName -> (parent == null ? Path.ROOT : Path.ROOT.child(name)).child(taskName) }
        _ * project.gradle >> thisBuild
        _ * project.owner >> projectState
        _ * project.services >> backing.services

        buildFile << '''
            sourceSets {
                other {
                    groovy
                }
            }
            def assertTaskConfiguration(taskName, sourceSet) {
                def task = project.tasks.findByName(taskName)
                assert task instanceof CodeNarc
                task.with {
                    assert description == "Run CodeNarc analysis for ${sourceSet.name} classes"

        return buildType + operatingSystemFamilySuffix + architectureSuffix;
    }

    protected String taskPath(final String taskName) {
        if (":".equals(projectPath)) {
            return ":" + taskName;
        }

        return projectPath + ":" + taskName;
    }

    @Override
    public VersionNumber getVisualStudioVersion() {

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

    TaskSelection getSelection(SelectionContext context, ProjectState project, String taskName, boolean selectAllMatching);

    class SelectionContext {
        private final Path originalPath;
        private final String type;

            // Map to: task(args?, '<identifier>', args?)
            String taskName = arg.getText();
            call.setMethod(new ConstantExpression("task"));
            args.getExpressions().set(index, new ConstantExpression(taskName));
        }

        private void transformBinaryExpression(MethodCallExpression call, BinaryExpression expression) {