*/

package org.gradle.cache;

public interface CleanupProgressMonitor {

    void incrementDeleted();

    void incrementSkipped();

    void incrementSkipped(long amount);

    CleanupProgressMonitor NO_OP = new CleanupProgressMonitor() {
        @Override
        public void incrementDeleted() {
        }

        @Override
        public void incrementSkipped() {
        }

        when:
        def cleanedUp = cleanupAction.execute(progressMonitor)

        then:
        cleanedUp
        4 * progressMonitor.incrementSkipped()
        2 * progressMonitor.incrementDeleted()
        ancientVersionWithoutMarkerFile.assertExists()
        oldestCacheDir.assertDoesNotExist()
        oldButRecentlyUsedCacheDir.assertExists()
        oldCacheDir.assertDoesNotExist()

    def "reports deleted and skipped"() {
        when:
        progressMonitor.incrementDeleted()

        then:
        1 * context.progress("1 entry deleted")

        when:
        progressMonitor.incrementSkipped()

        then:
        1 * context.progress("1 entry deleted, 1 skipped")

        when:
        progressMonitor.incrementDeleted()

        then:
        1 * context.progress("2 entries deleted, 1 skipped")

            .clean(cleanableStore, progressMonitor)

        then:
        1 * cleanableStore.getReservedCacheFiles() >> [cacheEntries[0]]
        1 * progressMonitor.incrementDeleted()
        1 * progressMonitor.incrementSkipped()
        cacheEntries[0].assertExists()
        cacheEntries[1].assertDoesNotExist()
        cacheEntries[2].assertExists()
        deletedFiles == [cacheEntries[1]]

        then:
        1 * usedGradleVersions.getUsedGradleVersions() >> ([usedVersion] as SortedSet)
        3 * progressMonitor.incrementSkipped(1)
        1 * progressMonitor.incrementDeleted()
        unusedDist.parentFile.assertDoesNotExist()
        stillUsedDist.assertExists()
        currentDist.assertExists()
        unusedFutureDist.assertExists()
    }

    private long skipped;

    public DefaultCleanupProgressMonitor(BuildOperationContext buildOperationContext) {
        this.buildOperationContext = buildOperationContext;
    }

    @Override
    public void incrementDeleted() {
        deleted++;
        updateProgress();
    }

    @Override
    public void incrementSkipped() {
        incrementSkipped(1);
    }

    @Override

        int filesDeleted = 0;
        for (File file : findEligibleFiles(cleanableStore)) {
            if (shouldDelete(file)) {
                progressMonitor.incrementDeleted();
                if (FileUtils.deleteQuietly(file)) {
                    handleDeletion(file);
                    filesDeleted += 1 + deleteEmptyParentDirectories(cleanableStore.getBaseDir(), file.getParentFile());

        then:
        usedGradleVersions.getUsedGradleVersions() >> (gradleVersions.collect { GradleVersion.version(it) } as SortedSet)
        numSkipped * progressMonitor.incrementSkipped()
        numDeleted * progressMonitor.incrementDeleted()
        for (version in expectedRemainingVersions) {
            versionDir(parentCacheVersion.append(version)).assertExists()
        }
        for (version in expectedDeletedVersions) {

        for (VersionSpecificCacheDirectory cacheDir : cacheDirsWithSameBaseVersion) {
            if (cleanupCondition.isSatisfiedBy(cacheDir)) {
                progressMonitor.incrementDeleted();
                try {
                    deleteCacheDir(cacheDir.getDir());
                } catch (Exception e) {

                 *      | gradle-5.5.1-bin.zip.lck
                 *      | gradle-5.5.1-bin.zip
                 *      | gradle-5.5.1
                 */
                progressMonitor.incrementDeleted();
                LOGGER.debug("Marking distribution for {} at {} unusable", version, checksumDir);

                // The wrapper uses the .ok file to identify distributions that are safe to use.