}

    protected AfterExecutionResult(AfterExecutionResult parent) {
        this(parent, parent.getAfterExecutionOutputState().orElse(null));
    }

    /**
     * State after execution, or {@link Optional#empty()} if work is untracked.
     */
    public Optional<ExecutionOutputState> getAfterExecutionOutputState() {
        return Optional.ofNullable(afterExecutionOutputState);
    }

        // If we did not capture any outputs after execution, remove them from history
        context.getHistory()
            .ifPresent(history -> {
                if (!result.getAfterExecutionOutputState().isPresent()) {
                    history.remove(context.getIdentity().getUniqueId());
                }
            });
        return result;
    }

        }
        def delegateResult = Stub(CachingResult) {
            getExecution() >> Try.successful(delegateExecution)
            getDuration() >> delegateDuration
            getAfterExecutionOutputState() >> Optional.of(delegateOutputState)
        }
        def resolvedDelegateResult = Stub(Object)

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

        then:

     *
     * This includes snapshots for the whole output {@link org.gradle.api.file.FileCollection}.
     *
     * @see PreviousExecutionState#getOutputFilesProducedByWork()
     * @see AfterExecutionResult#getAfterExecutionOutputState()
     */
    ImmutableSortedMap<String, FileSystemSnapshot> getOutputFileLocationSnapshots();

    /**
     * Returns overlapping outputs if they are detected.
     *

    public UpToDateResult(AfterExecutionResult parent, ImmutableList<String> executionReasons) {
        super(parent);
        this.executionReasons = executionReasons;
        this.reusedOutputOriginMetadata = parent.getAfterExecutionOutputState()
            .filter(ExecutionOutputState::isReused)
            .map(ExecutionOutputState::getOriginMetadata)
            .orElse(null);
    }

        if (work.shouldCleanupStaleOutputs()) {
            cleanupStaleOutputs(work, context);
        }
        R result = delegate.execute(work, context);
        result.getAfterExecutionOutputState()
            .ifPresent(afterExecutionState -> outputFilesRepository.recordOutputs(afterExecutionState.getOutputFilesProducedByWork().values()));
        return result;
    }

            );
            return result;
        } catch (Exception storeFailure) {
            return new AfterExecutionResult(Result.failed(storeFailure, result.getDuration()), result.getAfterExecutionOutputState().orElse(null));
        }
    }

    /**
     * Stores the results of the given work in the build cache, unless storing was disabled for this execution or work was untracked.
     * <p>

                .getOutputAs(Object.class)
                .map(Cast::<T>uncheckedNonnullCast),
            result
                .getReusedOutputOriginMetadata()
                .orElseGet(() -> result.getAfterExecutionOutputState()
                    .map(ExecutionOutputState::getOriginMetadata)
                    .orElse(null))
        );
    }

    def delegateResult = Stub(CachingResult) {
        getDuration() >> Duration.ofSeconds(1)
        getExecution() >> Try.successful(Stub(ExecutionEngine.Execution))
        getAfterExecutionOutputState() >> Optional.of(new DefaultExecutionOutputState(true, ImmutableSortedMap.of(), originMetadata, false))
    }

    def work1Started = new CountDownLatch(1)
    def work1Finished = new CountDownLatch(1)

        context.getHistory()
            .ifPresent(history -> context.getCachingState().getCacheKeyCalculatedState()
                .flatMap(cacheKeyCalculatedState -> result.getAfterExecutionOutputState()
                    .filter(afterExecutionState -> result.getExecution().isSuccessful() || shouldPreserveFailedState(context, afterExecutionState))