sourceMap = true
        }
    }
    val unpackKotlinJsStdlib by registering {
        group = "build"
        description = "Unpack the Kotlin JavaScript standard library"
        val outputDir = file("$buildDir/$name")
        inputs.property("compileClasspath", configurations.compileClasspath.get())
        outputs.dir(outputDir)
        doLast {
            val kotlinStdLibJar = configurations.compileClasspath.get().single {

configurations.runtimeClasspath.each { File f -> println f }
// end::groovyJdk[]

// tag::propertyAccessors[]
// Using a getter method
println project.buildDir
println getProject().getBuildDir()

// Using a setter method
project.buildDir = 'target'
getProject().setBuildDir('target')
// end::propertyAccessors[]

// tag::methodCallWithoutParentheses[]
test.systemProperty 'some.prop', 'value'

    }

    def cannotCreateAnEmptyTar() {
        given:
        buildFile << """
            task tar(type: Tar) {
                from 'test'
                destinationDirectory = buildDir
                archiveFileName = 'test.tar'
            }
            """
        when:
        run "tar"

        then:
        file('build/test.tar').assertDoesNotExist()
    }

    def dir = buildDir

    doLast {
        ant.move file: "${dir}/reports",
                 todir: "${dir}/toArchive"
    }
}
// end::move-example[]

// tag::delete-example[]
tasks.register('myClean', Delete) {
    delete buildDir
}
// end::delete-example[]

// tag::delete-with-filter-example[]

                archiveFile.set(project.file("\${buildDir}/foo.zip"))
            }
            task jarTask(type: Jar) {
                from(zipTask)
                archiveFile.set(project.file("\${buildDir}/foo.jar"))
            }
            taskWithInputs {
                sources.from(jarTask)
                outputFile = project.file("\${buildDir}/output.txt")
            }
        """

                attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling, Bundling.EXTERNAL))
            }
        }
    }


    artifacts {
        buildDir.mkdirs()
        file("\$buildDir/test.jar").text = "toto"
        runtimeOnly file("\$buildDir/test.jar")
    }
}

dependencies {
    api project(':child')

    artifactTypes.getByName("jar") {

interface ConfigurationCacheBuild {

    val gradle: GradleInternal

    val state: BuildState

    fun registerRootProject(rootProjectName: String, projectDir: File, buildDir: File)

    fun registerProject(projectPath: Path, dir: File, buildDir: File)

    fun getProject(path: String): ProjectInternal

    // Creates all registered projects for this build
    fun createProjects()

        file('build.gradle') << '''
            model {
                tasks {
                    create("fromModel") {
                        doLast {
                            buildDir.mkdirs()
                            new File(buildDir, "output.txt") << "from model rule defined task"
                        }
                    }
                }
            }
        '''
    }

        }

        where:
        expression       | _
        "buildDir"       | _
        "this.buildDir"  | _
        "owner.buildDir" | _
    }

    def "from-cache build fails when task action closure sets a project property"() {
        given:
        buildFile << """
            tasks.register("some") {

    def "detects when a task removes the build directory #buildDir"() {
        buildFile << """
            apply plugin: 'base'

            project.buildDir = file("${buildDir}")

            task myClean(type: Delete) {
                delete buildDir
            }

            task producer {
                def outputFile = new File(buildDir, "some/file/in/buildDir/output.txt")
                outputs.file(outputFile)