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:

        then:
        0 * executionPlan._
    }

    def "expand task parameters to tasks"() {
        def startParameters = Mock(StartParameterInternal)
        TaskExecutionRequest request1 = Stub(TaskExecutionRequest)
        TaskExecutionRequest request2 = Stub(TaskExecutionRequest)
        def task1 = Stub(Task)
        def task2 = Stub(Task)
        def task3 = Stub(Task)
        def selection1 = Stub(TaskSelection)

repeat(4) { counter ->
    tasks.register("task$counter") {
        doLast {
            println("I'm task number $counter")
        }
    }
}

4.times { counter ->
    tasks.register("task$counter") {
        doLast {
            println "I'm task number $counter"
        }
    }
}

        then:
        def task = project.tasks.target1
        task instanceof AntTarget
        task.target.name == 'target1'

        and:
        def task2 = project.tasks.target2
        task2 instanceof AntTarget
        task2.target.name == 'target2'

        and:
        def task3 = project.tasks.target3
        task3 instanceof AntTarget
        task3.target.name == 'target3'
    }

import org.gradle.api.Task

public class DefaultPublishArtifactTest extends AbstractPublishArtifactTest {

    def "init"() {
        given:
        def task1 = Mock(Task)
        def task2 = Mock(Task)

        when:
        def publishArtifact = new DefaultPublishArtifact(testName, testExt, testType,
                testClassifier, date, testFile, task1, task2)
        then:

    }

    void assertSameDaemonWasUsed(String task1, String task2) {
        fixture.list.each {
            assert outputFileDir.file(task1).file(it).text == outputFileDir.file(task2).file(it).text
        }
    }

    void assertDifferentDaemonsWereUsed(String task1, String task2) {
        fixture.list.each {
            assert outputFileDir.file(task1).file(it).text != outputFileDir.file(task2).file(it).text
        }
    }

def taskX = tasks.register('taskX') {
    doLast {
        println 'taskX'
    }
}
def taskY = tasks.register('taskY') {
    doLast {
        println 'taskY'
    }
}
def taskZ = tasks.register('taskZ') {
    doLast {
        println 'taskZ'
    }
}
taskX.configure { dependsOn(taskY) }
taskY.configure { dependsOn(taskZ) }

val taskX by tasks.registering {
    doLast {
        println("taskX")
    }
}
val taskY by tasks.registering {
    doLast {
        println("taskY")
    }
}
val taskZ by tasks.registering {
    doLast {
        println("taskZ")
    }
}
taskX { dependsOn(taskY) }
taskY { dependsOn(taskZ) }

tasks.register("task1"){
    println("REGISTER TASK1: This is executed during the configuration phase")
}

tasks.register("task2"){
    println("REGISTER TASK2: This is executed during the configuration phase")
}

tasks.named("task1"){
    println("NAMED TASK1: This is executed during the configuration phase")
    doFirst {