void incrementDeleted();

    void incrementSkipped();

    void incrementSkipped(long amount);

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

        @Override
        public void incrementSkipped() {
        }

        @Override
        public void incrementSkipped(long amount) {
        }
    };

    }

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

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

    @Override
    public void incrementSkipped(long amount) {
        skipped += amount;
        updateProgress();
    }

    public long getDeleted() {
        return deleted;
    }

        when:
        def cleanedUp = cleanupAction.execute(progressMonitor)

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

    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:

        when:
        cleanupAction.execute(progressMonitor)

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

                    filesDeleted += 1 + deleteEmptyParentDirectories(cleanableStore.getBaseDir(), file.getParentFile());
                }
            } else {
                progressMonitor.incrementSkipped();
            }
        }
        LOGGER.info("{} cleanup deleted {} files/directories.", cleanableStore.getDisplayName(), filesDeleted);
    }

                deleteDistributions(version, checksumDirsByVersion.get(version), maximumTimestamp, progressMonitor);
            } else {
                progressMonitor.incrementSkipped(checksumDirsByVersion.get(version).size());
            }
        }
        return true;
    }

            .clean(cleanableStore, progressMonitor)

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

            .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]]
    }

    def "can delete directories"() {

                    LOGGER.error("Failed to process/clean up version-specific cache directory: {}", cacheDir.getDir(), e);
                }
            } else {
                progressMonitor.incrementSkipped();
            }
        }
    }

    private void deleteCacheDir(File cacheDir) throws IOException {
        LOGGER.debug("Deleting version-specific cache directory at {}", cacheDir);