return withExclusiveAccessToCache(baseDir) { cacheDir ->
                action(ReadableLayout(cacheDir))
            }
        }

        override fun <T> useForStore(action: (Layout) -> T): T =
            withExclusiveAccessToCache(baseDir) { cacheDir ->
                // TODO GlobalCache require(!cacheDir.isDirectory)
                Files.createDirectories(cacheDir.toPath())

        this.webapp.setInitParameter("org.eclipse.jetty.servlet.Default.useFileMappedBuffer", "false")
    }

    TestFile getCacheDir() {
        Preconditions.checkNotNull(cacheDir)
    }

    List<TestFile> listCacheFiles() {
        cacheDir.listFiles().findAll { it.name ==~ /\p{XDigit}{${Hashing.defaultFunction().hexDigits}}/ }.sort()
    }

    void deleteCacheFiles() {
        listCacheFiles().each { it.delete() }
    }

    @Override
    public PersistentCache open(File cacheDir, String displayName, Map<String, ?> properties, LockOptions lockOptions, @Nullable Consumer<? super PersistentCache> initializer, @Nullable CacheCleanupStrategy cacheCleanupStrategy) throws CacheOpenException {
        GFileUtils.mkdirs(cacheDir);

        )
    }

    static class GradleDistDirs {
        private final TestFile cacheDir
        private final TestFile distDir
        private final TestFile customDistDir

        GradleDistDirs(TestFile cacheDir, TestFile distDir, TestFile customDistDir) {
            this.cacheDir = cacheDir
            this.distDir = distDir
            this.customDistDir = customDistDir
        }

class DirectoryBuildCacheTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    def cacheDir = temporaryFolder.createDir("cache")
    def persistentCache = Mock(PersistentCache) {
        getBaseDir() >> cacheDir
        withFileLock(_) >> { Runnable r -> r.run() }
    }
    def fileAccessTracker = Mock(FileAccessTracker)

        }

        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

    }

    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));