@CleanupTestDirectory
abstract class CrossVersionIntegrationSpec extends Specification {
    @Rule TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    private final List<GradleExecuter> executers = []
    final GradleDistribution current = new UnderDevelopmentGradleDistribution()
    static GradleDistribution previous

import org.junit.Rule
import spock.lang.Specification

class CompositeCleanupActionTest extends Specification {

    @Rule TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    def cleanableStore = Stub(CleanableStore) {
        getBaseDir() >> temporaryFolder.getTestDirectory()
        getDisplayName() >> "My Cache"
    }
    def progressMonitor = Stub(CleanupProgressMonitor)

import org.gradle.testkit.runner.GradleRunner
import org.junit.Before
import org.junit.Rule
import org.junit.rules.TemporaryFolder
import java.io.File

abstract class PluginTest {

    @Rule
    @JvmField
    val testProjectDir: TemporaryFolder = TemporaryFolder()
    protected lateinit var settingsFile: File
    protected lateinit var buildFile: File

    @Before
    fun setup() {

        temporaryFolder.createFile('settings.gradle') << '''
          rootProject.name = 'TestProject'
          include 'sub'
        '''

        temporaryFolder.createFile('build.gradle') << '''
          task alpha {
            description = 'ALPHA from root project'
          }
          task beta {}
        '''

        temporaryFolder.createDir('sub')

    }

    def "cleans outputs and delegates spec for clean compilation"() {
        def spec = Mock(NativeCompileSpec)
        def existingSource = temporaryFolder.file("existing")
        def newSource = temporaryFolder.file("new")
        def outputFile = temporaryFolder.createFile("output", "previous")

        def sources = [existingSource, newSource]

        when:
        outputFile.assertExists()

        and:

    @Rule
    TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    def deleter = TestFiles.deleter()
    def fileSystemSupport = new DefaultTarPackerFileSystemSupport(deleter)

    def "parent directory is created for output file"() {
        def targetOutputFile = temporaryFolder.file("build/some-dir/output.txt")
        targetOutputFile << "Some data"

        def dest = temporaryFolder.file("dir/dest")

        when:
        new TestFileTreeElement(src, chmod).copyTo(dest)

        then:
        dest.assertIsFile()
        dest.getText() == "content"
    }

    def copiedFileHasExpectedPermissions() throws Exception {
        given:
        def src = writeToFile("src", "")
        final dest = temporaryFolder.file("dest")

        when:

    def "executes using the C Compiler"() {
        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)

        when:
        cCompile.toolChain = toolChain
        cCompile.targetPlatform = platform
        cCompile.compilerArgs = ["arg"]
        cCompile.macros = [def: "value"]
        cCompile.objectFileDir = temporaryFolder.file("outputFile")
        cCompile.source sourceFile

    def "does not delete non-empty directories"() {
        def outputFiles = []

        def outputDir = temporaryFolder.createDir("rootDir")
        outputFiles << outputDir.file("some-output.txt")

        def subDir = outputDir.createDir("subDir")
        outputFiles << subDir.file("in-subdir.txt")

        def outputFile = temporaryFolder.createFile("output.txt")
        outputFiles << outputFile

        outputFiles.each {

class DefaultArtifactCacheMetadataTest extends Specification {
    @Rule TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    def cache = Stub(GlobalScopedCacheBuilderFactory)

    def "calculates file store directory"() {
        given:
        TestFile testCacheDir = temporaryFolder.file("test/cache")
        cache.baseDirForCrossVersionCache(CacheLayout.MODULES.key) >> testCacheDir