def "cleans up resources"() {
        given:
        def file1 = resourcesDir.createDir("1/abc").createFile("test.txt")
        def file2 = resourcesDir.createDir("1/xyz").createFile("test.txt")
        def file3 = resourcesDir.createDir("2/uvw").createFile("test.txt")
        file2.parentFile.lastModified = 0
        file3.parentFile.lastModified = 0

        when:

    def "locates each script from init.d directory"() {
        def scripts = []

        given:
        def script1 = distDir.createFile("init.d/script1.gradle")
        def script2 = distDir.createFile("init.d/script2.gradle")
        distDir.createFile("init.d/readme.txt")
        distDir.createFile("init.d/lib/test.jar")

        when:
        finder.findScripts(scripts)

        then:
        scripts.size() == 2

    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)

        def watchableHierarchy = file("watchable").createDir()
        def watchableContent = watchableHierarchy.file("some/dir/file.txt").createFile()
        def unsupportedFileSystemMountPoint = watchableHierarchy.file("unsupported")
        def unwatchableContent = unsupportedFileSystemMountPoint.file("some/file.txt").createFile()

        when:
        registerWatchableHierarchies([watchableHierarchy])

        File resultFile;

        path = "hoge.html";
        file = fileTransformer.createFile(path);
        resultFile = new File(fileTransformer.baseDir, path);
        assertEquals(resultFile, file);
        FileUtil.writeBytes(file.getAbsolutePath(), "abc".getBytes());

        path = "foo1/hoge.html";
        file = fileTransformer.createFile(path);
        resultFile = new File(fileTransformer.baseDir, path);

        inputFiles.each { it.createFile() }
        def newfile1 = inputDir.file("input12.txt")
        def newfile2 = inputDir.file("input13.txt")

        when:
        succeeds("theTask")
        newfile1.createFile()
        inputFiles[2].text = 'Modified file'
        inputFiles[7].delete()
        newfile2.createFile()

        then:
        buildTriggeredAndSucceeded()

    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    @Requires(UnitTestPreconditions.Symlinks)
    def "normalizes absolute path which points to an absolute link"() {
        def target = createFile(new File(tmpDir.testDirectory, 'target.txt'))
        def file = new File(tmpDir.testDirectory, 'a/other.txt')
        createLink(file, target)
        assert file.exists() && file.file

        expect:

        given:
        def htmlFolder = tmpDir.createDir('htmlContent');
        htmlFolder.createFile("index.html")

        when:
        generator.render([
                        mockReport('a', tmpDir.createFile('report.html')),
                        mockReport('b', tmpDir.createDir('inner').createFile('otherReport.html')),
                        mockReport('c', tmpDir.file('idonotexist.html')),

        then:
        sourceList.isEmpty()
    }

    def "adds init scripts from init directory when it exists."() {
        given:
        def initScript = temporaryFolder.createFile("init.d/script.gradle")
        def secondScript = temporaryFolder.createFile("init.d/another.gradle.kts")
        def sourceList = []

        when:
        finder.findScripts(sourceList)

        then:
        sourceList.size() == 2

        x64Registry()
        vswhere = localRoot.createFile("vswhere.exe")
    }

    void vswhereInProgramFiles() {
        x86Registry()
        vswhere = programFiles.createDir("Microsoft Visual Studio/Installer").createFile("vswhere.exe")
    }

    void vswhereInProgramFilesX86() {
        x64Registry()
        vswhere = programFilesX86.createDir("Microsoft Visual Studio/Installer").createFile("vswhere.exe")
    }