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:

                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 { }
            }
        """

    }

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

        def sync = server.expectAndBlock("waiting")

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

        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"

    def setup() {
        file("build.gradle") << """
    task hello {
        doLast {
            println 'hello'
        }
    }

    task echoProperty {
        def food = providers.gradleProperty('fooD')
        doLast {
            println "fooD=" + food.get()
        }
    }
"""
    }

    void "has non-zero exit code on build failure"() {

plugins {
    id("application")
}

repositories {
    mavenCentral()
    gradlePluginPortal()
}

// tag::object-factory[]
tasks.register("myObjectFactoryTask") {
    doLast {
        val objectFactory = project.objects
        val myProperty = objectFactory.property(String::class)
        myProperty.set("Hello, Gradle!")
        println(myProperty.get())
    }
}
// end::object-factory[]

import org.gradle.tooling.provider.model.ToolingModelBuilder

plugins {
    id 'groovy'
}

repositories {
    mavenCentral()
}

// tag::object-factory[]
tasks.register("myObjectFactoryTask") {
    doLast {
        def objectFactory = project.objects
        def myProperty = objectFactory.property(String)
        myProperty.set("Hello, Gradle!")
        println myProperty.get()
    }
}
// end::object-factory[]

* limitations under the License.
*/

def visitIterations = (1..10)

tasks.register("visitZip") {
    doLast {
        visitIterations.each {
            zipTree(file("archive.zip")).each {
                logger.info it.path
            }
        }
    }
}

tasks.register("visitTar") {
    doLast {
        visitIterations.each {
            tarTree(file("archive.tar")).each {
                logger.info it.path