this.cause = cause;
    }

    public MavenSession getSession() {
        return session;
    }

    public MavenProject getProject() {
        return project;
    }

    public MojoExecution getExecution() {
        return mojoExecution;
    }

    public Mojo getMojo() {
        return mojo;
    }

    public Throwable getCause() {
        return cause;
    }

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

                .flatMap(cacheKeyCalculatedState -> result.getAfterExecutionOutputState()
                    .filter(afterExecutionState -> result.getExecution().isSuccessful() || shouldPreserveFailedState(context, afterExecutionState))
                    .map(executionOutputState -> new DefaultAfterExecutionState(

                operationContext.setResult(Operation.Result.INSTANCE);
                return new DefaultExecutionOutputState(result.getExecution().isSuccessful(), outputsProducedByWork, originMetadata, false);
            },
            BuildOperationDescriptor
                .displayName("Snapshot outputs after executing " + work.getDisplayName())

         */
        <T> Deferrable<Try<T>> executeDeferred(Cache<Identity, IdentityCacheResult<T>> cache);
    }

    interface Result {
        Try<Execution> getExecution();

        CachingState getCachingState();

        /**
         * Get the output of the work. For immutable work this is resolved from the immutable workspace.
         */

         * Executes a conditional execution and then releases its resource lock.
         */
        private void runExecution(final ConditionalExecution<?> execution) {
            try {
                execution.getExecution().run();
            } finally {
                execution.complete();
            }
        }

        private void shutDown() {
            lock.lock();
            try {

                cacheableWork.getDisplayName(), cacheKey.getHashCode());
        }
        AfterExecutionResult result = executeWithoutCache(cacheableWork.work, context);
        try {
            result.getExecution().ifSuccessfulOrElse(
                executionResult -> storeInCacheUnlessDisabled(cacheableWork, cacheKey, result, executionResult),

            CachingResult delegateResult = delegate.execute(work, previousExecutionContext);

            if (delegateResult.getExecution().isSuccessful()) {
                // Store workspace metadata
                // TODO Capture in the type system the fact that we always have an after-execution output state here

        getExecutions().add(execution);
    } // -- void addExecution( Execution )

    /**
     * Get configuration to pass to all goals run in this phase.
     *
     * @return Object
     */
    public Object getConfiguration() {
        return this.configuration;
    } // -- Object getConfiguration()

    /**
     * Method getExecutions.
     *
     * @return List
     */

        List<? extends PerformanceTestExecution> executionsOfSameCommit = history.getExecutions().stream().filter(e -> e.getVcsCommits().contains(commitId)).collect(toList());
        List<? extends PerformanceTestExecution> currentExecutions = executionsOfSameCommit.isEmpty()
            ? history.getExecutions().stream().limit(3).collect(toList())
            : executionsOfSameCommit;
        return new PerformanceReportScenario(