import java.util.SortedSet;

public interface UsedGradleVersions {

    /**
     * Returns the set of Gradle versions known to be used.
     */
    SortedSet<GradleVersion> getUsedGradleVersions();

        cacheBaseDir.createDir("2.3.4")
        cacheBaseDir.createDir("99_BAR")
        cacheBaseDir.createDir("ZZZZ")

        when:
        def versions = versions.getUsedGradleVersions()

        then:
        versions as List == [
            GradleVersion.version("0.9-20101220110000+1100"),
            GradleVersion.version("1.2.3-rc-1"),
            GradleVersion.version("2.3.4")
        ]

    }
    def cacheBuilderFactory = Mock(GlobalScopedCacheBuilderFactory) {
        getRootDir() >> userHomeDir.createDir("caches")
    }
    def usedGradleVersions = Stub(UsedGradleVersions) {
        getUsedGradleVersions() >> ([] as SortedSet)
    }

    def releasedWrappers = Stub(CacheResourceConfigurationInternal) {

        directoryScanner = new VersionSpecificCacheDirectoryScanner(cacheBuilderFactory.getRootDir());
    }

    @Override
    public SortedSet<GradleVersion> getUsedGradleVersions() {
        SortedSet<GradleVersion> result = new TreeSet<>();
        for (VersionSpecificCacheDirectory cacheDir : directoryScanner.getExistingDirectories()) {
            result.add(cacheDir.getVersion());
        }

            return new WritableArtifactCacheLockingAccessCoordinator(unscopedCacheBuilderFactory, writableCacheMetadata, params.getFileAccessTimeJournal(), params.getUsedGradleVersions(), cacheConfigurations);
        });
        String roCache = System.getenv(READONLY_CACHE_ENV_VAR);
        if (StringUtils.isNotEmpty(roCache)) {

    def userHomeDir = temporaryFolder.createDir("user-home")
    def usedGradleVersions = Mock(UsedGradleVersions) {
        getUsedGradleVersions() >> ([] as SortedSet)
    }
    def progressMonitor = Mock(CleanupProgressMonitor)

    @Subject def cleanupAction = new WrapperDistributionCleanupAction(userHomeDir, usedGradleVersions)

        }
    }

    private SortedSet<GradleVersion> getUsedGradleVersionsSmallerThanCurrent() {
        return usedGradleVersions.getUsedGradleVersions().headSet(GradleVersion.current());
    }

    @Override
    protected boolean shouldDelete(File cacheDir) {
        Matcher matcher = cacheNamePattern.matcher(cacheDir.getName());
        if (matcher.matches()) {

        when:
        UnusedVersionsCacheCleanup.create(CACHE_NAME, cacheVersionMapping, usedGradleVersions)
            .clean(cleanableStore, progressMonitor)

        then:
        usedGradleVersions.getUsedGradleVersions() >> (gradleVersions.collect { GradleVersion.version(it) } as SortedSet)
        numSkipped * progressMonitor.incrementSkipped()
        numDeleted * progressMonitor.incrementDeleted()

            @Override
            public FileAccessTimeJournal getFileAccessTimeJournal() {
                return fileAccessTimeJournal;
            }

            @Override
            public UsedGradleVersions getUsedGradleVersions() {
                return usedGradleVersions;
            }
        };
    }

    @Provides
    ArtifactCachesProvider createArtifactCaches(
        GlobalScopedCacheBuilderFactory cacheBuilderFactory,

        long maximumTimestamp = Math.max(0, System.currentTimeMillis() - TimeUnit.DAYS.toMillis(1));
        Set<GradleVersion> usedVersions = this.usedGradleVersions.getUsedGradleVersions();
        Multimap<GradleVersion, File> checksumDirsByVersion = determineChecksumDirsByVersion();
        for (GradleVersion version : checksumDirsByVersion.keySet()) {