doCopy(metadataCacheDir, cachePath, CacheLayout.MODULES)

        roCacheDir
    }

    private void doCopy(File cacheDir, Path cachePath, CacheLayout entry) {
        if (cacheDir.exists()) {
            Files.move(cacheDir.toPath(), cachePath.resolve(entry.key))
        }
    }

    void assertInReadOnlyCache(File file) {
        boolean inCache = isInRoCache(file)

        output.contains("The remote build cache was disabled during the build due to errors.")
    }

    def "storing to cache does follow method preserving redirects"() {
        given:
        httpBuildCacheServer.cacheDir.createDir("redirect")
        httpBuildCacheServer.addResponder { req, res ->
            if (!req.requestURI.startsWith("/redirect")) {
                res.setHeader("location", "redirect$req.requestURI")

        withBuildCache().run "jar"
        then:
        skipped ":compileJava"
    }

    def "cached tasks are executed with #rerunMethod"() {
        def taskPath = ":compileJava"

        expect:
        cacheDir.listFiles() as List == []
        buildFile << """
            def upToDate = providers.gradleProperty('upToDateWhenFalse')
            tasks.withType(JavaCompile).configureEach { it.outputs.upToDateWhen { !upToDate.present } }

		;;
	"wasmer")
		exec wasmer run --dir=/ --env PWD="$PWD" --env PATH="$PATH" ${GOWASIRUNTIMEARGS:-} "$1" -- "${@:2}"
		;;
	"wazero")
		exec wazero run -mount /:/ -env-inherit -cachedir "${TMPDIR:-/tmp}"/wazero ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
		;;
	"wasmtime" | "")
		exec wasmtime run --dir=/ --env PWD="$PWD" --env PATH="$PATH" -W max-wasm-stack=1048576 ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
		;;
	*)

        def buildOp = operations.only("Clean up ${getBuildCacheName()} ($cacheDir)")
        buildOp.details.cacheLocation == cacheDir
        assert gcFile().lastModified() > lastCleanupCheck
    }

    void assertCacheWasNotCleanedUpSince(long lastCleanupCheck) {
        operations.none("Clean up ${getBuildCacheName()} ($cacheDir)")
        assert gcFile().lastModified() == lastCleanupCheck
    }

    @Override

        };
    }

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

        }
    }

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

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

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

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

        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}")
                }
            }
            """
        )