README

Magic486/moon_mutest/run does not have a README file

#
FileMutationPlan

#
MutationCandidate

#
MutationFilter

#
ProjectMutation

#
ProjectMutationPlan

#
BaselineOutcome

pub(all) enum BaselineOutcome {
BaselinePassed
BaselineFailed
BaselineTimedOut
BaselineIncomplete
} derive(Eq, ToJson,
Debug
)

#
BaselineReport

pub(all) struct BaselineReport {
outcome : BaselineOutcome
command_count : Int
executed_count : Int
failed_index : Int?
failed_phase : CommandPhase?
can_run_mutants : Bool
detail : String
} derive(Eq, ToJson,
Debug
)

#
BatchPlan

pub(all) struct BatchPlan {
strategy : BatchStrategy
selection : SelectionMode
batch_count : Int
execution_count : Int
command_count : Int
estimated_timeout_ms : Int
valid : Bool
message : String
batches : Array[ExecutionBatch]
} derive(Eq, ToJson,
Debug
)

#
BatchStrategy

pub(all) enum BatchStrategy {
OneMutantPerBatch
FixedBatchSize(Int)
TargetBatchMillis(Int)
} derive(Eq, ToJson,
Debug
)

#
BatchValidation

pub(all) struct BatchValidation {
valid : Bool
message : String
} derive(Eq, ToJson,
Debug
)

#
CommandPhase

pub(all) enum CommandPhase {
CheckPhase
TestPhase
} derive(Eq, ToJson,
Debug
,
FromJson
)

#
CommandResult

pub(all) struct CommandResult {
phase : CommandPhase
exit_code : Int?
stdout : String
stderr : String
timed_out : Bool
} derive(Eq, ToJson,
Debug
)

#
ExecutionBatch

pub(all) struct ExecutionBatch {
batch_id : Int
start_index : Int
end_index : Int
execution_count : Int
command_count : Int
estimated_timeout_ms : Int
executions : Array[MutationExecution]
} derive(Eq, ToJson,
Debug
)

#
ExecutionPlan

pub(all) struct ExecutionPlan {
config : MutestConfig
project :
ProjectMutationPlan

executions : Array[MutationExecution]
truncated : Bool
} derive(Eq, ToJson,
Debug
)

#
FileRunReport

pub(all) struct FileRunReport {
file : String
total : Int
killed : Int
survived : Int
compile_error : Int
timeout : Int
skipped : Int
equivalent : Int
score_percent : Int
} derive(Eq, ToJson,
Debug
)

#
MutantOutcome

pub(all) enum MutantOutcome {
Killed
Survived
CompileError
Timeout
Skipped
Equivalent
} derive(Eq, ToJson,
Debug
)

#
MutantResult

pub(all) struct MutantResult {
candidate :
MutationCandidate

outcome : MutantOutcome
detail : String
} derive(Eq, ToJson,
Debug
)

#
MutationExecution

pub(all) struct MutationExecution {
mutation :
ProjectMutation

edit : TextEdit
restore_edit : TextEdit
commands : Array[RunnerCommand]
} derive(Eq, ToJson,
Debug
)

#
MutationRunReport

pub(all) struct MutationRunReport {
file : String
total : Int
killed : Int
survived : Int
compile_error : Int
timeout : Int
skipped : Int
equivalent : Int
score_percent : Int
} derive(Eq, ToJson,
Debug
)

#
MutestConfig

pub(all) struct MutestConfig {
include_kinds : Array[
MutationKind
]
include_labels : Array[String]
line_start : Int?
line_end : Int?
commands : Array[RunnerCommand]
fail_fast : Bool
max_mutants : Int?
report_format : ReportFormat
} derive(Eq, ToJson,
Debug
,
FromJson
)

#
MutestConfig::default

fn MutestConfig::default() -> MutestConfig

#
PatchPreview

pub(all) struct PatchPreview {
file : String
line : Int
before : String
after : String
diff : String
} derive(Eq, ToJson,
Debug
)

#
ProjectMutantResult

pub(all) struct ProjectMutantResult {
mutation :
ProjectMutation

outcome : MutantOutcome
detail : String
} derive(Eq, ToJson,
Debug
)

#
ProjectRunReport

pub(all) struct ProjectRunReport {
file_count : Int
mutation_count : Int
killed : Int
survived : Int
compile_error : Int
timeout : Int
skipped : Int
equivalent : Int
score_percent : Int
files : Array[FileRunReport]
results : Array[ProjectMutantResult]
} derive(Eq, ToJson,
Debug
)

#
QualityGate

pub(all) struct QualityGate {
min_score_percent : Int
max_survived : Int?
max_compile_error : Int?
max_timeout : Int?
max_skipped : Int?
} derive(Eq, ToJson,
Debug
)

#
QualityGate::default

fn QualityGate::default() -> QualityGate

#
QualityGate::strict

fn QualityGate::strict(min_score_percent? : Int) -> QualityGate

#
QualityGateReport

pub(all) struct QualityGateReport {
status : QualityGateStatus
score_percent : Int
scored_mutants : Int
total_mutants : Int
killed : Int
survived : Int
compile_error : Int
timeout : Int
skipped : Int
equivalent : Int
violations : Array[QualityGateViolation]
message : String
} derive(Eq, ToJson,
Debug
)

#
QualityGateStatus

pub(all) enum QualityGateStatus {
GatePassed
GateFailed
GateNoSignal
} derive(Eq, ToJson,
Debug
)

#
QualityGateViolation

pub(all) struct QualityGateViolation {
metric : String
actual : Int
limit : Int
message : String
} derive(Eq, ToJson,
Debug
)

#
ReportFormat

pub(all) enum ReportFormat {
TextReport
MarkdownReport
JsonReport
} derive(Eq, ToJson,
Debug
,
FromJson
)

#
RunnerCommand

pub(all) struct RunnerCommand {
phase : CommandPhase
command : String
timeout_ms : Int
} derive(Eq, ToJson,
Debug
,
FromJson
)

#
RunnerScript

pub(all) struct RunnerScript {
dialect : ShellDialect
selection : SelectionMode
mutant_count : Int
content : String
} derive(Eq, ToJson,
Debug
)

#
SelectionMode

pub(all) enum SelectionMode {
AllMutants
FirstMutants(Int)
IdRange(start~ : Int, end~ : Int)
Shard(shard_index~ : Int, shard_count~ : Int)
} derive(Eq, ToJson,
Debug
)

#
SelectionReport

pub(all) struct SelectionReport {
mode : SelectionMode
input_count : Int
selected_count : Int
skipped_count : Int
selected_ids : Array[Int]
valid : Bool
message : String
} derive(Eq, ToJson,
Debug
)

#
SelectionValidation

pub(all) struct SelectionValidation {
valid : Bool
message : String
} derive(Eq, ToJson,
Debug
)

#
ShellDialect

pub(all) enum ShellDialect {
BashDialect
PowerShellDialect
} derive(Eq, ToJson,
Debug
)

#
TextEdit

pub(all) struct TextEdit {
file : String
start : Int
end : Int
original : String
replacement : String
line : Int
column : Int
} derive(Eq, ToJson,
Debug
)

#
apply_edit

fn apply_edit(source : String, edit : TextEdit) -> String?

#
apply_mutation

fn apply_mutation(source : String, candidate :
MutationCandidate
) -> String

#
baseline_can_run

fn baseline_can_run(report : BaselineReport) -> Bool

#
baseline_outcome_label

fn baseline_outcome_label(outcome : BaselineOutcome) -> String

#
build_batch_plan

fn build_batch_plan(plan : ExecutionPlan, strategy : BatchStrategy) -> BatchPlan

#
build_execution_plan

#
build_execution_plan_with_profile

#
build_selected_batch_plan

fn build_selected_batch_plan(plan : ExecutionPlan, selection : SelectionMode, strategy : BatchStrategy) -> BatchPlan

#
classify_baseline

fn classify_baseline(expected : ArrayView[RunnerCommand], results : ArrayView[CommandResult]) -> BaselineReport

#
classify_command_result

#
classify_project_sequence

#
classify_sequence

#
command_failure

fn command_failure(phase : CommandPhase, code : Int, stdout? : String, stderr? : String) -> CommandResult

#
command_phase_label

fn command_phase_label(phase : CommandPhase) -> String

#
command_success

fn command_success(phase : CommandPhase) -> CommandResult

#
command_timeout

fn command_timeout(phase : CommandPhase, detail? : String) -> CommandResult

#
config_to_json_string

fn config_to_json_string(config : MutestConfig, indent? : Int) -> String

#
default_commands

fn default_commands() -> Array[RunnerCommand]

#
diagnose_mutant_result

fn diagnose_mutant_result(result : ProjectMutantResult) -> String

#
discover_with_rules

#
edit_for_candidate

#
edit_for_project_mutation

fn edit_for_project_mutation(mutation :
ProjectMutation
) -> TextEdit

#
estimate_execution_timeout_ms

fn estimate_execution_timeout_ms(execution : MutationExecution) -> Int

#
evaluate_quality_gate

fn evaluate_quality_gate(report : ProjectRunReport, gate : QualityGate) -> QualityGateReport

#
evaluate_quality_gate_after_baseline

fn evaluate_quality_gate_after_baseline(report : ProjectRunReport, gate : QualityGate, baseline : BaselineReport) -> QualityGateReport

#
execution_by_mutation_id

fn execution_by_mutation_id(plan : ExecutionPlan, global_id : Int) -> MutationExecution?

#
file_risk_level

fn file_risk_level(file : FileRunReport) -> String

#
format_baseline_report

fn format_baseline_report(report : BaselineReport) -> String

#
format_batch_plan

fn format_batch_plan(plan : BatchPlan) -> String

#
format_batch_strategy

fn format_batch_strategy(strategy : BatchStrategy) -> String

#
format_config

fn format_config(config : MutestConfig) -> String

#
format_execution_plan

fn format_execution_plan(plan : ExecutionPlan) -> String

#
format_html_run_report

fn format_html_run_report(report : ProjectRunReport) -> String

#
format_markdown_project_plan

fn format_markdown_project_plan(plan :
ProjectMutationPlan
) -> String

#
format_markdown_run_report

fn format_markdown_run_report(report : ProjectRunReport) -> String

#
format_quality_gate

fn format_quality_gate(gate : QualityGate) -> String

#
format_quality_gate_report

fn format_quality_gate_report(report : QualityGateReport) -> String

#
format_result

fn format_result(result : MutantResult) -> String

#
format_run_report

fn format_run_report(report : MutationRunReport) -> String

#
format_runner_command

fn format_runner_command(command : RunnerCommand) -> String

#
format_runner_script

fn format_runner_script(script : RunnerScript) -> String

#
format_selection_mode

fn format_selection_mode(mode : SelectionMode) -> String

#
format_selection_report

fn format_selection_report(report : SelectionReport) -> String

#
format_survived_diagnostics

fn format_survived_diagnostics(report : ProjectRunReport) -> String

#
format_unified_diff

fn format_unified_diff(file : String, line : Int, before : String, after : String) -> String

#
generate_runner_script

fn generate_runner_script(plan : ExecutionPlan, dialect : ShellDialect) -> RunnerScript

#
generate_selected_runner_script

fn generate_selected_runner_script(plan : ExecutionPlan, mode : SelectionMode, dialect : ShellDialect) -> RunnerScript

#
invert_edit

fn invert_edit(edit : TextEdit) -> TextEdit

#
mutation_kind_label

fn mutation_kind_label(kind :
MutationKind
) -> String

#
mutation_risk_level

fn mutation_risk_level(report : ProjectRunReport) -> String

#
mutation_risk_summary

fn mutation_risk_summary(report : ProjectRunReport) -> String

#
outcome_label

fn outcome_label(outcome : MutantOutcome) -> String

#
parse_config_json

fn parse_config_json(text : String) -> MutestConfig raise

#
preview_candidate_patch

fn preview_candidate_patch(source : String, candidate :
MutationCandidate
) -> PatchPreview?

#
preview_project_mutation_patch

fn preview_project_mutation_patch(source : String, mutation :
ProjectMutation
) -> PatchPreview?

#
project_result

fn project_result(mutation :
ProjectMutation
, outcome : MutantOutcome, detail? : String) -> ProjectMutantResult

#
quality_gate_status_label

fn quality_gate_status_label(status : QualityGateStatus) -> String

#
report_format_label

fn report_format_label(format : ReportFormat) -> String

#
result

#
risk_ranked_files

fn risk_ranked_files(report : ProjectRunReport) -> Array[FileRunReport]

#
select_executions

fn select_executions(plan : ExecutionPlan, mode : SelectionMode) -> Array[MutationExecution]

#
shell_dialect_label

fn shell_dialect_label(dialect : ShellDialect) -> String

#
skip_execution_results_for_baseline

fn skip_execution_results_for_baseline(plan : ExecutionPlan, report : BaselineReport) -> Array[ProjectMutantResult]

#
summarize_execution_selection

fn summarize_execution_selection(plan : ExecutionPlan, mode : SelectionMode) -> SelectionReport

#
summarize_project_selection

#
summarize_results

fn summarize_results(file : String, results : ArrayView[MutantResult]) -> MutationRunReport

#
validate_batch_strategy

fn validate_batch_strategy(strategy : BatchStrategy) -> BatchValidation

#
validate_edit

fn validate_edit(source : String, edit : TextEdit) -> Bool

#
validate_selection_mode

fn validate_selection_mode(mode : SelectionMode) -> SelectionValidation

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io