🥮 mooncakes.io

    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 issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io