then:
        targetOutputFile.parentFile.assertIsEmptyDir()
    }

    def "directory is created for output directory"() {
        def targetOutputDir = temporaryFolder.file("build/output")

        when:
        fileSystemSupport.ensureDirectoryForTree(DIRECTORY, targetOutputDir)

        then:
        targetOutputDir.assertIsEmptyDir()
    }

    def "cleans up leftover files in output directory"() {

        file("buildSrc").assertIsEmptyDir()
        executer.gradleUserHomeDir.file(BuildScopeCacheDir.UNDEFINED_BUILD).assertDoesNotExist()
    }

    def "does not fail when executing #flag in undefined build"() {
        when:
        executer.requireDaemon().requireIsolatedDaemons()
        succeeds(flag)

        then:
        testDirectory.assertIsEmptyDir()

        where:

            visitor.visitLocalState(localStateFile)
            visitor.visitDestroyable(destroyableFile)
        }

        then:
        outputDir.assertIsEmptyDir()
        outputFile.parentFile.assertIsEmptyDir()
        localStateFile.parentFile.assertIsEmptyDir()
        !destroyableFile.parentFile.exists()

        then:
        1 * delegate.execute(work, context)
        0 * _
    }

        def generatedJarsDirectory = "user-home/caches/$version/generated-gradle-jars"

        when:
        succeeds("help")

        then:
        file(generatedJarsDirectory).assertIsEmptyDir()

        when:
        succeeds("classes")

        then:
        file("$generatedJarsDirectory/gradle-api-${version}.jar").assertExists()

    }

        when:
        deleter.ensureEmptyDirectory(target, true)

        then:
        target.assertIsEmptyDir()
        linked.assertIsEmptyDir()
        Files.readSymbolicLink(target.toPath()) == linked.toPath()
        content.assertDoesNotExist()
    }

    @Requires(UnitTestPreconditions.Symlinks)

        given:
        buildFile << applyJavaPlugin()

        when:
        succeeds 'build'

        then:
        file("user-home/caches/${distribution.version.version}/generated-gradle-jars").assertIsEmptyDir()
    }

    def "buildSrc project implicitly forces generation of Gradle API JAR"() {
        given:
        buildFile << applyJavaPlugin()

        scalaClassFile("compile/test/Person.class").exists()
    }

    def compileBadCode() {
        badCode()

        expect:
        fails("compileScala")
        file("build/classes/scala/main").assertIsEmptyDir()

        if (versionNumber.major >= 3) {
            result.assertHasErrorOutput("src/main/scala/compile/test/Person.scala:4:28: Found:    (42 : Int)\nRequired: String")
        } else {

For troubleshooting, visit https://help.gradle.org

BUILD SUCCESSFUL"""

        and:
        // Directory is still empty
        testDirectory.assertIsEmptyDir()

        and:
        // Uses a directory under the user home for those things that happen to need a cache directory
        executer.gradleUserHomeDir.file(BuildScopeCacheDir.UNDEFINED_BUILD).assertIsDir()

        // force rebuild
        outputDir.file("modified.txt").text = "changed"
        inputDir.forceDeleteDir()
        run("copy")
        then:
        executedAndNotSkipped(":copy")
        outputDir.assertIsEmptyDir()
    }

    def "outputs are cleaned out on rebuild (output type: #type)"() {
        file("buildSrc").deleteDir()
        buildFile.text = """
            abstract class MyCopy extends DefaultTask {

        noExceptionThrown()

        when:
        def input = new ByteArrayInputStream(output.toByteArray())
        unpack input, prop("empty", DIRECTORY, targetDir)

        then:
        targetDir.assertIsEmptyDir()
    }

    def "catch escaping path in tar archive entry during unpacking"() {
        given:
        def targetDir = temporaryFolder.file("target")
        def output = new ByteArrayOutputStream()