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

        when:

                // (if) The test fails in all of the re-runs […] the running time of a failing test with re-runs will be the running time of the first failing run.
                long duration = allFailed ? firstExecution.getDuration() : lastExecution.getDuration();

                writeTestCase(writer, new TestCase(
                    firstExecution.getDisplayName(),
                    className,
                    duration,

        def instant = end.get()
        if (instant == null) {
            throw new IllegalStateException("Operation '$name' has not completed yet.")
        }
        return instant
    }

    Duration getDuration() {
        return getEnd() - start
    }

    void completed(Instant when) {
        end.compareAndSet(null, when)
    }

        // As this is _roughly_ the amount of time that is avoided by reusing the outputs,
        // which is currently the _only_ thing this value is used for.
        Duration originExecutionTime = result.getDuration().plus(Duration.ofMillis(snapshotOutputDuration));
        HashCode buildCacheKey = ((BuildCacheKeyInternal) cacheKeyCalculatedState.getKey()).getHashCodeInternal();
        return new OriginMetadata(

                    final TestResult testResult = model.addTest(classResult.getId(), classResult.getClassName(), classResult.getClassDisplayName(), collectedResult.getName(), collectedResult.getDisplayName(), collectedResult.getDuration());
                    if (collectedResult.getResultType() == SKIPPED) {
                        testResult.setIgnored();
                    } else {

            );
            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.

        1 * execution.canStoreOutputsInCache() >> true

        then:
        interaction { outputStored { throw failure } }


        then:
        1 * delegateResult.getDuration() >> duration
        1 * delegateResult.getAfterExecutionOutputState() >> Optional.of(afterExecutionOutputState)

        then:
        0 * _
    }

        return new DefaultAnnotationProcessorResult(result.getClassName(), toAnnotationProcessorResultType(result.getType()), result.getDuration());
    }

    private static AnnotationProcessorResult.Type toAnnotationProcessorResultType(String type) {
        if (type.equals(InternalAnnotationProcessorResult.TYPE_AGGREGATING)) {