@Rule
    final TestNameTestDirectoryProvider temporaryFolder = TestNameTestDirectoryProvider.newInstance(getClass())

    FileSystemAccess fileSystemAccess = TestFiles.fileSystemAccess()
    FileSystem fileSystem = TestFiles.fileSystem()

    def "filters correctly"() {
        given:
        def root = temporaryFolder.createDir("root")
        root.createFile("rootFile1")

    private Test test

    def setup() {
        classesDir = temporaryFolder.createDir("classes")
        File classfile = new File(classesDir, "FileTest.class")
        FileUtils.touch(classfile)
        resultsDir = temporaryFolder.createDir("testResults")
        binResultsDir = temporaryFolder.createDir("binResults")
        reportDir = temporaryFolder.createDir("report")

        test = createTask(Test.class)
    }

        def jdkHome = temporaryFolder.createDir("jdk-$version")
        def binDir = jdkHome.createDir("bin")
        binDir.createFile(OperatingSystem.current().getExecutableName("java"))
        return jdkHome
    }

    private TestFile createJreInstallation(String version) {
        def jdkHome = temporaryFolder.createDir("jdk-$version")

import spock.lang.Specification

@UsesNativeServices
@CleanupTestDirectory
class DirectoryBuildCacheTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    def cacheDir = temporaryFolder.createDir("cache")
    def persistentCache = Mock(PersistentCache) {
        getBaseDir() >> cacheDir
        withFileLock(_) >> { Runnable r -> r.run() }
    }

class FinalizeBuildCacheConfigurationBuildOperationIntegrationTest extends AbstractIntegrationSpec {

    def buildOperations = new BuildOperationsFixture(executer, temporaryFolder)

    def "local build cache configuration is exposed"() {
        given:
        def cacheDir = temporaryFolder.file("cache-dir").createDir()
        settingsFile << """
            buildCache {
                local {
                    enabled = true

import spock.lang.Specification

@CleanupTestDirectory
class SystemPropertiesHandlerTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())

    def parsesPropertiesFile() {
        TestFile propFile = temporaryFolder.file('props')
        propFile << """
a=b
systemProp.c=d
systemProp.=e
systemProp=f
"""

        expect:

    final outputFile = temporaryFolder.file("output-file")
    final outputDir = temporaryFolder.file("output-dir")
    final outputDirFile = outputDir.file("some-file")
    final outputDirFile2 = outputDir.file("some-file-2")
    final emptyOutputDir = temporaryFolder.file("empty-output-dir")
    final missingOutputFile = temporaryFolder.file("missing-output-file")

    private final TestNameTestDirectoryProvider temporaryFolder
    final WorkParameterClass testParameterType
    final WorkActionClass workActionThatCreatesFiles
    final WorkActionClass workActionThatFails

    WorkerExecutorFixture(TestNameTestDirectoryProvider temporaryFolder) {
        this.temporaryFolder = temporaryFolder
        this.outputFileDir = temporaryFolder.file("build/workers")

    @Rule
    final TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())

    @Rule
    final GcsServer server = new GcsServer(temporaryFolder)

    def "should perform put, get and list on an Gcs bucket"() {
        setup:
        def fileContents = 'This is only a test'
        File file = temporaryFolder.createFile(FILE_NAME)
        file << fileContents

        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:
        objCppCompile.toolChain = toolChain
        objCppCompile.targetPlatform = platform
        objCppCompile.compilerArgs = ["arg"]
        objCppCompile.macros = [def: "value"]
        objCppCompile.objectFileDir = temporaryFolder.file("outputFile")
        objCppCompile.source sourceFile