@spec bottom_commands(t(), non_neg_integer()) :: [{module(), non_neg_integer()}]

Get the least frequently executed commands (excluding untested).

@spec command_coverage(t()) :: float()

Get command coverage percentage.

Returns the percentage of defined commands that were executed at least once.

@spec format(t(), atom()) :: String.t()

Format coverage report for display.

Format Options

• :summary - Brief summary (default)
• :matrix - Transition matrix showing command pairs
• :full - Complete report with matrix and untested transitions
• :state_classes - State class transition matrix (requires state_classifier)

Examples

Coverage.format(tracker)                # summary
Coverage.format(tracker, :matrix)       # transition matrix only
Coverage.format(tracker, :full)         # everything
Coverage.format(tracker, :state_classes) # state class matrix only

@spec format_state_class_matrix(t()) :: String.t()

Format state class coverage as ASCII art.

Shows which state class transitions have been tested.

@spec format_transition_matrix(t()) :: String.t()

Format the transition matrix as ASCII art.

Shows which command pairs have been tested:

• ████ = well-tested (>10 occurrences)
• ▓▓▓▓ = tested (>5 occurrences)
• ░░░░ = lightly tested (1-5 occurrences)
• = untested

Example

Transition Matrix
───────────────────────────────────────
              → Create  Credit  Debit
Create           ·      ████    ████
Credit         ████       ·     ▓▓▓▓
Debit          ░░░░    ████       ·

@spec from_result({:ok, map()} | {:error, PropertyDamage.FailureReport.t()}, module()) ::
  t()

Build coverage from a single result (convenience function).

@spec meets_threshold?(
  t(),
  keyword()
) :: boolean()

Check if coverage meets specified thresholds.

Options

• :command - Minimum command coverage percentage (default: 0)
• :transition - Minimum transition coverage percentage (default: 0)
• :min_commands - Minimum total commands executed (default: 0)

Example

Coverage.meets_threshold?(coverage, command: 80, transition: 50)

@spec merge(t(), t()) :: t()

Merge two coverage trackers.

Useful for combining coverage from parallel test runs.

@spec new(
  module(),
  keyword()
) :: t()

Create a new coverage tracker for a model.

Options

• :state_classifier - Function to classify states into abstract classes. The function receives the projection state map and returns an atom or string identifying the state class.

Example

# Track coverage with state classes
classifier = fn state ->
  cond do
    state.balance == 0 -> :zero_balance
    state.balance > 0 -> :positive_balance
    state.balance < 0 -> :negative_balance
  end
end

tracker = Coverage.new(MyModel, state_classifier: classifier)

@spec record(t(), {:ok, map()} | {:error, PropertyDamage.FailureReport.t()}) :: t()

Record coverage from a test run result.

Works with both success and failure results.

@spec state_class_counts(t()) :: %{required(atom()) => non_neg_integer()}

Get state class counts (requires state_classifier to be set).

Returns a map of %{state_class => count}.

@spec state_class_matrix(t()) :: %{
  required(atom()) => %{required(atom()) => non_neg_integer()}
}

Get the state class transition matrix.

Returns %{from_class => %{to_class => count}}.

@spec state_class_transitions(t()) :: %{
  required({atom(), atom()}) => non_neg_integer()
}

Get state class transition counts (requires state_classifier to be set).

Returns a map of %{{from_class, to_class} => count}.

@spec stats(t()) :: map()

Get detailed statistics.

@spec to_json(t()) :: String.t()

Export coverage data to JSON for CI integration.

@spec top_commands(t(), non_neg_integer()) :: [{module(), non_neg_integer()}]

Get the most frequently executed commands.

@spec top_transitions(t(), non_neg_integer()) :: [
  {{module(), module()}, non_neg_integer()}
]

Get most frequently tested transitions.

@spec transition_coverage(t()) :: float()

Get transition coverage percentage.

Returns the percentage of possible command pairs that were tested.

@spec transition_matrix(t()) :: %{
  required(module()) => %{required(module()) => non_neg_integer()}
}

Get the transition matrix as a map.

Returns %{from_command => %{to_command => count}}.

@spec unique_states(t()) :: non_neg_integer()

Get the number of unique states observed.

@spec untested_commands(t()) :: [module()]

Get commands that haven't been tested yet.

@spec untested_transitions(t()) :: [{module(), module()}]

Get transitions (command pairs) that haven't been tested yet.

Returns list of {from_command, to_command} tuples.