Try<Execution> execution = Try.successful(Execution.skipped(UP_TO_DATE, work));
        return new UpToDateResult(
            previousExecutionState.getOriginMetadata().getExecutionTime(),
            execution,
            executionOutputState,
            ImmutableList.of(),
            previousExecutionState.getOriginMetadata()
        );
    }

    }

    // TODO: Move this logic in a step around IdentityCacheStep
    private <T> void emitExecuteDeferredProgressDetails(UnitOfWork work, Identity identity, IdentityCacheResult<T> cacheResult) {
        cacheResult.getOriginMetadata().ifPresent(originMetadata ->
            progressEventEmitter.emitNowIfCurrent(new DefaultExecuteDeferredWorkProgressDetails(
                work.getBuildOperationWorkType().orElse(null),
                identity,

        then:
        1 * immutableWorkspaceMetadataStore.loadWorkspaceMetadata(immutableWorkspace) >> Stub(ImmutableWorkspaceMetadata) {
            getOriginMetadata() >> delegateOriginMetadata
            getOutputPropertyHashes() >> ImmutableListMultimap.of("output", outputFileSnapshot.hash)
        }
        0 * _
    }

        then:
        1 * delegateResult.afterExecutionOutputState >> Optional.of(Mock(AfterExecutionState) {
            _ * getOutputFilesProducedByWork() >> this.outputFilesProducedByWork
            _ * getOriginMetadata() >> originMetadata
        })

        _ * context.cachingState >> CachingState.enabled(new DefaultBuildCacheKey(cacheKey), beforeExecutionState)
        _ * delegateResult.execution >> Try.successful(Mock(Execution))

            return afterExecutionOutputState.getOutputFilesProducedByWork();
        }

        @Override
        public OriginMetadata getOriginMetadata() {
            return afterExecutionOutputState.getOriginMetadata();
        }

        @Override
        public boolean isReused() {
            return afterExecutionOutputState.isReused();
        }
    }

        this.originMetadata = originMetadata;
        this.outputPropertyHashes = outputPropertyHashes;
    }

    public OriginMetadata getOriginMetadata() {
        return originMetadata;
    }

    public ImmutableListMultimap<String, HashCode> getOutputPropertyHashes() {
        return outputPropertyHashes;
    }

    @Override

     */
    ImmutableSortedMap<String, FileSystemSnapshot> getOutputFilesProducedByWork();

    /**
     * The origin metadata of the outputs captured.
     */
    OriginMetadata getOriginMetadata();

    /**
     * Whether the outputs come from a previous execution.
     */
    boolean isReused();

    }

    @Override
    public ImmutableSortedMap<String, FileSystemSnapshot> getOutputFilesProducedByWork() {
        return outputFilesProducedByWork;
    }

    @Override
    public OriginMetadata getOriginMetadata() {
        return originMetadata;
    }

    @Override
    public boolean isSuccessful() {
        return successful;
    }

    @Override
    public boolean isReused() {
        return true;

import org.gradle.caching.internal.origin.OriginMetadata;
import org.gradle.internal.snapshot.FileSystemSnapshot;

public interface BuildCacheLoadResult {
    long getArtifactEntryCount();

    OriginMetadata getOriginMetadata();

    ImmutableSortedMap<String, FileSystemSnapshot> getResultingSnapshots();

            this.originMetadata = originMetadata;
            this.entries = entries;
            this.snapshots = snapshots;
        }

        public OriginMetadata getOriginMetadata() {
            return originMetadata;
        }

        public long getEntries() {
            return entries;
        }

        public Map<String, FileSystemLocationSnapshot> getSnapshots() {