def storeOp = cacheOperations.getOnlyLocalStoreOperationForTask(":t")

        def cacheKey = localMissLoadOp.details.cacheKey
        cacheKey != null
        def archiveSize = localCache.getCacheEntry(cacheKey.toString()).bytes.length

        !localMissLoadOp.result.hit

        packOp.details.cacheKey == cacheKey

        packOp.result.archiveSize == archiveSize
        packOp.result.archiveEntryCount == 5

// files as needed, as the resources change.
type Cache struct {
	mu sync.Mutex

	discriminator int64
	resources     map[CacheKey]*resourceState
	dir           string
}

// CacheKey is a key representing a tracked Yaml based resource.
type CacheKey struct {
	group     string
	kind      string
	namespace string
	name      string
}

type resourceState struct {
	part Part
	file string

                }
                if (o == null || getClass() != o.getClass()) {
                    return false;
                }
                CacheKey cacheKey = (CacheKey) o;
                return variantAttributes.equals(cacheKey.variantAttributes) && requested.equals(cacheKey.requested);
            }

            @Override
            public int hashCode() {
                return hashCode;
            }
        }

    }

    void deleteCacheEntry(String cacheKey) {
        def entry = getTestFileCacheEntry(cacheKey)
        if (entry.file.exists()) {
            entry.file.deleteDir()
        }
    }

    boolean hasCacheEntry(String cacheKey) {
        return getTestFileCacheEntry(cacheKey).file.exists()
    }

    TestCacheEntry getCacheEntry(String cacheKey) {
        def cacheEntry = getTestFileCacheEntry(cacheKey)

        """
        succeeds("customTask")

        then:
        def cacheKey = cacheOperations.getCacheKeyForTask(":customTask")
        remoteCache.hasCacheEntry(cacheKey)

        when:
        def cacheEntry = remoteCache.getCacheEntry(cacheKey)
        cacheEntry.text = "corrupt"
        localCache.deleteCacheEntry(cacheKey)

        then:
        fails("clean", "customTask")

    public Key createKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session) {
        return keys.computeIfAbsent(new CacheKey(plugin, repositories, session), k -> k);
    }

    public PluginDescriptor get(Key cacheKey) {
        return clone(descriptors.get(cacheKey));
    }

    @Override
    public PluginDescriptor get(Key key, PluginDescriptorSupplier supplier)

    }

    protected CacheKey newCacheKey(
            Artifact artifact,
            boolean resolveManagedVersions,
            ArtifactRepository localRepository,
            List<ArtifactRepository> remoteRepositories) {
        return new CacheKey(artifact, resolveManagedVersions, localRepository, remoteRepositories);
    }

    protected void put(CacheKey cacheKey, ResolutionGroup result) {

        public boolean equals(Object o) {
            if (o == this) {
                return true;
            }

            if (!(o instanceof CacheKey)) {
                return false;
            }

            CacheKey that = (CacheKey) o;

            return CacheUtils.pluginEquals(plugin, that.plugin)
                    && Objects.equals(workspace, that.workspace)

                return false;
            }
            CacheKey cacheKey = (CacheKey) o;
            return Objects.equal(backingStateType, cacheKey.backingStateType)
                && Objects.equal(schema, cacheKey.schema)
                && Objects.equal(structBindings.getDelegateSchema(), cacheKey.structBindings.getDelegateSchema());
        }

        @Override
        public int hashCode() {

    /**
     * CacheKey
     */
    protected static class CacheKey implements Key {

        private final List<File> files;

        private final List<Long> timestamps;

        private final List<Long> sizes;

        private final List<String> ids;

        private final int hashCode;

        public CacheKey(List<Artifact> extensionArtifacts) {