}

    public int getFailuresCount() {
        return failuresCount;
    }

    public int getSkippedCount() {
        return skippedCount;
    }

    public long getDuration() {
        long end = startTime;
        for (TestMethodResult m : methodResults) {
            if (end < m.getEndTime()) {
                end = m.getEndTime();
            }
        }

        if (ignored) {
            return ResultType.SKIPPED;
        }
        return failures.isEmpty() ? ResultType.SUCCESS : ResultType.FAILURE;
    }

    @Override
    public long getDuration() {
        return duration;
    }

    @Override
    public String getFormattedDuration() {
        return ignored ? "-" : super.getFormattedDuration();
    }

    }

    public List<TestFailure> getFailures() {
        return failures;
    }

    public TestResult.ResultType getResultType() {
        return resultType;
    }

    public long getDuration() {
        return duration;
    }

    public long getEndTime() {
        return endTime;
    }

        }

        def stdout(String output) {
            outputEvents << new BuildableOutputEvent(0, new DefaultTestOutputEvent(StdOut, output))
        }

        @Override
        long getDuration() {
            this.duration
        }
    }

    static class BuildableTestMethodResult extends TestMethodResult {

        long duration
        List<TestFailure> failures = []

    def work = Stub(ImmutableUnitOfWork) {
        getWorkspaceProvider() >> immutableWorkspaceProvider
    }
    def originMetadata = Stub(OriginMetadata)
    def delegateResult = Stub(CachingResult) {
        getDuration() >> Duration.ofSeconds(1)
        getExecution() >> Try.successful(Stub(ExecutionEngine.Execution))

        // 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(

        encoder.writeString(methodResult.getName());
        encoder.writeString(methodResult.getDisplayName());
        encoder.writeSmallInt(methodResult.getResultType().ordinal());
        encoder.writeSmallLong(methodResult.getDuration());
        encoder.writeLong(methodResult.getEndTime());
        encoder.writeSmallInt(methodResult.getFailures().size());
        for (TestFailure testFailure : methodResult.getFailures()) {

                    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 * _
    }