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

	config.QPS = f.discoveryQPS

	cacheDir := getDefaultCacheDir()

	// retrieve a user-provided value for the "cache-dir"
	// override httpCacheDir and discoveryCacheDir if user-value is given.
	// user-provided value has higher precedence than default
	// and KUBECACHEDIR environment variable.
	if f.CacheDir != nil && *f.CacheDir != "" && *f.CacheDir != getDefaultCacheDir() {
		cacheDir = *f.CacheDir
	}

    @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()) {

    @Nullable
    private static File validateReadOnlyCache(DocumentationRegistry documentationRegistry, File cacheDir) {
        if (!cacheDir.exists()) {
            LOGGER.warn("The read-only dependency cache is disabled because of a configuration problem:");
            LOGGER.warn("The " + READONLY_CACHE_ENV_VAR + " environment variable was set to " + cacheDir + " which doesn't exist!");
            return null;
        }

class DefaultPersistentDirectoryStoreConcurrencyTest extends ConcurrentSpec {

    @Rule
    def TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def cacheDir = tmpDir.file("dir")
    def metaDataProvider = new DefaultProcessMetaDataProvider(NativeServicesTestFixture.getInstance().get(ProcessEnvironment));

        this.globalCacheLocations = globalCacheLocations;
    }

    @Override
    public File transform(File source, FileSystemLocationSnapshot sourceSnapshot, File cacheDir, InstrumentationTypeRegistry typeRegistry) {
        // Copy files into the cache, if it is possible that loading the file in a ClassLoader may cause locking problems if the file is deleted