func UserTasksHandlerFunc(t *parsedTrace) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		tasks := t.summary.Tasks

		// Summarize groups of tasks with the same name.
		summary := make(map[string]taskStats)
		for _, task := range tasks {
			stats, ok := summary[task.Name]
			if !ok {
				stats.Type = task.Name
			}
			stats.add(task)

            @Override
            public int compare(TaskDetails task1, TaskDetails task2) {
                int diff = STRING_COMPARATOR.compare(task1.getPath().getName(), task2.getPath().getName());
                if (diff != 0) {
                    return diff;
                }
                Path parent1 = task1.getPath().getParent();
                Path parent2 = task2.getPath().getParent();

import javax.annotation.Nullable;

/**
 * Represents a task which is executable by Gradle.
 *
 * <p>Note: {@code Task} extends {@code Launchable} since 1.12.</p>
 *
 * @since 1.0-milestone-3
 */
public interface Task extends Launchable {
    /**
     * Returns the path of this task. This is a fully qualified unique name for this task.
     *
     * @return The path of this task.
     * @since 1.0-milestone-3
     */

        when:
        def deps = publishArtifact.buildDependencies

        then:
        deps.getDependencies(null) == [task1, task2] as Set
    }

    def "create artifact from buildable Directory provider"() {
        def task1 = Stub(Task)
        def task2 = Stub(Task)
        def provider = Mock(ProviderInternal)
        def value = Mock(Directory)
        def file1 = new File("classes-1.dir")

            rootProject.name = 'root'
            include 'a'
        """
        file("a/build.gradle") << """
            task taskA {}
            task taskB {
                dependsOn 'taskA'
            }
            task taskC {
                dependsOn '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

            return null
        }
        1 * handler.onComplete(null)
        0 * asyncConnection._
        0 * handler._
    }

    def "can configure the operation"() {
        Task task1 = task(':task1')
        Task task2 = task(':task2')
        ResultHandlerVersion1<Void> adaptedHandler
        ResultHandler<Void> handler = Mock()
        OutputStream stdout = Stub()
        OutputStream stderr = Stub()

        when:

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Task)) {
            return false;
        }
        Task task = (Task) o;
        return Objects.equals(getClass(), task.getClass()) && Objects.equals(value, task.value);
    }

    @Override
    public int hashCode() {
        return Objects.hash(getClass(), value);
    }

    @Override

 * decide not to by returning -1L.
 *
 * Task Queues
 * -----------
 *
 * Tasks are bound to the [TaskQueue] they are scheduled in. Each queue is sequential and the tasks
 * within it never execute concurrently. It is an error to use a task in multiple queues.
 */
abstract class Task(
  val name: String,
  val cancelable: Boolean = true,
) {
  // Guarded by the TaskRunner.
  internal var queue: TaskQueue? = null

            </thead>
            <tr>
                <td>dir</td>
            </tr>
            <tr>
                <td>buildFile</td>
            </tr>
            <tr>
                <td>tasks</td>
            </tr>
            <tr>
                <td>startParameter</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>