String cacheKey = versionCacheKey(repository, version);
        return checkoutDirs.get(cacheKey);
    }

    public void putWorkingDirForRevision(VersionControlRepositoryConnection repository, VersionRef version, File dir) {
        String cacheKey = versionCacheKey(repository, version);
        checkoutDirs.put(cacheKey, dir);
    }

    @Nullable

    }

    private AfterExecutionResult executeWithCache(UnitOfWork work, C context, BuildCacheKey cacheKey) {
        CacheableWork cacheableWork = new CacheableWork(context.getIdentity().getUniqueId(), context.getWorkspace(), work);
        return Try.ofFailable(() -> work.isAllowedToLoadFromCache()
                ? tryLoadingFromCache(cacheKey, cacheableWork)
                : Optional.<BuildCacheLoadResult>empty()
            )

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

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

                return false;
            }

            CacheKey cacheKey = (CacheKey) o;

            if (!filePath.equals(cacheKey.filePath)) {
                return false;
            }
            if (!signaturePath.equals(cacheKey.signaturePath)) {
                return false;
            }
            if (!trustedKeys.equals(cacheKey.trustedKeys)) {
                return false;
            }

    private final BuildCacheKey cacheKey;
    private final long archiveSize;

    public StoreOperationDetails(BuildCacheKey cacheKey, long archiveSize) {
        this.cacheKey = cacheKey;
        this.archiveSize = archiveSize;
    }

    @Override
    public String getCacheKey() {
        return cacheKey.getHashCode();
    }

    @Override
    public long getArchiveSize() {

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

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

@Named
@Singleton
public class DefaultProjectRealmCache implements ProjectRealmCache, Disposable {
    /**
     * CacheKey
     */
    protected static class CacheKey implements Key {

        private final List<? extends ClassRealm> extensionRealms;

        private final int hashCode;

        public CacheKey(List<? extends ClassRealm> extensionRealms) {
            this.extensionRealms =

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

    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