🥮 mooncakes.io

caseweave

Deterministic constrained combinatorial test matrix generator for MoonBit.

testing
pairwise
covering-array
constraints
ci
moon add LF-ai-nb/caseweave@0.1.0
Download zip
Author
Version
0.1.0
License
MIT
Repository
Last updated
3 hours ago
Downloads
2
README

#CaseWeave

MoonBit package documentation lives in README.md.

#
CasePattern

source
pub(all) struct CasePattern {
  choices : Array[NamedChoice]
} derive(Eq, 
Debug)

A partial assignment such as os=linux, browser=chrome.

#
CasePattern::matches

source
fn CasePattern::matches(self : CasePattern, model : Model, test_case : TestCase) -> Result[Bool, CaseWeaveError]

#
CasePattern::to_case

source
fn CasePattern::to_case(self : CasePattern, model : Model, line_no? : Int) -> Result[TestCase, CaseWeaveError]

#
CasePattern::to_exclusion_constraint

source
fn CasePattern::to_exclusion_constraint(self : CasePattern, label : String) -> Result[Constraint, CaseWeaveError]

#
CasePattern::to_text

source
fn CasePattern::to_text(self : CasePattern) -> String

#
CasePattern::validate

source
fn CasePattern::validate(self : CasePattern, model : Model) -> Result[Unit, CaseWeaveError]

#
CaseRisk

source
pub(all) struct CaseRisk {
  score : Int
  reasons : Array[String]
} derive(Eq, 
Debug)

Risk score for one concrete case.

#
CaseWeaveError

source
pub(all) enum CaseWeaveError {
  EmptyModel
  EmptyParameterName(Int)
  DuplicateParameter(String)
  EmptyValues(String)
  EmptyValue(String, Int)
  DuplicateValue(String, String)
  InvalidStrength(Int, Int)
  InvalidCandidateLimit(Int)
  InvalidSuggestionLimit(Int)
  CandidateLimitExceeded(Int)
  NoValidCases
  UncoverableInteraction
  ParseError(Int, String)
  UnknownParameter(String)
  UnknownValue(String, String)
  InvalidCaseWidth(Int, Int)
  InvalidCaseValue(String, String)
  ConstraintViolation(Int, String)
} derive(Eq, 
Debug)

Errors returned by model validation, constraint parsing, generation and coverage analysis. Public operations return Result so callers can report input problems without relying on panics.

#
Constraint

source
pub(all) struct Constraint {
  label : String
  expression : ConstraintExpr
} derive(Eq, 
Debug)

#
Constraint::matches

source
fn Constraint::matches(self : Constraint, model : Model, test_case : TestCase) -> Result[Bool, CaseWeaveError]

#
Constraint::new

source
fn Constraint::new(label : String, expression : ConstraintExpr) -> Constraint

#
Constraint::parse

source
fn Constraint::parse(label : String, source : String) -> Result[Constraint, CaseWeaveError]

#
Constraint::validate

source
fn Constraint::validate(self : Constraint, model : Model) -> Result[Unit, CaseWeaveError]

#
ConstraintExpr

source
pub(all) enum ConstraintExpr {
  Equal(String, String)
  NotEqual(String, String)
  OneOf(String, Array[String])
  NoneOf(String, Array[String])
  And(ConstraintExpr, ConstraintExpr)
  Or(ConstraintExpr, ConstraintExpr)
  Implies(ConstraintExpr, ConstraintExpr)
  Not(ConstraintExpr)
  Always
  Never
} derive(Eq, 
Debug)

Boolean constraint language used to exclude impossible or unwanted test combinations. Atoms address parameters and values by name, keeping models readable and independent from internal indexes.

#
CoverageReport

source
pub(all) struct CoverageReport {
  strength : Int
  case_count : Int
  total_interactions : Int
  covered_interactions : Int
  coverage_percent : Double
  missing : Array[MissingInteraction]
} derive(
Debug)

Coverage audit for an arbitrary suite. Missing interactions are named so they can be printed directly in CI diagnostics.

#
CoverageReport::is_complete

source
fn CoverageReport::is_complete(self : CoverageReport) -> Bool

#
CoverageReport::missing_text

source
fn CoverageReport::missing_text(self : CoverageReport) -> String

Render missing interactions as readable lines.

#
CoverageReport::summary

source
fn CoverageReport::summary(self : CoverageReport) -> String

One-line coverage summary suitable for CI logs.

#
GateFailure

source
pub(all) struct GateFailure {
  kind : GateFailureKind
  message : String
} derive(Eq, 
Debug)

#
GateFailureKind

source
pub(all) enum GateFailureKind {
  IncompleteCoverage(Int, Int)
  TooManyMissingInteractions(Int, Int)
  TooFewCases(Int, Int)
  TooManyCases(Int, Int)
  TopRiskTooLow(Int, Int)
  TooFewPositiveRiskCases(Int, Int)
  ScenarioWarnings(Int)
} derive(Eq, 
Debug)

#
GateReport

source
pub(all) struct GateReport {
  passed : Bool
  failures : Array[GateFailure]
  warnings : Array[SpecWarning]
  coverage : CoverageReport
  case_count : Int
  top_risk_score : Int
  positive_risk_cases : Int
}

#
GateReport::failure_text

source
fn GateReport::failure_text(self : GateReport) -> String

#
GateReport::is_passed

source
fn GateReport::is_passed(self : GateReport) -> Bool

#
GateReport::summary

source
fn GateReport::summary(self : GateReport) -> String

#
GateReport::to_markdown

source
fn GateReport::to_markdown(self : GateReport) -> String

#
GateReport::warning_text

source
fn GateReport::warning_text(self : GateReport) -> String

#
GenerationOptions

source
pub(all) struct GenerationOptions {
  strength : Int
  max_candidates : Int
  minimize : Bool
} derive(Eq, 
Debug)

Controls covering-array generation. max_candidates bounds the exhaustive candidate phase; constraints are evaluated during enumeration so invalid branches are pruned early.

#
GenerationOptions::default

source

#
GenerationOptions::pairwise

source
fn GenerationOptions::pairwise(max_candidates? : Int) -> GenerationOptions

#
GenerationStats

source
pub(all) struct GenerationStats {
  cartesian_size : Int64
  examined_candidates : Int
  feasible_candidates : Int
  required_interactions : Int
  selected_cases : Int
  removed_redundant_cases : Int
} derive(Eq, 
Debug)

#
InteractionRisk

source
pub(all) struct InteractionRisk {
  pattern : CasePattern
  weight : Int
  note : String
} derive(Eq, 
Debug)

A risk attached to an interaction pattern.

#
MissingInteraction

source
pub(all) struct MissingInteraction {
  choices : Array[NamedChoice]
} derive(Eq, 
Debug)

#
Model

source
pub struct Model {
  parameters : Array[Parameter]
}

A validated ordered collection of parameters.

#
Model::combination_count

source
fn Model::combination_count(self : Model) -> Int64

#
Model::new

source
fn Model::new(parameters : Array[Parameter]) -> Result[Model, CaseWeaveError]

#
Model::parameter

source
fn Model::parameter(self : Model, index : Int) -> Parameter?

#
Model::parameter_count

source
fn Model::parameter_count(self : Model) -> Int

#
Model::parameter_index

source
fn Model::parameter_index(self : Model, name : String) -> Int?

#
Model::parameters

source
fn Model::parameters(self : Model) -> Array[Parameter]

#
Model::validate_case

source
fn Model::validate_case(self : Model, test_case : TestCase) -> Result[Unit, CaseWeaveError]

#
Model::value_index

source
fn Model::value_index(self : Model, parameter_index : Int, value : String) -> Int?

#
NamedChoice

source
pub(all) struct NamedChoice {
  parameter : String
  value : String
} derive(Eq, 
Debug)

#
Parameter

source
pub(all) struct Parameter {
  name : String
  values : Array[String]
} derive(Eq, 
Debug)

One dimension in the input space. Values are kept in declaration order so generation and exported output remain deterministic.

#
Parameter::new

source
fn Parameter::new(name : String, values : Array[String]) -> Parameter

#
RankedCase

source
pub(all) struct RankedCase {
  rank : Int
  index : Int
  test_case : TestCase
  score : Int
  reasons : Array[String]
} derive(Eq, 
Debug)

A generated case ordered by descending risk score.

#
RepairGate

source
pub(all) struct RepairGate {
  require_complete : Bool
  max_additions : Int
  max_final_missing : Int
  min_largest_gain : Int
}

#
RepairGate::best_effort

source
fn RepairGate::best_effort(max_additions : Int, max_final_missing : Int) -> RepairGate

#
RepairGate::budget

source
fn RepairGate::budget(max_additions : Int) -> RepairGate

#
RepairGate::default

source
fn RepairGate::default() -> RepairGate

#
RepairGate::normalize

source
fn RepairGate::normalize(self : RepairGate) -> RepairGate

#
RepairGateFailure

source
pub(all) struct RepairGateFailure {
  kind : RepairGateFailureKind
  message : String
} derive(Eq, 
Debug)

#
RepairGateFailureKind

source
pub(all) enum RepairGateFailureKind {
  RepairIncomplete(Int)
  TooManyRepairAdditions(Int, Int)
  TooManyRemainingInteractions(Int, Int)
  LargestGainTooLow(Int, Int)
} derive(Eq, 
Debug)

#
RepairGateReport

source
pub(all) struct RepairGateReport {
  passed : Bool
  failures : Array[RepairGateFailure]
  additions : Int
  initial_missing : Int
  final_missing : Int
  largest_gain : Int
  complete : Bool
}

#
RepairGateReport::failure_text

source
fn RepairGateReport::failure_text(self : RepairGateReport) -> String

#
RepairGateReport::is_passed

source
fn RepairGateReport::is_passed(self : RepairGateReport) -> Bool

#
RepairGateReport::summary

source
fn RepairGateReport::summary(self : RepairGateReport) -> String

#
RepairGateReport::to_markdown

source
fn RepairGateReport::to_markdown(self : RepairGateReport) -> String

#
RepairOptions

source
pub(all) struct RepairOptions {
  strength : Int
  max_candidates : Int
  max_suggestions : Int
}

Options for repairing an incomplete suite. The planner uses the same interaction model as audit, then greedily proposes additional feasible cases that cover the largest number of currently missing interactions.

#
RepairOptions::default

source
fn RepairOptions::default() -> RepairOptions

#
RepairOptions::from_generation

source
fn RepairOptions::from_generation(options : GenerationOptions, max_suggestions? : Int) -> RepairOptions

#
RepairOptions::normalize

source
fn RepairOptions::normalize(self : RepairOptions) -> RepairOptions

#
RepairOptions::pairwise

source
fn RepairOptions::pairwise(max_candidates? : Int, max_suggestions? : Int) -> RepairOptions

#
RepairPlan

source
pub(all) struct RepairPlan {
  model : Model
  original_cases : Array[TestCase]
  additions : Array[TestCase]
  merged_cases : Array[TestCase]
  original_report : CoverageReport
  final_report : CoverageReport
  steps : Array[RepairStep]
  complete : Bool
  initial_missing : Int
  final_missing : Int
}

#
RepairPlan::addition_count

source
fn RepairPlan::addition_count(self : RepairPlan) -> Int

#
RepairPlan::additions

source
fn RepairPlan::additions(self : RepairPlan) -> Array[TestCase]

#
RepairPlan::additions_markdown

source
fn RepairPlan::additions_markdown(self : RepairPlan) -> String

#
RepairPlan::evaluate_repair_gate

source
fn RepairPlan::evaluate_repair_gate(self : RepairPlan, gate? : RepairGate) -> RepairGateReport

#
RepairPlan::highest_risk_step

source
fn RepairPlan::highest_risk_step(self : RepairPlan) -> RepairStep?

#
RepairPlan::is_complete

source
fn RepairPlan::is_complete(self : RepairPlan) -> Bool

#
RepairPlan::largest_gain_step

source
fn RepairPlan::largest_gain_step(self : RepairPlan) -> RepairStep?

#
RepairPlan::largest_repair_gain

source
fn RepairPlan::largest_repair_gain(self : RepairPlan) -> Int

#
RepairPlan::merged_cases

source
fn RepairPlan::merged_cases(self : RepairPlan) -> Array[TestCase]

#
RepairPlan::merged_markdown

source
fn RepairPlan::merged_markdown(self : RepairPlan) -> String

#
RepairPlan::missing_after_text

source
fn RepairPlan::missing_after_text(self : RepairPlan) -> String

#
RepairPlan::risk_summary

source
fn RepairPlan::risk_summary(self : RepairPlan) -> String

#
RepairPlan::steps

source
fn RepairPlan::steps(self : RepairPlan) -> Array[RepairStep]

#
RepairPlan::steps_markdown

source
fn RepairPlan::steps_markdown(self : RepairPlan, top? : Int) -> String

#
RepairPlan::summary

source
fn RepairPlan::summary(self : RepairPlan) -> String

#
RepairPlan::to_markdown

source
fn RepairPlan::to_markdown(self : RepairPlan) -> String

#
RepairStep

source
pub(all) struct RepairStep {
  index : Int
  test_case : TestCase
  newly_covered : Array[MissingInteraction]
  remaining_missing : Int
  risk_score : Int
  reasons : Array[String]
} derive(Eq, 
Debug)

#
ScenarioGate

source
pub(all) struct ScenarioGate {
  require_complete_coverage : Bool
  max_missing_interactions : Int
  min_cases : Int
  max_cases : Int
  min_top_risk_score : Int
  min_positive_risk_cases : Int
  allow_warnings : Bool
}

CI-oriented policy for generated scenario runs. It turns coverage, risk and scenario-lint facts into a small pass/fail report that can be printed in a release job.

#
ScenarioGate::coverage_only

source
fn ScenarioGate::coverage_only() -> ScenarioGate

#
ScenarioGate::default

source
fn ScenarioGate::default() -> ScenarioGate

#
ScenarioGate::describe

source
fn ScenarioGate::describe(self : ScenarioGate) -> String

#
ScenarioGate::normalize

source
fn ScenarioGate::normalize(self : ScenarioGate) -> ScenarioGate

#
ScenarioGate::strict

source
fn ScenarioGate::strict() -> ScenarioGate

#
ScenarioGate::with_case_budget

source
fn ScenarioGate::with_case_budget(min_cases : Int, max_cases : Int) -> ScenarioGate

#
ScenarioGate::with_risk_floor

source
fn ScenarioGate::with_risk_floor(min_top_risk_score : Int, min_positive_risk_cases : Int) -> ScenarioGate

#
ScenarioRun

source
pub(all) struct ScenarioRun {
  spec_name : String
  model : Model
  suite : Suite
  cases : Array[TestCase]
  included_case_count : Int
  coverage : CoverageReport
  ranked_cases : Array[RankedCase]
}

End-to-end execution result for a parsed scenario spec.

#
ScenarioRun::cases_markdown

source
fn ScenarioRun::cases_markdown(self : ScenarioRun) -> String

#
ScenarioRun::evaluate_gate

source
fn ScenarioRun::evaluate_gate(self : ScenarioRun, spec : ScenarioSpec, gate? : ScenarioGate) -> GateReport

#
ScenarioRun::evaluate_normalized_gate

source
fn ScenarioRun::evaluate_normalized_gate(self : ScenarioRun, spec : ScenarioSpec, gate : ScenarioGate) -> GateReport

#
ScenarioRun::positive_risk_case_count

source
fn ScenarioRun::positive_risk_case_count(self : ScenarioRun) -> Int

#
ScenarioRun::risk_markdown

source
fn ScenarioRun::risk_markdown(self : ScenarioRun, top? : Int) -> String

#
ScenarioRun::summary

source
fn ScenarioRun::summary(self : ScenarioRun) -> String

#
ScenarioRun::top_risk_score

source
fn ScenarioRun::top_risk_score(self : ScenarioRun) -> Int

#
ScenarioSpec

source
pub(all) struct ScenarioSpec {
  name : String
  model : Model
  constraints : Array[Constraint]
  options : GenerationOptions
  included_cases : Array[TestCase]
  excluded_patterns : Array[CasePattern]
  value_risks : Array[ValueRisk]
  interaction_risks : Array[InteractionRisk]
}

A compact, line-oriented scenario format for teams that want to keep their covering-array model beside design docs, issues or CI configuration.

#
ScenarioSpec::generate_suite

source
fn ScenarioSpec::generate_suite(self : ScenarioSpec) -> Result[Suite, CaseWeaveError]

#
ScenarioSpec::lint

source

#
ScenarioSpec::lint_text

source
fn ScenarioSpec::lint_text(self : ScenarioSpec) -> String

#
ScenarioSpec::parse

source
fn ScenarioSpec::parse(source : String) -> Result[ScenarioSpec, CaseWeaveError]

#
ScenarioSpec::plan_repair

source
fn ScenarioSpec::plan_repair(self : ScenarioSpec, cases : Array[TestCase], options? : RepairOptions) -> Result[RepairPlan, CaseWeaveError]

#
ScenarioSpec::rank_cases

source
fn ScenarioSpec::rank_cases(self : ScenarioSpec, cases : Array[TestCase]) -> Result[Array[RankedCase], CaseWeaveError]

#
ScenarioSpec::run

source

#
ScenarioSpec::score_case

source
fn ScenarioSpec::score_case(self : ScenarioSpec, test_case : TestCase) -> Result[CaseRisk, CaseWeaveError]

#
ScenarioSpec::summary

source
fn ScenarioSpec::summary(self : ScenarioSpec) -> String

#
SpecWarning

source
pub(all) struct SpecWarning {
  kind : SpecWarningKind
  message : String
} derive(Eq, 
Debug)

#
SpecWarningKind

source
pub(all) enum SpecWarningKind {
  NoConstraints
  NoRiskHints
  NoIncludedCases
  StrengthOne
  CandidateLimitBelowCartesian(Int64, Int)
  SingleValueParameter(String)
} derive(Eq, 
Debug)

Non-blocking quality hints for scenario specifications.

#
Suite

source
pub struct Suite {
  cases : Array[TestCase]
  strength : Int
  stats : GenerationStats
}

Generated cases plus reproducibility and compression statistics.

#
Suite::cases

source
fn Suite::cases(self : Suite) -> Array[TestCase]

#
Suite::length

source
fn Suite::length(self : Suite) -> Int

#
Suite::stats

source
fn Suite::stats(self : Suite) -> GenerationStats

#
Suite::strength

source
fn Suite::strength(self : Suite) -> Int

#
Suite::summary

source
fn Suite::summary(self : Suite) -> String

One-line generation summary suitable for CLI output.

#
Suite::to_csv

source
fn Suite::to_csv(self : Suite, model : Model) -> String

Render a generated suite as CSV with a header row in model order.

#
Suite::to_json

source
fn Suite::to_json(self : Suite, model : Model) -> String

Render a generated suite as a compact JSON document.

#
Suite::to_markdown

source
fn Suite::to_markdown(self : Suite, model : Model) -> String

Render a generated suite as a Markdown table for READMEs and issue reports.

#
TestCase

source
pub(all) struct TestCase {
  values : Array[String]
} derive(Eq, 
Debug)

A concrete test vector in model order.

#
TestCase::assignment_text

source
fn TestCase::assignment_text(self : TestCase, model : Model) -> String

#
TestCase::get

source
fn TestCase::get(self : TestCase, index : Int) -> String?

#
TestCase::new

source
fn TestCase::new(values : Array[String]) -> TestCase

#
TestCase::value_for

source
fn TestCase::value_for(self : TestCase, model : Model, parameter : String) -> String?

#
ValueRisk

source
pub(all) struct ValueRisk {
  choice : NamedChoice
  weight : Int
  note : String
} derive(Eq, 
Debug)

A risk attached to one parameter value.

#
audit

source
fn audit(model : Model, cases : Array[TestCase], strength? : Int, constraints? : Array[Constraint], max_candidates? : Int) -> Result[CoverageReport, CaseWeaveError]

#
cases_to_csv

source
fn cases_to_csv(model : Model, cases : Array[TestCase]) -> String

Render arbitrary cases as CSV. This is useful when callers load a suite from another source and want the same escaping rules as generated suites.

#
cases_to_markdown

source
fn cases_to_markdown(model : Model, cases : Array[TestCase]) -> String

Render arbitrary cases as a Markdown table.

#
generate

source
fn generate(model : Model, constraints? : Array[Constraint], options? : GenerationOptions) -> Result[Suite, CaseWeaveError]

Generate a deterministic constrained covering array. Candidate order, greedy tie-breaking, and redundancy elimination are stable, so identical inputs always produce identical suites.

#
parse_scenario_spec

source
fn parse_scenario_spec(source : String) -> Result[ScenarioSpec, CaseWeaveError]

#
plan_repair

source
fn plan_repair(model : Model, cases : Array[TestCase], constraints? : Array[Constraint], options? : RepairOptions) -> Result[RepairPlan, CaseWeaveError]

#
version

source
let version : String

CaseWeave builds deterministic covering arrays for configuration-heavy software tests. The public API is split across the files in this package; this file intentionally keeps the package-level overview close to the generated interface.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io