🥮 mooncakes.io
README

mokomoking2501/lockwire/fault does not have a README file

#
BranchLabelCoverage

source
pub(all) struct BranchLabelCoverage {
  label : String
  hit_count : Int
  covered : Bool
} derive(Eq, 
Debug)

#
BuggifyGate

source
pub(all) struct BuggifyGate {
  point_id : String
  threshold_per_mille : Int
  fault_kind : FaultKind
} derive(Eq, 
Debug)

#
BuggifyGate::make

source
fn BuggifyGate::make(point_id~ : String, threshold_per_mille~ : Int, fault_kind~ : FaultKind) -> BuggifyGate

#
BuggifyGate::should_trigger

source
fn BuggifyGate::should_trigger(self : BuggifyGate, seed : Int) -> Bool

#
FaultCampaignCase

source
pub(all) struct FaultCampaignCase {
  seed : Int
  point_id : String
  fault_kind_label : String
  fault_kind_code : Int
  triggered : Bool
  fault_hit_count : Int
  digest : 
SimDigest
  failed : Bool
  failure_summary : String
} derive(Eq, 
Debug)

#
FaultCampaignCoverageReport

source
pub(all) struct FaultCampaignCoverageReport {
  campaign_id : String
  seed_pool_id : String
  coverage_source : String
  scenario_count : Int
  case_count : Int
  seed_count : Int
  fault_point_count : Int
  covered_fault_point_count : Int
  fault_point_coverage_per_mille : Int
  branch_label_count : Int
  covered_branch_label_count : Int
  branch_label_coverage_per_mille : Int
  failing_seed_count : Int
  first_failure_seed : Int?
  first_failure_point_id : String
  first_failure_digest : 
SimDigest
  digest : 
SimDigest
  fault_points : Array[FaultPointCoverage]
  branch_labels : Array[BranchLabelCoverage]
  seed_failure_histogram : Array[SeedFailureHistogramBucket]
  compiler_coverage_evidence : Bool
  external_fuzzing_evidence : Bool
  real_hot_path : Bool
} derive(Eq, 
Debug)

#
FaultCampaignCoverageReport::passes

source

#
FaultCampaignCoverageReport::to_text

source

#
FaultCampaignReport

source
pub(all) struct FaultCampaignReport {
  campaign_id : String
  seed_pool_id : String
  seed_count : Int
  gate_count : Int
  cases : Array[FaultCampaignCase]
  triggered_case_count : Int
  fault_hit_count : Int
  failure_count : Int
  first_failure_seed : Int?
  first_failure_point_id : String
  first_failure_summary : String
  shrink_candidate_seed : Int?
  shrink_status : String
  digest : 
SimDigest
  real_hot_path : Bool
} derive(Eq, 
Debug)

#
FaultCampaignReport::passes

source
fn FaultCampaignReport::passes(self : FaultCampaignReport) -> Bool

#
FaultCampaignReport::to_text

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

#
FaultHit

source
pub(all) struct FaultHit {
  seed : Int
  step : Int
  kind : FaultKind
  label : String
} derive(Eq, 
Debug)

#
FaultHit::to_trace_event

source
fn FaultHit::to_trace_event(self : FaultHit, event_id~ : Int, vtime~ : 
VTime, clock_domain~ : String, node_id~ : String, medium_id~ : String, backend~ : 
BackendProfile) -> 
TraceEvent

#
FaultKind

source
pub(all) enum FaultKind {
  Delay(
Duration)
  Drop
  Corrupt(offset~ : Int, value~ : Byte)
  Duplicate
  Reorder
} derive(Eq, 
Debug)

#
FaultKind::code

source
fn FaultKind::code(self : FaultKind) -> Int

#
FaultKind::label

source
fn FaultKind::label(self : FaultKind) -> String

#
FaultOutcome

source
pub(all) struct FaultOutcome {
  hit : FaultHit?
  frames : Array[Bytes]
  delayed_by : 
Duration?
  dropped : Bool
} derive(Eq, 
Debug)

#
FaultOutcome::is_faulted

source
fn FaultOutcome::is_faulted(self : FaultOutcome) -> Bool

#
FaultPlan

source
pub struct FaultPlan {
  // private fields
}

#
FaultPlan::add_rule

source
fn FaultPlan::add_rule(self : FaultPlan, rule : FaultRule) -> Unit

#
FaultPlan::apply

source
fn FaultPlan::apply(self : FaultPlan, payload : Bytes) -> FaultOutcome

#
FaultPlan::apply_pair

source
fn FaultPlan::apply_pair(self : FaultPlan, first : Bytes, second : Bytes) -> FaultOutcome

#
FaultPlan::from_seed

source
fn FaultPlan::from_seed(seed~ : Int) -> FaultPlan

#
FaultPlan::hit_count

source
fn FaultPlan::hit_count(self : FaultPlan) -> Int

#
FaultPlan::new

source
fn FaultPlan::new(seed~ : Int) -> FaultPlan

#
FaultPlan::report

source
fn FaultPlan::report(self : FaultPlan) -> FaultReport

#
FaultPlan::step

source
fn FaultPlan::step(self : FaultPlan) -> Int

#
FaultPointCoverage

source
pub(all) struct FaultPointCoverage {
  point_id : String
  case_count : Int
  triggered_count : Int
  covered : Bool
} derive(Eq, 
Debug)

#
FaultReport

source
pub(all) struct FaultReport {
  seed : Int
  total_steps : Int
  hits : Array[FaultHit]
} derive(Eq, 
Debug)

#
FaultRule

source
pub(all) struct FaultRule {
  kind : FaultKind
  schedule : FaultSchedule
  fired_count : Int
} derive(Eq, 
Debug)

#
FaultRule::new

source
fn FaultRule::new(kind : FaultKind, schedule : FaultSchedule) -> FaultRule

#
FaultRule::should_fire

source
fn FaultRule::should_fire(self : FaultRule, step : Int) -> Bool

#
FaultSchedule

source
pub(all) enum FaultSchedule {
  Always
  Once
  CountDown(Int)
  AfterStep(Int)
  AtStep(Int)
} derive(Eq, 
Debug)

#
SeedFailureHistogramBucket

source
pub(all) struct SeedFailureHistogramBucket {
  seed : Int
  case_count : Int
  failure_count : Int
  first_failure_point_id : String
  first_failure_digest : 
SimDigest
} derive(Eq, 
Debug)

#
SwarmSeedPool

source
pub(all) struct SwarmSeedPool {
  id : String
  seeds : Array[Int]
} derive(Eq, 
Debug)

#
SwarmSeedPool::make

source
fn SwarmSeedPool::make(id~ : String, seeds~ : Array[Int]) -> SwarmSeedPool

#
TopologyFaultHit

source
pub(all) struct TopologyFaultHit {
  seed : Int
  step : Int
  kind : TopologyFaultKind
  label : String
} derive(Eq, 
Debug)

#
TopologyFaultHit::make

source
fn TopologyFaultHit::make(seed~ : Int, step~ : Int, kind~ : TopologyFaultKind) -> TopologyFaultHit

#
TopologyFaultHit::to_trace_event

source
fn TopologyFaultHit::to_trace_event(self : TopologyFaultHit, event_id~ : Int, vtime~ : 
VTime, clock_domain~ : String, node_id~ : String, medium_id~ : String, backend~ : 
BackendProfile) -> 
TraceEvent

#
TopologyFaultKind

source
pub(all) enum TopologyFaultKind {
  Partition
  Heal
} derive(Eq, 
Debug)

#
TopologyFaultKind::code

source
fn TopologyFaultKind::code(self : TopologyFaultKind) -> Int

#
TopologyFaultKind::label

source
fn TopologyFaultKind::label(self : TopologyFaultKind) -> String

#
buggify_swarm_coverage_report_fixture

source
fn buggify_swarm_coverage_report_fixture() -> FaultCampaignCoverageReport

#
buggify_swarm_seed_pool_fixture

source
fn buggify_swarm_seed_pool_fixture() -> FaultCampaignReport

#
buggify_swarm_trace_fixture

source
fn buggify_swarm_trace_fixture(report : FaultCampaignReport) -> 
TraceLog

#
default_buggify_gates

source
fn default_buggify_gates() -> Array[BuggifyGate]

#
default_swarm_seed_pool

source
fn default_swarm_seed_pool() -> SwarmSeedPool

#
fault_campaign_coverage_report

source
fn fault_campaign_coverage_report(report : FaultCampaignReport) -> FaultCampaignCoverageReport

#
package_id

source
fn package_id() -> String

#
run_buggify_swarm_seed_pool

source
fn run_buggify_swarm_seed_pool(seed_pool : SwarmSeedPool, gates : Array[BuggifyGate]) -> FaultCampaignReport

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io