return usedGradleVersions.getUsedGradleVersions().headSet(GradleVersion.current());
    }

    @Override
    protected boolean shouldDelete(File cacheDir) {
        Matcher matcher = cacheNamePattern.matcher(cacheDir.getName());
        if (matcher.matches()) {
            CacheVersion version = CacheVersion.parse(matcher.group(1));

    def cacheDir = temporaryFolder.createDir(".gradle")
    def context = Mock(BuildOperationContext)
    def buildOperationRunner = Mock(BuildOperationRunner)
    def deleter = TestFiles.deleter()

    @Subject def projectCacheDir = new ProjectCacheDir(cacheDir, buildOperationRunner, deleter)

    def "cleans up unused version-specific cache directories"() {

@SdkSuppress(minSdkVersion = 34)
class AndroidHttpEngineTest {
  val context = InstrumentationRegistry.getInstrumentation().context

  val cacheDir =
    context.cacheDir.resolve("httpEngine").also {
      it.mkdirs()
    }
  val engine =
    HttpEngine.Builder(context)
      .setEnableBrotli(true)
      .setStoragePath(cacheDir.path)
      .setEnableHttpCache(HttpEngine.Builder.HTTP_CACHE_DISK, 10_000_000)
      .setConnectionMigrationOptions(

                inputs.file("input")
                outputs.file(outputFile)
                outputs.cacheIf { true }

                doLast {
                    outputFile.parentFile.mkdirs()
                    outputFile.text = "done"
                }
            }
"""
        def cacheDir = file("task-output-cache")
        settingsFile << """
            buildCache {
                local {

    private TestDecompressionCoordinators() {}

    public static DecompressionCoordinator decompressionCoordinator(File cacheDir) {
        final TestInMemoryCacheFactory cacheFactory = new TestInMemoryCacheFactory();
        return new DefaultDecompressionCoordinator(cacheFactory.open(cacheDir, "test compression cache"));
    }

    @Rule TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    def cacheDir = temporaryFolder.file("cache-dir").createDir()
    def cleanableStore = Stub(CleanableStore) {
        getBaseDir() >> cacheDir
    }
    def fileAccessTimeJournal = Spy(ModificationTimeFileAccessTimeJournal)
    def progressMonitor = Stub(CleanupProgressMonitor)

    this.windows = windows

    if (filesystem.exists(cacheDir)) {
      filesystem.deleteRecursively(cacheDir)
    }
    journalFile = cacheDir / DiskLruCache.JOURNAL_FILE
    journalBkpFile = cacheDir / DiskLruCache.JOURNAL_FILE_BACKUP
    createNewCache()
  }

  @AfterEach fun tearDown() {
    while (!toClose.isEmpty()) {
      toClose.pop().close()
    }
    taskFaker.close()

    @Override
    void createBuildCacheEntry(String key, File value, long timestamp) {
        File cacheFile = cacheDir.file(key)
        Files.copy(value.toPath(), cacheFile.toPath())
        writeLastFileAccessTimeToJournal(cacheFile, timestamp)
    }

    @Override
    boolean existsBuildCacheEntry(String key) {
        cacheDir.file(key).exists()
    }

    @Override
    AbstractIntegrationSpec withEnabledBuildCache() {

    public static final CacheVersion CACHE_LAYOUT_VERSION = CacheLayout.META_DATA.getVersion();
    private final File cacheDir;
    private final File baseDir;

    public DefaultArtifactCacheMetadata(GlobalScopedCacheBuilderFactory cacheBuilderFactory) {
        this.baseDir = cacheBuilderFactory.getRootDir();
        this.cacheDir = cacheBuilderFactory.baseDirForCrossVersionCache(CacheLayout.MODULES.getKey());
    }

        }
        outputContains "Using local directory build cache for the root build (location = ${mainCache.cacheDir}, removeUnusedEntriesAfter = 7 days)."

        and:
        def expectedCacheDirs = [":": mainCache.cacheDir]
        if (isNotConfigCache()) {