}

    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;

    def buildCacheController = Mock(BuildCacheController)

    def beforeExecutionState = Stub(BeforeExecutionState)

    def cacheKeyHashCode = "30a042b90a"
    def cacheKey = Stub(BuildCacheKey) {
        hashCode >> cacheKeyHashCode
    }
    def loadMetadata = Mock(BuildCacheLoadResult)
    def deleter = Mock(Deleter)
    def fileSystemAccess = Mock(FileSystemAccess)

    }

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

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