private final String taskName;

        public TaskPathSpec(ProjectInternal targetProject, String taskName) {
            this.targetProject = targetProject;
            this.taskName = taskName;
        }

        @Override
        public boolean isSatisfiedBy(Task element) {
            if (!element.getName().equals(taskName)) {
                return true;
            }

        final boolean includeSubprojects;
        final String taskName;

        public ProjectResolutionResult(BuildState build, ProjectState project, boolean includeSubprojects, String taskName) {
            this.build = build;
            this.project = project;
            this.includeSubprojects = includeSubprojects;
            this.taskName = taskName;
        }
    }

            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')."

    def "generates build phase events for task #taskName and expects #expectedReportedTasksCount run tasks"() {
        setupProject()

        when:
        def events = ProgressEvents.create()
        withConnection {
            it.newBuild().forTasks(taskName)
                .addProgressListener(events, OperationType.BUILD_PHASE)
                .run()
        }

        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"

        }
    }

    private void executeTaskViaGradleProjectLaunchable(String taskName) {
        withConnection { connection ->
            def gradleProjects = connection.action(new LoadCompositeModel(GradleProject)).run()
            def launchables = findLaunchables(gradleProjects, taskName)
            assert launchables.size == 1
            def build = connection.newBuild()

        withDebugFrame({ task.path }) {
            val taskType = GeneratedSubclasses.unpackType(task)
            val projectPath = task.project.path
            val taskName = task.name
            writeClass(taskType)
            writeString(projectPath)
            writeString(taskName)
            writeLong(task.taskIdentity.uniqueId)
            writeNullableString(task.reasonTaskIsIncompatibleWithConfigurationCache.orElse(null))

        ReferenceType.SELF_REF ->
            isolate.owner.delegate as Task

        ReferenceType.TASK_REF -> {
            val taskName = readString()
            isolate.owner.service(TaskContainerInternal::class.java).resolveTask(taskName)
        }

        ReferenceType.PROHIBITED -> {
            logUnsupported(
                "deserialize",
                Task::class,

        def pluginBuilder = new PluginBuilder(testDirectory.file("plugin-" + version))

        def taskName = "pluginTask"

        pluginBuilder.addPluginWithPrintlnTask(taskName, message, "org.example.plugin")
        pluginBuilder.publishAs("org.example.plugin:plugin:${version}", mavenRepo, executer)
    }

        buildFile << """
            tasks.addRule("create some tasks") { taskName ->
                if (taskName == "bar") {
                    tasks.register("bar")
                } else if (taskName == "baz") {
                    tasks.create("baz")
                } else if (taskName == "notByRule") {
                    tasks.register("notByRule") {