🥮 mooncakes.io

    caseweave

    Deterministic constrained combinatorial test matrix generator for MoonBit.

    testing
    pairwise
    covering-array
    constraints
    ci
    Download zip
    Author
    Version
    0.1.1
    License
    MIT
    Repository
    Last updated
    2 months ago
    Downloads
    38

    No dependencies

    #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 issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io