}
                webInf {
                    from 'web-inf'
                }
                classpath 'classes'
                classpath 'lib.jar'
                destinationDirectory = buildDir
                archiveFileName = 'test.war'
            }
        """

        when:
        run "war"

        then:
        def war = new JarTestFixture(file('build/test.war'))

                def builtFile = file('build/file')
                def builtDir = file('build/dir')
                outputs.file builtFile
                outputs.dir builtDir
                doLast {
                    assert !builtFile.exists()
                    builtFile.text = "Created"
                    assert builtDir.directory
                    assert builtDir.list().length == 0
                }
            }
        """

    def 'can execute java with #task'() {
        given:
        buildFile << """
            apply plugin: 'java'

            task javaexecTask(type: JavaExec) {
                def testFile = file("${'$'}buildDir/${'$'}name")
                classpath(sourceSets.main.output.classesDirs)
                mainClass = 'org.gradle.TestMain'
                args projectDir, testFile
                doLast {

        testSourceSet.compileClasspath.contains(new File(project.buildDir, 'classes/java/main'))
        testSourceSet.annotationProcessorPath.is(project.configurations.testAnnotationProcessor)
        testSourceSet.java.destinationDirectory.set(new File(project.buildDir, 'classes/java/test'))
        testSourceSet.output.resourcesDir == new File(project.buildDir, 'resources/test')

        run 'retrieve'

        then:
        hasArtifact(module)

    }

    def hasArtifact(MavenModule module) {
        def buildDir = file('build')
        def artifactName = module.artifactFile.name
        buildDir.assertHasDescendants(artifactName)
        buildDir.file(artifactName).assertIsCopyOf(module.artifactFile)
    }

        // TODO: synchronization
        File buildDir = buildDefinition.getBuildRootDir();
        if (buildDir == null) {
            throw new IllegalArgumentException("Included build must have a root directory defined");
        }
        IncludedBuildState includedBuild = includedBuildsByRootDir.get(buildDir);
        if (includedBuild == null) {
            if (rootBuild == null) {

    }

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

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

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

    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)

                ${invocation} { println(it.buildDir) }
            }
        """

        when:
        isolatedProjectsFails(":a:help", ":b:help")

        then:
        fixture.assertStateStoredAndDiscarded {
            projectsConfigured(":", ":a", ":b")
            problem("Build file 'a/build.gradle': line 3: Project ':a' cannot access 'Project.buildDir' functionality on $message", accessedProjects)
        }