void "cache handles manual deletion of cached artifacts"() {
        given:
        def module = ivyHttpRepo.module('group', 'projectA', '1.2').publish()

        def cacheDir = getUserHomeCacheDir().toURI()

        and:
        buildFile << """
repositories {
    ivy { url "${ivyHttpRepo.uri}" }
}
configurations { compile }
dependencies { compile 'group:projectA:1.2' }

        buildFile << defineCacheableTask()
        withBuildCache()
        succeeds "cacheable", "--info"

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

    def "cache entry contains expected contents"() {
        buildFile << defineCacheableTask()
        when:
        withBuildCache().run("cacheable")
        then:

        settingsFile << "rootProject.buildFileName = '$defaultBuildFileName'"

        file("buildSrc/settings.gradle.kts") << """
            buildCache {
                local {
                    directory = "${cacheDir.absoluteFile.toURI()}"
                    isPush = true
                }
            }
        """
    }

    @Requires(IntegTestPreconditions.NotParallelExecutor)
    @LeaksFileHandles

            val compilationClassPath = targetScopeClassPath + accessorsClassPath
            val scriptTemplateId = programId.templateId
            val sourceHash = programId.sourceHash

            val cacheDir =
                host.cachedDirFor(
                    scriptHost,
                    programId,
                    compilationClassPath,
                    accessorsClassPath
                ) { outputDir ->

        given:
        def cacheDir = createDir("cache-dir")

        def firstDir = createDir("first-location")
        firstDir.file("settings.gradle") << """
            rootProject.name = "test"
            buildCache {
                local {
                    directory = file("../${cacheDir.name}")
                }
            }
        """

                dependsOn tasks.named('update1'), tasks.named('update2')
                doLast {
                    def cacheDir = file("build/tmp/.cache/expanded")
                    assert cacheDir.list().size() == 1 // There should only be 1 file here, the single unzipped cache entry
                    cacheDir.eachFile(groovy.io.FileType.DIRECTORIES) { File f ->
                        assert f.name.startsWith('tar_')
                    }

====

[[dir:gradle_user_home:cache_marking]]
=== Cache marking
Beginning with Gradle version 8.1, Gradle supports marking caches with a `CACHEDIR.TAG` file.

It follows the format described in https://bford.info/cachedir/[the Cache Directory Tagging Specification].
The purpose of this file is to allow tools to identify the directories that do not need to be searched or backed up.

    final File lockFile = tmpDir.file('lock.bin')
    final File cacheDir = tmpDir.file('caches')
    final FileLock lock = Mock()
    final BTreePersistentIndexedCache<String, Integer> backingCache = Mock()

    private DefaultCacheCoordinator newAccess(FileLockManager.LockMode lockMode) {
        new DefaultCacheCoordinator("<display-name>", lockFile, mode(lockMode), cacheDir, lockManager, initializationAction, cleanupExecutor, executorFactory) {

            }
        }
        settingsFile << withHttpBuildCacheServer()

        when:
        withBuildCache().run "customTask"

        then:
        count == 1
        httpBuildCacheServer.cacheDir.listFiles().size() == 1
    }

    def "transient error on read is retried"() {
        given:
        settingsFile << withHttpBuildCacheServer()
        withBuildCache().run "customTask"

    }

    @Override
    public GradleExecuter withReadOnlyCacheDir(File cacheDir) {
        return withReadOnlyCacheDir(cacheDir.getAbsolutePath());
    }

    @Override
    public GradleExecuter withReadOnlyCacheDir(String cacheDir) {
        environmentVars.put(ArtifactCachesProvider.READONLY_CACHE_ENV_VAR, cacheDir);
        return this;
    }

    @Override