taskX
taskY

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':taskX'.
> java.lang.RuntimeException (no error message)

* Try:
> Run with --stacktrace option to get the stack trace.
> Run with --info or --debug option to get more log output.
> Run with --scan to get full insights.
> Get more help at https://help.gradle.org.

    doLast {
        println("Hello world!")
    }
}
----

Once the task is assigned to a group, it will be listed by `./gradlew tasks`:

[source]
----
$ ./gradlew tasks

> Task :tasks

Custom tasks
------------------
hello - A lovely greeting task.
----

To view information about a task, use the `help --task <task-name>` command:

[source]

        def task2 = taskDetails('a:task_A')
        def task3 = taskDetails('a:a:task_A')
        def task4 = taskDetails('B:task_A')
        def task5 = taskDetails('c:task_A')
        def task6 = taskDetails('b:task_a')
        def task7 = taskDetails('a:task_Abc')
        def task8 = taskDetails('task_b')
        _ * target.groups >> ['group']

        dependsOn(task2, [task3])
        dependsOn(task3, [task4])
        dependsOn(transform1, [task4])

        when:
        collector.collectNodes([task1, task2, task3, task4, transform1])
        def graph = collector.getGraph()
        def nodes = graph.getNodes(PlannedNodeGraph.DetailLevel.LEVEL1_TASKS) as List<TestPlannedNode>
        then:
        nodes.size() == 4

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

Group tasks
-----------
:task1 - task1Description
:task2
:task3

Rules
-----
rule1Description
rule2Description
'''
    }

    def writesTasksForSingleGroup() {
        TaskDetails task = taskDetails(':task1')

        when:
        renderer.addDefaultTasks([])
        renderer.startTaskGroup('group')
        renderer.addTask(task)

        TaskDetails task3 = taskDetails(':sub:task')
        _ * task1.findTask(_) >> Mock(Task)
        _ * task2.findTask(_) >> Mock(Task)
        _ * task3.findTask(_) >> Mock(Task)

        TaskReportModel project1 = Mock()
        TaskReportModel project2 = Mock()
        _ * project1.groups >> (['group'] as LinkedHashSet)
        _ * project1.getTasksForGroup('group') >> ([task1, task2] as Set)

            tasks.register("task2", SomeTask) {
                println "Configure ${path}"
            }
            tasks.register("task3", SomeTask)
        '''

        when:
        run("task1")

        then:
        outputContains("Create :task1")
        outputContains("Configure :task1")
        result.assertNotOutput(":task2")
        result.assertNotOutput(":task3")

        when:
        run("task2")

        1 * tasks.names >> (['task1', 'task2'] as SortedSet)
        0 * tasks._

        when:
        def matches = asTasks(result['task1'])

        then:
        matches == [task1]

        and:
        1 * tasks.getByName('task1') >> task1
        0 * tasks._
    }

    def "lazily locates all tasks for multiple projects"() {
        given:
        def task1 = task('task1')

        def task1 = Stub(Task)
        def task2 = Stub(Task)
        def task3 = Stub(Task)
        def source1 = Stub(FileCollectionInternal)
        def source2 = Stub(FileCollectionInternal)

        given:
        source1.visitDependencies(_) >> { TaskDependencyResolveContext context ->
            context.add(task1)
            context.add(task2)
        }