val isCi = providers.systemProperty("ci")
            if ($expression) {
                tasks.register("run") {
                    doLast { println("ON CI") }
                }
            } else {
                tasks.register("run") {
                    doLast { println("NOT CI") }
                }
            }
        """

        when:
        configurationCacheRun "run"

        then:

            abstract class ResolveTask extends DefaultTask {
                @InputFiles
                abstract ConfigurableFileCollection getMyInputs()

                @TaskAction
                void doTask() {
                    /**
                     * If additionalRuntimeClasspath in producer is consumable, it will
                     * be selected instead of runtimeElements.  This ensures it does not

                outputs.dir(outputDir)
                doLast {
                    new File(outputDir, "source").text = "fixed"
                }
            }

            task secondTask {
                def inputDir = file("${outputDir}")
                def outputDir = file("${sourceDir}")
                inputs.dir(inputDir)
                outputs.dir(outputDir)
                doLast {

                inputs.property('p', project).optional(true)
                doLast { t -> t.project }
            }
            // Should be reported
            tasks.register('broken') {
                inputs.property('p', project).optional(true)
                doLast { t -> t.project }
            }
            tasks.register('ok') {
                doLast { }
            }
        """

        "doFirst({})"                                               | "Task.doFirst(Closure)"
        "doLast(anAction)"                                          | "Task.doLast(Action)"
        "doLast({})"                                                | "Task.doLast(Closure)"
        "actions.add(anAction)"                                     | "Task.getActions().add()"

    }

    @TargetGradleVersion(">=6.5")
    def "disconnect during build stops daemon"() {
        setup:
        buildFile.text = """
            task hang {
                doLast {
                    ${server.callFromBuild("waiting")}
                }
            }
        """.stripIndent()

        def sync = server.expectAndBlock("waiting")

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

    }
    doLast {
        println("NAMED TASK1 - doLast: This is executed during the execution phase")
    }
}

tasks.named("task2"){
    println("NAMED TASK2: This is executed during the configuration phase")
    doFirst {
        println("NAMED TASK2 - doFirst: This is executed during the execution phase")
    }
    doLast {

        buildFile << """
            task foo {
                inputs.property "a", "hello"
                inputs.property "b", new Foo()
                outputs.file "foo.txt"
                doLast { file("foo.txt") << "" }
            }

            class Foo {
                int x
                String toString() { "xxx" }
            }
        """

        when:
        fails "foo"