def hashCode = "123456"
    def cacheKey = Stub(BuildCacheKey) {
        getHashCode() >> hashCode
    }
    def reader = Mock(BuildCacheEntryReader)
    def writer = Mock(BuildCacheEntryWriter)
    def data = [1, 2, 3] as byte[]

    def "can read from map"() {
        when:
        def found = cache.load(cacheKey, reader)
        then:
        found

    }

    private void logCacheKey(BuildCacheKey cacheKey, UnitOfWork work) {
        if (emitDebugLogging) {
            LOGGER.warn("Build cache key for {} is {}", work.getDisplayName(), cacheKey.getHashCode());
        } else {
            LOGGER.info("Build cache key for {} is {}", work.getDisplayName(), cacheKey.getHashCode());
        }
    }

        _ * previousExecutionState.cacheKey >> cacheKey
        _ * context.validationProblems >> ImmutableList.of()
        1 * delegate.execute(work, { CachingContext context ->
            def buildCacheKey = context.cachingState.cacheKeyCalculatedState.get().key
            buildCacheKey.hashCode == cacheKey.toString()
        }) >> delegateResult

        where:

        assertNotSame(lr1, lr2);
        assertNotSame(rr1, rr2);

        DefaultMavenMetadataCache.CacheKey k1 =
                new DefaultMavenMetadataCache.CacheKey(a1, false, lr1, Collections.singletonList(rr1));
        DefaultMavenMetadataCache.CacheKey k2 =
                new DefaultMavenMetadataCache.CacheKey(a2, false, lr2, Collections.singletonList(rr2));

        assertEquals(k1.hashCode(), k2.hashCode());
    }

        @Override
        public boolean equals(Object o) {
            if (o == this) {
                return true;
            }
            if (!(o instanceof CacheKey)) {
                return false;
            }
            CacheKey that = (CacheKey) o;
            return Objects.equals(groupId, that.groupId)
                    && Objects.equals(artifactId, that.artifactId)

        private final ExecutionOutputState afterExecutionOutputState;
        private final HashCode cacheKey;

        public DefaultAfterExecutionState(HashCode cacheKey, BeforeExecutionState beforeExecutionState, ExecutionOutputState afterExecutionOutputState) {
            this.cacheKey = cacheKey;
            this.beforeExecutionState = beforeExecutionState;
            this.afterExecutionOutputState = afterExecutionOutputState;

    }

    @Override
    public final CachingState createCachingState(BeforeExecutionState beforeExecutionState, HashCode cacheKey, ImmutableList<CachingDisabledReason> cachingDisabledReasons) {
        if (cachingDisabledReasons.isEmpty()) {
            return CachingState.enabled(new DefaultBuildCacheKey(cacheKey), beforeExecutionState);
        } else {
            cachingDisabledReasons.forEach(reason ->

	}

	cacheKey := cacheKeyType{signerName: signerName, labelSelector: selector.String()}

	if lsLen := len(cacheKey.labelSelector); lsLen > maxLabelSelectorLength {
		return nil, fmt.Errorf("label selector length (%d) is larger than %d", lsLen, maxLabelSelectorLength)
	}

	if cachedAnchors, ok := m.normalizationCache.Get(cacheKey); ok {
		return cachedAnchors.([]byte), nil
	}

        }
    }

    public <T> void set(ModelType<T> type, ModelSchema<T> schema) {
        WeakClassSet cacheKey = WeakClassSet.of(type);
        Map<ModelType<?>, ModelSchema<?>> typeCache = cache.get(cacheKey);
        if (typeCache == null) {
            typeCache = new HashMap<>();
            cache.put(cacheKey, typeCache);
        }
        typeCache.put(type, schema);
    }

    public long size() {
        cleanUp();

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