*/
    public static void tryMarkCacheDirectoryByTag(Path dir) {
        if (!Files.isDirectory(dir)) {
            return;
        }
        Path cacheDirTag = dir.resolve("CACHEDIR.TAG");
        OutputStream stream;
        try {
            stream = Files.newOutputStream(cacheDirTag, StandardOpenOption.CREATE_NEW);
        } catch (IOException e) {

        };
    }

    @Override
    public File transform(File source, FileSystemLocationSnapshot sourceSnapshot, File cacheDir, InstrumentationTypeRegistry typeRegistry) {
        String destDirName = hashOf(sourceSnapshot);
        File destDir = new File(cacheDir, destDirName);
        String destFileName = source.getName();
        File receipt = new File(destDir, destFileName + ".receipt");

		MinimizeTimeout: minimizeTimeout,
		MinimizeLimit:   minimizeLimit,
		Parallel:        parallel,
		Seed:            seed,
		Types:           types,
		CorpusDir:       corpusDir,
		CacheDir:        cacheDir,
	})
	if err == ctx.Err() {
		return nil
	}
	return err
}

func (TestDeps) RunFuzzWorker(fn func(fuzz.CorpusEntry) error) error {

                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 {

            accessorsClassPath: ClassPath,
            initializer: (File) -> Unit
        ): File = baseCacheDir.resolve(programId.sourceHash.toString()).resolve(programId.templateId).also { cacheDir ->
            cacheDir.mkdirs()
            initializer(cacheDir)
        }

        override fun compilationClassPathOf(classLoaderScope: ClassLoaderScope): ClassPath =
            scriptCompilationClassPath

        settingsFile.text = """
            buildCache {
                local {
                    directory = '${localCache.cacheDir.toURI()}'
                }
                remote(DirectoryBuildCache) {
                    directory = '${remoteCache.cacheDir.toURI()}'
                }
            }
        """.stripIndent()

        when:
        withBuildCache().run cacheableTask

### Download

```kotlin
testImplementation("com.squareup.okhttp3:okhttp-dnsoverhttps:4.12.0")
```

### Usage

```
  val appCache = Cache(File("cacheDir", "okhttpcache"), 10 * 1024 * 1024)
  val bootstrapClient = OkHttpClient.Builder().cache(appCache).build()

  val dns = DnsOverHttps.Builder().client(bootstrapClient)
    .url("https://dns.google/dns-query".toHttpUrl())

        }
    }

    def localCacheConfiguration() {
        initIfNeeded()
        buildCache.localCacheConfiguration()
    }

    TestFile getCacheDir() {
        initIfNeeded()
        buildCache.cacheDir
    }

    TestFile gcFile() {
        initIfNeeded()
        buildCache.gcFile()
    }

    List<TestFile> listCacheFiles() {
        initIfNeeded()
        buildCache.listCacheFiles()
    }

     */
    private simulateAnotherInitializationOfAlreadyInitializedWorkerClasspathCache() {
        def cacheDir = file("user-home/caches/${distribution.version.version}/workerMain")
        def countingInitAction = new CacheInitializationAction() {
            def count = 0

            boolean requiresInitialization(FileLock fileLock) {

        val firstLocation = "first-location"
        val secondLocation = "second-location"
        val cacheDir = newDir("cache-dir")

        withDefaultSettingsIn(firstLocation).appendText(
            """
            rootProject.name = "test"
            buildCache {
                local {
                    directory = file("${cacheDir.normalisedPath}")
                }
            }
            """
        )