def deletedFiles = []

    def "deletes non-reserved matching files"() {
        def cacheEntries = [
            temporaryFolder.createFile("1"),
            temporaryFolder.createFile("2"),
            temporaryFolder.createFile("3"),
        ]

        when:
        cleanupAction(finder(cacheEntries), { it != cacheEntries[2] })
            .clean(cleanableStore, progressMonitor)

        then:

        childSnapshot.absolutePath == childAbsolutePath.absolutePath
    }

    def "snapshot accessed directly is relocated"() {
        def sourceFile = temporaryFolder.file("source.txt")
        def targetFile = temporaryFolder.file("target.txt")
        def sourceSnapshot = createInitialRootNode(sourceFile.absolutePath, DIRECT)

        when:

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

    def candidates = temporaryFolder.createDir("linux")
    def otherCandidates = temporaryFolder.createDir("other")
    def emptyDir = temporaryFolder.createDir("empty")
    def nonExistent = temporaryFolder.file("non-existent")

    def setup() {
        candidates.createDir("11.0.6.hs-adpt")

    def setup() {
        System.setProperty("user.dir", temporaryFolder.testDirectory.absolutePath)
        // This prevents the ProjectBuilder from finding the Gradle build's root settings.gradle
        // and treating the root of the repository as the root of the build
        new File(temporaryFolder.testDirectory, "settings.gradle") << ""
        rootProject = TestUtil.createRootProject(temporaryFolder.testDirectory)

    def "executes using the C Compiler"() {
        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:
        objCCompile.toolChain = toolChain
        objCCompile.targetPlatform = platform
        objCCompile.compilerArgs = ["arg"]
        objCCompile.macros = [def: "value"]
        objCCompile.objectFileDir = temporaryFolder.file("outputFile")
        objCCompile.source sourceFile

 */
package org.gradle.docs.asciidoctor

import org.asciidoctor.Asciidoctor
import org.junit.Rule
import org.junit.rules.TemporaryFolder
import spock.lang.Specification

class ExampleSelfLinkProcessorTest extends Specification {
    @Rule
    TemporaryFolder tmpDir = new TemporaryFolder()

    Asciidoctor asciidoctor

    def setup() {
        tmpDir.newFolder("src", "samples")

    def "executes using the CppCompiler"() {
        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)
        when:
        cppCompile.toolChain = toolChain
        cppCompile.targetPlatform = platform
        cppCompile.compilerArgs = ["arg"]
        cppCompile.macros = [def: "value"]
        cppCompile.objectFileDir = temporaryFolder.file("outputFile")
        cppCompile.source sourceFile

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

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