tasks.register('hello') {
    doLast {
        println 'Hello Earth'
    }
}
tasks.named('hello') {
    doFirst {
        println 'Hello Venus'
    }
}
tasks.named('hello') {
    doLast {
        println 'Hello Mars'
    }
}
tasks.named('hello') {
    doLast {
        println 'Hello Jupiter'
    }

        task.descendant('Execute doLast {} action for :custom')
    }

    @TargetGradleVersion(">=4.10.3")
    def "task actions defined in doFirst and doLast blocks of Kotlin build scripts have informative names"() {
        given:
        buildFileKts << """
            tasks { create("custom") {
                doFirst {}
                doLast {}
            }}
        """

        when:

tasks.register("compile") {
    doLast {
        println("compiling source")
    }
}
tasks.register("testCompile") {
    dependsOn("compile")
    doLast {
        println("compiling test source")
    }
}
tasks.register("test") {
    dependsOn("compile", "testCompile")
    doLast {
        println("running unit tests")
    }
}
tasks.register("build") {
    dependsOn("test")

file("src/file1.txt").mkdirs()
file("src2").mkdirs()
file("src2/dir1").mkdirs()
file("src2/dir2").mkdirs()

// tag::closure[]
tasks.register("list") {
    val projectDirectory = layout.projectDirectory
    doLast {
        var srcDir: File? = null

        val collection = projectDirectory.files({
            srcDir?.listFiles()
        })

        srcDir = projectDirectory.file("src").asFile

class BuildSrcTaskExecutionIntegrationTest extends AbstractIntegrationSpec {
    def "can execute a task from buildSrc from the command line"() {
        file("buildSrc/build.gradle") << """
            task something {
                doLast { }
            }
        """

        expect:
        2.times {
            run(":buildSrc:something")
            result.assertTaskExecuted(":buildSrc:something")
        }

        run(":buildSrc:jar")

        """
    }

    def 'JUL logger.isLoggable corresponds to gradle log level for --debug'() {
        given:
        buildFile << """
            task isLoggable() {
                doLast {
                    def logger = Logger.getLogger('some-logger')

                    assert logger.isLoggable(Level.SEVERE)
                    assert logger.isLoggable(Level.WARNING)

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

        given:
        buildFile << """
            task graph {
                def root = configurations.compile.incoming.resolutionResult.rootComponent
                doLast {
                    root.get()
                }
            }
"""

        when:
        module.pom.expectGet()
        module2.pom.expectGet()

        then:
        succeeds("graph")
    }

}
task a {
    def files = configurations.a
    doLast {
        files.files
    }
}
task b {
    def files = configurations.b
    doLast {
        files.files
    }
}
task block1 {
    doLast {
        ${blockingServer.callFromBuild("block1")}
    }
}
block1.mustRunAfter a
b.mustRunAfter block1

task block2 {
    doLast {
        ${blockingServer.callFromBuild("block2")}
    }
}

    def "logs info message for exact match"() {
        setup:
        buildFile << """
            tasks.register("sanityCheck") {
                doLast { }
            }
            tasks.register("safetyCheck") {
                doLast { }
            }
        """

        when:
        run("sanityCheck", "--info")

        then:
        outputContains("Task name matched 'sanityCheck'")