@Override
    public SortedSet<GradleVersion> getUsedGradleVersions() {
        SortedSet<GradleVersion> result = new TreeSet<>();
        for (VersionSpecificCacheDirectory cacheDir : directoryScanner.getExistingDirectories()) {
            result.add(cacheDir.getVersion());
        }
        return result;
    }

 * </p>
 *
 * @since 8.1
 */
@Incubating
public interface MarkingStrategy {
    /**
     * Marking strategy that marks the cache directory with a {@code CACHEDIR.TAG} file.
     *
     * @see <a href="https://bford.info/cachedir/">Cache Directory Tagging Specification</a>
     */
    MarkingStrategy CACHEDIR_TAG = new CacheDirTagMarkingStrategy();

    /**

        then:
        cached()
        localCache.hasCacheEntry(cacheKey)

        when:
        settingsFile << """
            buildCache.remote.enabled = false
        """
        assert remoteCache.cacheDir.deleteDir()
        execute()

        then:
        cached()
    }

    def "remote loads are not cached locally if local cache is #state"() {
        given:
        settingsFile << """

        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)

			cacheDir := filepath.Join(homedir.HomeDir(), ".kube", "cache")

			httpCacheDir := filepath.Join(cacheDir, "http")
			discoveryCacheDir := computeDiscoverCacheDir(filepath.Join(cacheDir, "discovery"), restConfig.Host)

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

                outputFile = new File(buildDir, "output")
            }
            """
        def cacheDir = file("task-output-cache")
        settingsFile << """
            buildCache {
                local {
                    directory = "${TextUtil.escapeString(cacheDir.absolutePath)}"
                }
            }
        """
        file("gradle.properties") << """

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

import org.gradle.internal.snapshot.FileSystemLocationSnapshot;

import java.io.File;

public interface ClasspathFileTransformer {
    File transform(File source, FileSystemLocationSnapshot sourceSnapshot, File cacheDir, InstrumentationTypeRegistry typeRegistry);

    ClasspathFileHasher getFileHasher();