file("a/build.gradle") << """
            tasks.register("taskA")
            tasks.register("taskB") {
                dependsOn 'taskA'
            }
            tasks.register("taskC") {
                dependsOn 'taskB'
            }
            tasks.register("taskD")
        """
        file("b/build.gradle") << """
            tasks.register("taskA")
        """
        file("c/build.gradle") << """

    def "provides tasks of a project"() {
        file('build.gradle') << '''
task a {
   description = 'this is task a'
}
task b
task c
'''

        when:
        GradleProject project = withConnection { it.getModel(GradleProject.class) }

        then:
        GradleTask taskA = project.tasks.find { it.name == 'a' }
        taskA.path == ':a'
        taskA.description == 'this is task a'

        then:
        project.tasks*.name.toSet() == (["a", "b", "c"] + rootProjectImplicitTasksForGradleProjectModel).toSet()
        def taskA = project.tasks.find { it.name == 'a' }
        taskA != null
        taskA.path == ':a'
        taskA.description == 'this is task a'
        taskA.project == project
    }

    def "can execute a build for a project"() {

        file('build.gradle') << '''
task a
task b { description = 'this is task b' }
'''

        when:
        GradleProject project = withConnection { connection -> connection.getModel(GradleProject.class) }

        then:
        def taskA = project.tasks.find { it.name == 'a' }
        taskA != null
        taskA.path == ':a'
        taskA.displayName == /task ':a'/
        taskA.description == null

        buildFile << """
            def taskA = tasks.create("a", FileProducer) {
                // no output value
            }
            def taskB = tasks.create("b", FileProducer) {
                // no output value
            }
            tasks.register("c") {
                dependsOn taskA.output.orElse(taskB.output)
            }
        """

        when:
        run("c")

        then:

                        project.getTasks().register("b", TaskB.class, task -> task.doLast(b -> actionB.execute((TaskB) b)));
                    }
                }
            """
        }
        buildFile << """
            apply plugin: my.LambdaPlugin
        """

        when:
        configurationCacheRun("a", "b")
        configurationCacheRun("a", "b")

            rootProject.name = 'root'
            include 'a'
        """
        file("a/build.gradle") << """
            task taskA {}
            task taskB {
                dependsOn 'taskA'
            }
            task taskC {
                dependsOn 'taskB'
            }
        """
    }

            }

            task taskB {
                def output = file("build/task-b/output.txt")
                inputs.file input
                outputs.file output
                outputs.cacheIf { true }
                doFirst action
            }
        """

        when:
        withBuildCache().run "taskA", "taskB"
        then:
        executedAndNotSkipped(":taskA")
        skipped(":taskB")
    }

So if you only run `taskY` with `mustRunAfter`, you won't cause `taskX` to run.
This is expressed as `taskY.mustRunAfter(taskX)`.

====
include::sample[dir="snippets/tasks/mustRunAfter/kotlin",files="build.gradle.kts[]"]
include::sample[dir="snippets/tasks/mustRunAfter/groovy",files="build.gradle[]"]

----
$ gradle -q taskY taskX

                        println "Task '\$name' file '\${file.name}' with '\${file.text}'"
                    }
                }
            }

            task a(type: TaskA) {
                outputFile = file("output.txt")
            }

            task b(type: TaskB) {
                inputFiles = tasks.a.outputs.files
            }