}

        and:
        cacheDir.listFiles().length == 3 // gc file + cache properties + 'help' state
    }

    private TestFile createCacheEntryDir(String entry) {
        TestFile dir = cacheDir.createDir(entry)
        dir.createFile("state.bin")
        dir.createFile("fingerprint.bin")
        return dir
    }

    private TestFile getGcFile() {
        return cacheDir.file("gc.properties")
    }

            dir.mkdirs()
        }

        when:
        succeeds("help")

        then:
        if (expectedState == "marked") {
            assert new File(dir, "CACHEDIR.TAG").exists()
        } else {
            assert !new File(dir, "CACHEDIR.TAG").exists()
        }

        where:
        directory       | markingStrategy | createDir | expectedState

        isFoundInDirectory(cacheDir, "sensitive_value1".getBytes()) == !enabled
        isFoundInDirectory(cacheDir, "sensitive_value2".getBytes()) == !enabled
        isFoundInDirectory(cacheDir, "sensitive_env_var_value".getBytes()) == !enabled
        isFoundInDirectory(cacheDir, "sensitive_value3".getBytes()) == !enabled
        isFoundInDirectory(cacheDir, "sensitive_convention".getBytes()) == !enabled

class AbstractCacheCleanupTest extends Specification {
    @Rule TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    def cacheDir = temporaryFolder.file("cache-dir").createDir()
    def cleanableStore = Mock(CleanableStore) {
        getBaseDir() >> cacheDir
        getReservedCacheFiles() >> []
    }
    def progressMonitor = Mock(CleanupProgressMonitor)
    def deletedFiles = []

    String cacheDir = temporaryFolder.file("cache-dir").createDir().absoluteFile.toURI().toString()
    def localBuildCache = new TestBuildCache(new File(new URI(cacheDir).path))

    def "can configure with settings.gradle"() {
        settingsFile << """
            buildCache {
                local {
                    directory = '$cacheDir'
                }
            }
        """

    }

    Set<TestFile> typeHierarchyAnalysisOutputs(String artifactName, File cacheDir = getCacheDir()) {
        return analyzeOutputs(artifactName, TYPE_HIERARCHY_ANALYSIS_FILE_NAME, cacheDir)
    }

    TestFile typeHierarchyAnalysisOutput(String artifactName, File cacheDir = getCacheDir()) {
        def analysis = typeHierarchyAnalysisOutputs(artifactName, cacheDir)
        if (analysis.size() == 1) {
            return analysis.first()

        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 {