Report

record in io.mutastic.api

record Report(
    String project,
    int jdk,
    List<MutantResult> results,
    int tests,
    List<String> flaky,
    Duration coverage,
    int workers,
    int started,
    Duration took,
    List<MutantResult> audited,
    Optional<ChangedLines> scope,
    List<Ignore> staleIgnores,
    List<FlakyTest> flakyEvidence)

A finished run: every mutant’s result, in the order they were found.

Components

`jdk`	the feature version the tests ran on
`flaky`	tests that failed in the coverage pass and passed when run again: left out of every mutant’s run, so their catches don’t count
`coverage`	how long the coverage pass took, of `took`
`workers`	how many workers ran side by side
`started`	how many worker JVMs started: one per worker, plus one after each kill
`audited`	in an audit of the arid filters, each arid mutant’s result when run anyway; the mutant itself is in `results` as skipped, as in any run
`scope`	the change the run was scoped to, when it was: only mutants on its lines ran
`staleIgnores`	the ignores whose line has changed since: they no longer hold, and their mutants ran
`flakyEvidence`	for each of the `flaky` tests the run found out about, what it failed with and what it reaches that changes from run to run

Constructors

`Report`

Report(String project, int jdk, List<MutantResult> results, int tests, List<String> flaky, Duration coverage, int workers, int started, Duration took, List<MutantResult> audited, Optional<ChangedLines> scope, List<Ignore> staleIgnores)

A run with nothing known of why its flaky tests are flaky.

`Report`

Report(String project, int jdk, List<MutantResult> results, int tests, List<String> flaky, Duration coverage, int workers, int started, Duration took)

A run without an audit.

Methods

`whyFlaky`

Optional<FlakyTest> whyFlaky(String test)

What’s known of why the flaky test test is flaky, if anything is.

`merge`

Report merge(Report other)

This run’s results with other’s, a run of other tests (another module’s) over the same mutants: a mutant is caught if either caught it, missed rather than not covered if either reached it, and covered by the tests of both.

`replaced`

int replaced()

Workers started again after one was killed for taking too long: never fewer than none.

`count`

long count(Status status)

`scored`

long scored()

The mutants that ran or could have: all but the skipped ones.

`score`

OptionalDouble score()

Detected mutants as a share of the scored ones, from 0 to 100; none when nothing was scored, which is no evidence either way, not a perfect score.

`coveredScore`

OptionalDouble coveredScore()

Detected mutants as a share of those some test reached: how well the tests check the code they run, apart from the code they don’t. None when no test reached any; the threshold is still on score.

`passes`

boolean passes(int threshold)

At or above threshold, or nothing to score: with no mutants there is nothing to fail.