public abstract class TestResultModel {

    public abstract TestResult.ResultType getResultType();

    public abstract long getDuration();

    public abstract String getTitle();

    public String getFormattedDuration() {
        return TimeFormatting.formatDurationVeryTerse(getDuration());
    }

    public String getStatusClass() {
        switch (getResultType()) {
            case SUCCESS:

    protected Result(Duration duration, Try<Execution> execution) {
        this.duration = duration;
        this.execution = execution;
    }

    protected Result(Result parent) {
        this(parent.getDuration(), parent.getExecution());
    }

    public static Result failed(Throwable t, Duration duration) {
        return new Result(duration, Try.failure(t));
    }

    }

    public int getIgnoredCount() {
        return ignored.size();
    }

    public int getRunTestCount() {
        return tests - getIgnoredCount();
    }

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

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

    @Override
    public String getClassName() {
        return className;
    }

    @Override
    public Type getType() {
        return type;
    }

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

    @Override
    public String getClassName() {
        return className;
    }

    @Override
    public String getType() {
        return type;
    }

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

        String TYPE_ISOLATING = "ISOLATING";
        String TYPE_AGGREGATING = "AGGREGATING";
        String TYPE_UNKNOWN = "UNKNOWN";

        String getClassName();

        String getType();

        Duration getDuration();

    }

            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)
    }

         */
        Type getType();

        /**
         * Returns the total execution time of this annotation processor.
         */
        Duration getDuration();

        /**
         * Type of annotation processor.
         *
         * @since 5.1
         */
        enum Type {
            ISOLATING,
            AGGREGATING,
            UNKNOWN
        }