Struct MutationHandler 

pub struct MutationHandler {
    contract_to_mutate: PathBuf,
    pub src: Arc<String>,
    pub mutations: Vec<Mutant>,
    config: Arc<Config>,
    report: MutationsSummary,
    survived_spans: SurvivedSpans,
    contract_filter: Option<Regex>,
}

Fields

contract_to_mutate: PathBuf

src: Arc<String>

mutations: Vec<Mutant>

config: Arc<Config>

report: MutationsSummary

survived_spans: SurvivedSpans

contract_filter: Option<Regex>

Optional regex used to restrict mutation to specific contracts within the file (matches against contract name).

Implementations

impl MutationHandler

pub fn new(contract_to_mutate: PathBuf, config: Arc<Config>) -> Self

pub fn with_contract_filter(self, filter: Regex) -> Self

Restrict mutation to contracts whose name matches filter.

pub fn read_source_contract(&mut self) -> Result<(), Error>

pub fn add_dead_mutant(&mut self, mutant: Mutant)

Add a dead mutant to the report

pub fn add_survived_mutant(&mut self, mutant: Mutant)

Add a survived mutant to the report

pub fn add_invalid_mutant(&mut self, mutant: Mutant)

Add an invalid mutant to the report

pub fn add_skipped_mutant(&mut self, mutant: Mutant)

pub fn add_timed_out_mutant(&mut self, mutant: Mutant)

pub const fn get_report(&self) -> &MutationsSummary

Get a reference to the current report

fn cache_file_path(&self, hash: &str, kind: CacheKind<'_>) -> PathBuf

Returns the cache file path for the given build hash and cache kind. The filename encodes a hash of the full contract path to prevent collisions between files with the same stem in different directories, and a hash of the active mutation config so changes to enabled operators invalidate previously cached mutants. Result-like caches also include an execution key so stale outcomes are not reused after test/config/EVM changes.

pub fn persist_cached_mutants( &self, hash: &str, mutants: &[Mutant], ) -> Result<()>

Persists cached mutants using build hash for cache invalidation.

pub fn persist_cached_results( &self, hash: &str, execution_key: &str, mutants: &[Mutant], results: &[(Mutant, MutationResult)], ) -> Result<()>

Persists results for mutants using build hash for cache invalidation.

pub async fn generate_ast(&mut self) -> Result<()>

Read a source string, and for each contract found, gets its ast and visit it to list all mutations to conduct.

pub fn retrieve_cached_mutants(&self, hash: &str) -> Option<Vec<Mutant>>

Retrieves cached mutants using build hash.

pub fn retrieve_cached_mutant_results( &self, hash: &str, execution_key: &str, mutants: &[Mutant], ) -> Option<Vec<(Mutant, MutationResult)>>

Retrieves cached results using build hash.

pub fn mark_span_survived(&mut self, span: Span)

Mark a span as having a surviving mutation

pub fn should_skip_span(&self, span: Span) -> bool

Check if a span should be skipped (has survived mutation or is child of survived span)

pub fn persist_survived_spans( &self, hash: &str, execution_key: &str, ) -> Result<()>

Persist survived spans to cache for adaptive mutation testing.

pub fn retrieve_survived_spans( &mut self, hash: &str, execution_key: &str, ) -> bool

Retrieve survived spans from cache.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 264 bytes