}

    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)

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

    private final OriginMetadata originMetadata;
    private final boolean successful;
    private final HashCode cacheKey;

    public DefaultPreviousExecutionState(
        OriginMetadata originMetadata,
        HashCode cacheKey,
        ImplementationSnapshot implementation,
        ImmutableList<ImplementationSnapshot> additionalImplementations,

class StoreExecutionStateStepTest extends StepSpec<IncrementalCachingContext> implements SnapshotterFixture {
    def executionHistoryStore = Mock(ExecutionHistoryStore)
    def cacheKey = TestHashCodes.hashCodeFrom(1234)

    def originMetadata = Mock(OriginMetadata)
    def beforeExecutionState = Stub(BeforeExecutionState) {

        then:
        executed()
        localCache.empty
        def cacheKey = cacheOperations.getCacheKeyForTask(":t")
        remoteCache.hasCacheEntry(cacheKey)

        when:
        settingsFile << """
            buildCache.local.push = true
        """
        execute()

        then:
        cached()
        localCache.hasCacheEntry(cacheKey)

        when:
        settingsFile << """

    }

    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());
    }