project.tasks.find { it.name == 'rootTask' && it.project == project }
        !project.tasks.find { it.name == 'taskA' }

        GradleProject a = project.children[0]
        a.tasks.find { it.name == 'taskA' && it.project == a }
        !a.tasks.find { it.name == 'rootTask' }

        GradleProject ab = a.children.find { it.path == ':a:b' }
        ab.tasks.find { it.name == 'taskAB'}

        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']

    def writesTasksWithDetail() {
        TaskDetails task11 = taskDetails(':task11')
        TaskDetails task12 = taskDetails(':task12')
        TaskDetails task1 = taskDetails(':task1', description: 'task1Description', dependencies: [task11, task12])
        TaskDetails task2 = taskDetails(':task2')
        TaskDetails task3 = taskDetails(':task3', dependencies: [task1])
        RuleDetails rule1 = [getDescription: {'rule1Description'}] as RuleDetails

        given:
        _ * gradle.startParameter >> startParameters
        _ * startParameters.taskRequests >> [request1, request2]

        def tasks1 = [task1, task2] as Set
        _ * selection1.tasks >> tasks1

        def tasks2 = [task3] as Set
        _ * selection2.tasks >> tasks2

        when:
        action.scheduleRequestedTasks(gradle, null, executionPlan)

        then:

        def task3 = task('task3')
        def task4 = task('task4', task2)
        def task5 = task('task5', task3, task4)

        when:
        def model = modelFor([task1, task2, task3, task4, task5])

        then:
        model.groups == ['group', ''] as Set
        def tasks = model.getTasksForGroup('') as List
        tasks*.path == [pathOf(task1), pathOf(task3), pathOf(task4), pathOf(task5)]
        def t = tasks.first()

                dependsOn('task3')
            }
            tasks.register('task3') {
                dependsOn gradle.includedBuild('theNameOfBuildA').task(':task4')
            }
        """

        when:
        execute(buildA, 'task1')

        then:
        result.assertTasksExecuted(':task4', ':buildB:task3', ':buildB:task2', ':task1')

        and:

        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

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