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

        def sourceDir = testDirectory.createDir("source-directory")
        def childDir = sourceDir.createDir("child")
        def childFile = childDir.createFile("child.txt")
        def parentFile = sourceDir.createFile("parent.txt")
        def targetDir = testDirectory.file("target-directory")

        // need an existing sibling of the symlink to ensure the parent directory of
        // the symlink is watched between builds.
        linkdir.file("existing").createFile()
        buildFile << """
    task echo {
        def symlink = file("${symlink.toURI()}")
        inputs.files symlink
        inputs.files "src/linkdir/existing"
        outputs.file "build/outputs"