ProjectArtifactsCache.Key cacheKey = projectArtifactsCache.createKey(
                project, scopesToCollect, scopesToResolve, aggregating, session.getRepositorySession());

        ProjectArtifactsCache.CacheRecord recordArtifacts;
        recordArtifacts = projectArtifactsCache.get(cacheKey);
        if (recordArtifacts == null) {
            synchronized (cacheKey) {

        def packOperations = getPackOperationsForTask(taskPath)
        return packOperations.empty ? null : packOperations[0].details["cacheKey"]
    }

    String getCacheKeyForTask(String taskPath) {
        def cacheKey = getCacheKeyForTaskOrNull(taskPath)
        assert cacheKey != null
        return cacheKey
    }

    void assertStoredToLocalCacheForTask(String taskPath) {

        metadata.gradleVersion == GradleVersion.current().version
    }

    private Properties readMetadata() {
        def cacheKey = cacheOperations.getCacheKeyForTask(":compileJava")
        assert localCache.hasCacheEntry(cacheKey)
        def cacheEntry = localCache.getCacheEntry(cacheKey)

        // Must rename to "*.tgz" for unpacking to work
        def tgzCacheEntry = temporaryFolder.file("cache.tgz")

    private val fileAccessTimeJournal: FileAccessTimeJournal,
    private val fileSystem: FileSystem
) : Stoppable {
    fun forKey(cacheKey: String): ConfigurationCacheStateStore {
        return StoreImpl(cache.baseDirFor(cacheKey))
    }

    abstract class Layout {
        abstract fun fileForRead(stateType: StateType): ConfigurationCacheStateFile

        buildCacheController.store(
            cacheKey,
            sandboxEntity,
            ImmutableMap.of("output", producedOutputSnapshot),
            Duration.ofSeconds(10));

        // Load the entity from the cache
        BuildCacheLoadResult loadResult = buildCacheController.load(cacheKey, targetEntity)
            .orElseThrow(() -> new RuntimeException("Should have been a hit"));

            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            CacheKey cacheKey = (CacheKey) o;
            return Objects.equal(publicType, cacheKey.publicType)
                && Objects.equal(viewTypes, cacheKey.viewTypes)
                && Objects.equal(delegateType, cacheKey.delegateType);
        }

        @Override
        public int hashCode() {

 */
@ServiceScope(Scope.Gradle.class)
public interface BuildCacheController extends Closeable {

    boolean isEnabled();

    Optional<BuildCacheLoadResult> load(BuildCacheKey cacheKey, CacheableEntity cacheableEntity);

    void store(BuildCacheKey cacheKey, CacheableEntity entity, Map<String, FileSystemSnapshot> snapshots, Duration executionTime);

    public boolean isEnabled() {
        return false;
    }

    @Override
    public Optional<BuildCacheLoadResult> load(BuildCacheKey cacheKey, CacheableEntity cacheableEntity) {
        return Optional.empty();
    }

    @Override
    public void store(BuildCacheKey cacheKey, CacheableEntity entity, Map<String, FileSystemSnapshot> snapshots, Duration executionTime) {

    }

    @Override
    public void close() {

	g := NewWithT(t)
	d := t.TempDir()
	t.Logf("Test Dir: %q", d)

	c := NewCache(d)

	keys, err := c.Apply(gateway)
	g.Expect(err).To(BeNil())
	g.Expect(keys).To(HaveLen(1))
	expected := CacheKey{
		group:     "networking.istio.io",
		kind:      "Gateway",
		namespace: "",
		name:      "some-ingress",
	}
	g.Expect(keys[0]).To(Equal(expected))
	key1 := keys[0]

	file := c.GetFileFor(keys[0])

		ce.resourceVersionByResource[key.resourceName] = key.resourceVersion
	}
	return needChecksumUpdate
}

// addEntry adds a wasmModule to cache with cacheKey, writes the module to the local file system,
// and returns the created entry.
func (c *LocalFileCache) addEntry(key cacheKey, wasmModule []byte) (*cacheEntry, error) {
	c.mux.Lock()
	defer c.mux.Unlock()
	needChecksumUpdate := c.updateChecksum(key)