import org.gradle.internal.hash.HashCode;

/**
 * Captures the state a {@link org.gradle.internal.execution.UnitOfWork} after the previous execution has finished.
 */
public interface PreviousExecutionState extends ExecutionInputState, ExecutionOutputState {

    /**
     * Returns the cache key from the previous execution.
     */
    HashCode getCacheKey();

    /**
     * {@inheritDoc}
     */

        when:
        step.execute(work, context)
        then:
        _ * context.previousExecutionState >> Optional.of(previousExecutionState)
        1 * previousExecutionState.inputProperties >> ImmutableSortedMap.of()
        1 * previousExecutionState.inputFileProperties >> ImmutableSortedMap.of()
        1 * previousExecutionState.outputFilesProducedByWork >> previousOutputSnapshots

        _ * context.previousExecutionState >> Optional.empty()

        then:
        interaction { expectStore(false, outputFilesProducedByWork) }
        0 * _
    }

    def "output snapshots are stored after failed execution with changed outputs"() {
        def previousExecutionState = Mock(PreviousExecutionState)

        when:
        def result = step.execute(work, context)

        }
        @SuppressWarnings("OptionalGetWithoutIsPresent")
        PreviousExecutionState previousExecutionState = context.getPreviousExecutionState().get();
        ExecutionOutputState executionOutputState = new DefaultExecutionOutputState(true, previousExecutionState.getOutputFilesProducedByWork(), previousExecutionState.getOriginMetadata(), true);

        _ * context.beforeExecutionState >> Optional.of(beforeExecutionState)
        _ * executionStateChanges.changeDescriptions >> ImmutableList.of()

        _ * context.previousExecutionState >> Optional.of(previousExecutionState)
        _ * previousExecutionState.cacheKey >> cacheKey
        _ * context.validationProblems >> ImmutableList.of()
        1 * delegate.execute(work, { CachingContext context ->

        _ * context.previousExecutionState >> Optional.of(previousExecutionState)
        _ * context.validationProblems >> ImmutableList.of(Mock(Problem))
        _ * context.previousExecutionState >> Optional.empty()
        0 * _
    }

    def "provides input file changes when history is available"() {
        def previousExecutionState = Mock(PreviousExecutionState)
        def changes = Mock(ExecutionStateChanges)

import static com.google.common.collect.Maps.transformValues;

public class TestExecutionHistoryStore implements ExecutionHistoryStore {

    private final Map<String, PreviousExecutionState> executionHistory = new HashMap<>();

    @Override
    public Optional<PreviousExecutionState> load(String key) {
        return Optional.ofNullable(executionHistory.get(key));
    }

    @Override

        }

        Optional<PreviousExecutionState> previousExecutionState = context.getPreviousExecutionState();
        ImmutableSortedMap<String, ValueSnapshot> previousInputPropertySnapshots = previousExecutionState
            .map(ExecutionInputState::getInputProperties)
            .orElse(ImmutableSortedMap.of());

import org.gradle.internal.execution.history.AfterExecutionState;
import org.gradle.internal.execution.history.ExecutionHistoryStore;
import org.gradle.internal.execution.history.PreviousExecutionState;
import org.gradle.internal.fingerprint.CurrentFileCollectionFingerprint;
import org.gradle.internal.fingerprint.FileCollectionFingerprint;
import org.gradle.internal.hash.ClassLoaderHierarchyHasher;

class ExecuteStepTest extends StepSpec<ChangingOutputsContext> {
    def workspace = Mock(File)
    def previousOutputs = ImmutableSortedMap.of()
    def previousExecutionState = Stub(PreviousExecutionState) {
        getOutputFilesProducedByWork() >> previousOutputs
    }

    def step = new ExecuteStep<>(new TestBuildOperationRunner())
    def inputChanges = Mock(InputChangesInternal)