cleanupAction(finder([file]), { true })
            .clean(cleanableStore, progressMonitor)

        then:
        1 * progressMonitor.incrementDeleted()
        file.assertDoesNotExist()
        parent.assertDoesNotExist()
        grandparent.assertDoesNotExist()
        cacheDir.assertExists()
        deletedFiles == [file, parent, grandparent]
    }

    def "does not delete non-empty parent directories"() {
        given:

        given:
        gcFile.lastModified = daysAgo(2)

        when:
        succeeds("help")

        then:
        oldModulesDir.assertDoesNotExist()
        oldMetadataDir.assertDoesNotExist()
        currentModulesDir.assertExists()
        currentModulesMetadataDir.assertExists()
    }

    def "cleans up unused versions of caches on cleanup always"() {
        given:

        cleanupAction.execute(progressMonitor)

        then:
        1 * progressMonitor.incrementSkipped(2)
        2 * progressMonitor.incrementDeleted()
        oldAllDist.parentFile.assertDoesNotExist()
        oldBinDist.parentFile.assertDoesNotExist()
        currentAllDist.assertExists()
        currentBinDist.assertExists()
    }

    def "does not delete custom parent directories that are still in use"() {
        given:

        then:
        dslDir.file('build/toArchive/my-report.pdf').isFile()
        dslDir.file('build/toArchive/metrics/scatterPlot.pdf').assertDoesNotExist()
        dslDir.file('build/toArchive/scatterPlot.pdf').assertDoesNotExist()
        dslDir.file('build/toArchive/numbers.csv').assertDoesNotExist()

        where:
        dsl << ['groovy', 'kotlin']
    }

    @UsesSample("files/copy")

        then:
        file1.assertExists()
        file2.assertDoesNotExist()
        file3.assertDoesNotExist()
    }

    def "deletes old versions of cache dir"() {
        given:
        def oldCacheDir = cacheDir.getParentFile().createDir("modules-1")

        when:
        cacheLockingManager.close()

        then:
        oldCacheDir.assertDoesNotExist()
    }

        succeeds("cleanXcode")

        then:
        executedAndNotSkipped(":cleanXcodeProject")

        project.projectFile.getFile().assertDoesNotExist()
        project.schemeFiles*.file*.assertDoesNotExist()
        project.workspaceSettingsFile.assertDoesNotExist()
        project.dir.assertDoesNotExist()
    }

        4 * progressMonitor.incrementSkipped()
        2 * progressMonitor.incrementDeleted()
        ancientVersionWithoutMarkerFile.assertExists()
        oldestCacheDir.assertDoesNotExist()
        oldButRecentlyUsedCacheDir.assertExists()
        oldCacheDir.assertDoesNotExist()
        currentCacheDir.assertExists()
        newerCacheDir.assertExists()
    }

    def "ignores directories that are not version-specific caches"() {

        given:
        modulesGcFile.lastModified = daysAgo(2)

        when:
        succeeds("help")

        then:
        transforms3Dir.assertDoesNotExist()
        transforms4Dir.assertDoesNotExist()
        currentTransformsDir.assertExists()
        currentModulesDir.assertExists()
    }

    def "retains used versions of transforms-X when current modules requires cleanup"() {

            file.withExtension(".exp").assertIsFile()
        }
    }

    @Override
    void assertDoesNotExist() {
        super.assertDoesNotExist()
        if (toolChain.visualCpp) {
            file.withExtension(".lib").assertDoesNotExist()
            file.withExtension(".exp").assertDoesNotExist()
        }
    }

    String getSoName() {
        return binaryInfo.soName
    }

        result.assertTasksNotSkipped(notSkippedTasks)
        result.assertTasksSkipped(skippedTasks)

        executable("app/build/exe/main/debug/app").assertDoesNotExist()
        file("app/build/exe/main/debug").assertDoesNotExist()
        file("app/build/obj/main/debug").assertDoesNotExist()
        installation("app/build/install/main/debug").assertNotInstalled()

        sharedLibrary("greeter/build/lib/main/debug/greeter").assertExists()