def watchableHierarchy = file("watchable").createDir()
        def fileOutsideOfWatchableHierarchy = file("outside").file("someFile.txt").createFile()
        def fileInDirectoryIgnoredForWatching = file("cache/some-cache/someFile.txt").createFile()
        ignoredForWatching.add(fileInDirectoryIgnoredForWatching.absolutePath)

        when:
        registerWatchableHierarchies([watchableHierarchy])

    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    def "can apply ContentAndMetadataAction to file contents"() {
        def file = tmpDir.createFile("content")
        file.text = "1234"

        expect:
        def resource = new LocalFileStandInExternalResource(file, TestFiles.fileSystem())

        setup:
        def file = temporaryFolder.createFile("fsbase/a/a");

        when:
        def fileInStore = uniquePathKeyFileStore.add("a/a", action)

        then:
        fileInStore.file == file
        0 * action.execute(_)
    }

    def "move returns existing file if it already exists"() {
        setup:
        def source = temporaryFolder.createFile("some-file")

        expect:
        fs.getUnixMode(tmpDir.createFile("someFile")) == FileSystem.DEFAULT_FILE_MODE
        fs.getUnixMode(tmpDir.createDir("someDir")) == FileSystem.DEFAULT_DIR_MODE
    }

    @Requires(UnitTestPreconditions.NoFilePermissions)
    def "setting unix permissions does nothing on unsupported platforms"() {
        expect:
        fs.chmod(tmpDir.createFile("someFile"), 0644)
    }

        long minimumTimestamp = (System.currentTimeMillis() / 1000 * 1000) - 2000
        def file1 = rootDir.createFile("a/b/1.txt")
        file1 << '12345'
        def file2 = rootDir.createFile("a/b/2.txt")
        file2 << '12345'
        def file3 = rootDir.createFile("a/b/3.txt")
        file3 << '12345'
        def fileTree = new DirectoryFileTree(rootDir, new PatternSet(), TestFiles.fileSystem(), false)

    }

    private TestFile createCacheEntryDir(String entry) {
        TestFile dir = cacheDir.createDir(entry)
        dir.createFile("state.bin")
        dir.createFile("fingerprint.bin")
        return dir
    }

    private TestFile getGcFile() {
        return cacheDir.file("gc.properties")
    }

    private TestFile getCacheDir() {

        long lastCleanupCheck = initializeHome()

        when:
        def newTrashFile = temporaryFolder.file("0" * hashStringLength).createFile()
        def oldTrashFile = temporaryFolder.file("1" * hashStringLength).createFile()
        createBuildCacheEntry("0" * hashStringLength, newTrashFile, System.currentTimeMillis())

        def jdkHome = temporaryFolder.createDir("jdk")
        def binDir = jdkHome.createDir("bin")
        binDir.createFile(OperatingSystem.LINUX.getExecutableName("java"))

        // Make it look like a macOS installation
        def macOsJdkHomeBinDir = jdkHome.createDir("Contents/Home/bin")
        macOsJdkHomeBinDir.createFile(OperatingSystem.LINUX.getExecutableName("java"))

        when:

    def "correctly executes copy actions, normalising and handling excludes"() {
        given:
        file("a").with {
            createFile("a")
        }
        file("b").with {
            createFile("b")
            createDir("b1").createFile("b1")
        }

        def resolver = TestFiles.resolver(testDirectory)
        def fileCollectionFactory = TestFiles.fileCollectionFactory(testDirectory)

  <application-name>customear</application-name>
</application>
"""

        file("${appDirectory}/META-INF/application.xml").createFile().write(applicationXml)
        file("${appDirectory}/someOtherFile.txt").createFile()
        file("${appDirectory}/META-INF/stuff/yetAnotherFile.txt").createFile()
        buildFile << """
apply plugin: 'ear'

ear {
    ${descriptorConfig}
    deploymentDescriptor {