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;
        }
    }

    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()
        }

    class TaskWithSources {
        String outputDir = "build/output"
        File inputFile = file('src/data/input.txt')
        String taskName = 'test'

        String getBuildScript() {
            """
                apply plugin: 'base'

                task ${taskName} {
                    def sources = file("src")
                    inputs.dir sources skipWhenEmpty()

        }
    }

    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()

                String previousTaskStatusLine = tasks.contains(taskName) ? taskStatusLines.get(tasks.lastIndexOf(taskName)) : "";
                // Don't add if our last record has a `:taskName` status, and this one is `:taskName SOMETHING`
                if (previousTaskStatusLine.equals(taskName) && !taskStatusLine.equals(taskName)) {
                    return;
                }

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

        given:
        buildFile << """
            tasks.addRule("Pattern: ping<ID>") { String taskName ->
                if (taskName.startsWith("ping")) {
                    task(taskName) {
                        doLast {
                            println "Pinging: " + (taskName - 'ping')
                        }
                    }
                }
            }
        """

        where:
        task << ['execTask', 'execProjectMethod', 'execInjectedTaskAction']
    }

    private static String injectedTaskActionTask(String taskName, String taskActionBody) {
        return """
            abstract class InjectedServiceTask_$taskName extends DefaultTask {

                @Classpath
                abstract ConfigurableFileCollection getExecClasspath()

                @Inject

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

        run taskName

        then:
        executed ":lib", ":child:jar", ":child:lib", ":$taskName"

        where:
        taskName               | _
        "direct"               | _
        "fileCollection"       | _
        "ownDependencies"      | _
        "allDependencies"      | _