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

    def virtualFileSystem = TestFiles.virtualFileSystem()
    def fileSystemAccess = TestFiles.fileSystemAccess(virtualFileSystem)

    def "pre-existing directories are filtered"() {
        def outputDir = temporaryFolder.file("outputDir").createDir()

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

    def 'asJvmArg with default arguments assembles correct string'() {
        setup:
        agent.supportsJmx() >> true
        agent.supportsInclNoLocationClasses() >> true
        agent.jar >> temporaryFolder.file('fakeagent.jar')
        task.getWorkingDir() >> temporaryFolder.file(".")
        expect:

    @Rule
    TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass());
    Action<File> action = Mock()

    UniquePathKeyFileStore uniquePathKeyFileStore

    def setup() {
        uniquePathKeyFileStore = new UniquePathKeyFileStore(TestUtil.checksumService, temporaryFolder.createDir("fsbase"))
    }

    def "add executes action if file does not exist"() {

        TestFiles.deleter()
    }

    def "can pack directory"() {
        def sourceOutputDir = temporaryFolder.file("source").createDir()
        def sourceSubDir = sourceOutputDir.file("subdir").createDir()
        def sourceDataFile = sourceSubDir.file("data.txt")
        sourceDataFile << "output"
        def targetOutputDir = temporaryFolder.file("target").createDir()
        def targetSubDir = targetOutputDir.file("subdir")

        def treeWithExcludes = new DirectoryFileTree(temporaryFolder.getTestDirectory(), excludesOnly, TestFiles.fileSystem(), false)

        expect:
        treeWithNoIncludesOrExcludes.getDisplayName() == "directory '${temporaryFolder.getTestDirectory()}'".toString()
        treeWithIncludes.getDisplayName() == "directory '${temporaryFolder.getTestDirectory()}' include 'a/b', 'c'".toString()

@CleanupTestDirectory
class TarCopyActionSpec extends Specification {
    @Rule
    public final TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    private TarCopyAction action


    def "creates tar file"() {
        expect:
        final TestFile tarFile = initializeTarFile(temporaryFolder.testDirectory.file("test.tar"), new SimpleCompressor())
        tarAndUntarAndCheckFileContents(tarFile)
    }

    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "can follow symlinks"() {
        given:
        def keepTxt = temporaryFolder.createFile("originalDir", "keep.txt")
        def originalDir = keepTxt.getParentFile()
        def link = new File(temporaryFolder.getTestDirectory(), "link")
        fileSystem().createSymbolicLink(link, originalDir)

        when:
        delete.delete(link)

    @Rule
    public final TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    private UserHomeInitScriptFinder finder

    def setup() {
        finder = new UserHomeInitScriptFinder(temporaryFolder.getTestDirectory())
    }

    def "adds user #initScriptName init script when it exits"() {
        given:
        def initScript = temporaryFolder.createFile(initScriptName)
        def sourceList = []

import org.gradle.test.fixtures.file.TestFile

class DefaultFileSystemAccessTest extends AbstractFileSystemAccessTest {

    def "can read a file"() {
        TestFile someFile = temporaryFolder.file("some/subdir/someFile").createFile()

        when:
        allowFileSystemAccess(true)
        def snapshot = read(someFile)
        then:
        assertIsFileSnapshot(snapshot, someFile)

        when:

        then:
        hasGradleMetadataRedirectionMarker
    }

    def "parse IVY descriptor with external entities"() {
        given:
        def externalFile = temporaryFolder.file('external.txt').createFile()
        def ivyXml = temporaryFolder.file("ivy.xml") << """
        <!DOCTYPE data [
          <!ENTITY file SYSTEM "file://${normaliseFileSeparators(externalFile.absolutePath)}">
        ]>