import java.util.Optional;

public class PreviousExecutionContext extends WorkspaceContext {
    private final PreviousExecutionState previousExecutionState;

    public PreviousExecutionContext(WorkspaceContext parent, @Nullable PreviousExecutionState previousExecutionState) {
        super(parent);
        this.previousExecutionState = previousExecutionState;
    }

    protected PreviousExecutionContext(PreviousExecutionContext parent) {

        then:
        result == delegateResult
        1 * delegate.execute(work, _) >> { UnitOfWork work, PreviousExecutionContext previousExecutionContext ->
            assert previousExecutionContext.previousExecutionState.get() == previousExecutionState
            return delegateResult
        }

        then:

public class LoadPreviousExecutionStateStep<C extends WorkspaceContext, R extends AfterExecutionResult> implements Step<C, R> {
    private final Step<? super PreviousExecutionContext, ? extends R> delegate;

    public LoadPreviousExecutionStateStep(Step<? super PreviousExecutionContext, ? extends R> delegate) {
        this.delegate = delegate;
    }

    @Override
    public R execute(UnitOfWork work, C context) {

import org.gradle.internal.execution.UnitOfWork

class CaptureNonIncrementalStateBeforeExecutionStepTest extends AbstractCaptureStateBeforeExecutionStepTest<PreviousExecutionContext> {

    AbstractCaptureStateBeforeExecutionStep<PreviousExecutionContext, CachingResult> step
        = new CaptureNonIncrementalStateBeforeExecutionStep(buildOperationRunner, classloaderHierarchyHasher, delegate)

    def setup() {

        Step<? super PreviousExecutionContext, ? extends CachingResult> delegate
    ) {
        super(workInputListeners, delegate);
        this.outputChangeListener = outputChangeListener;
        this.outputsCleanerSupplier = outputsCleanerSupplier;
    }

    @Override

    @Nullable
    abstract protected OverlappingOutputs detectOverlappingOutputs(UnitOfWork work, PreviousExecutionContext context, ImmutableSortedMap<String, FileSystemSnapshot> unfilteredOutputSnapshots);

    private BeforeExecutionState captureExecutionStateWithOutputs(UnitOfWork work, PreviousExecutionContext context, ImmutableSortedMap<String, FileSystemSnapshot> unfilteredOutputSnapshots, @Nullable OverlappingOutputs overlappingOutputs) {

import org.gradle.internal.operations.BuildOperationRunner;
import org.gradle.internal.snapshot.FileSystemSnapshot;

import javax.annotation.Nullable;

public class CaptureNonIncrementalStateBeforeExecutionStep<C extends PreviousExecutionContext, R extends CachingResult> extends AbstractCaptureStateBeforeExecutionStep<C, R> {

    public CaptureNonIncrementalStateBeforeExecutionStep(
        BuildOperationRunner buildOperationRunner,

            // There is no previous execution in the immutable case
            PreviousExecutionContext previousExecutionContext = new PreviousExecutionContext(workspaceContext, null);
            CachingResult delegateResult = delegate.execute(work, previousExecutionContext);

            if (delegateResult.getExecution().isSuccessful()) {
                // Store workspace metadata

import javax.annotation.Nullable;
import java.util.Optional;

public class BeforeExecutionContext extends PreviousExecutionContext {
    private final BeforeExecutionState beforeExecutionState;

    public BeforeExecutionContext(PreviousExecutionContext parent, @Nullable BeforeExecutionState beforeExecutionState) {
        super(parent);
        this.beforeExecutionState = beforeExecutionState;
    }

import org.gradle.internal.operations.BuildOperationRunner;
import org.gradle.internal.snapshot.FileSystemSnapshot;

import javax.annotation.Nullable;

public class CaptureIncrementalStateBeforeExecutionStep<C extends PreviousExecutionContext, R extends CachingResult> extends AbstractCaptureStateBeforeExecutionStep<C, R> {
    private final OutputSnapshotter outputSnapshotter;
    private final OverlappingOutputDetector overlappingOutputDetector;