Struct FunctionRunner 

struct FunctionRunner<'a, FEN: FoundryEvmNetwork> {
    tcfg: Cow<'a, TestRunnerConfig<FEN>>,
    executor: Cow<'a, Executor<FEN>>,
    cr: &'a ContractRunner<'a, FEN>,
    address: Address,
    setup: &'a TestSetup,
    result: TestResult,
}

Executes a single test function, returning a TestResult.

Fields

tcfg: Cow<'a, TestRunnerConfig<FEN>>

The function-level configuration.

executor: Cow<'a, Executor<FEN>>

The EVM executor.

cr: &'a ContractRunner<'a, FEN>

The parent runner.

address: Address

The address of the test contract.

setup: &'a TestSetup

The test setup result.

result: TestResult

The test result. Returned after running the test.

Implementations

impl<'a, FEN: FoundryEvmNetwork> FunctionRunner<'a, FEN>

fn new(cr: &'a ContractRunner<'a, FEN>, setup: &'a TestSetup) -> Self

const fn revert_decoder(&self) -> &'a RevertDecoder

fn fuzz_progress( &self, test_name: &str, timeout: Option<u32>, runs: u32, ) -> Option<ProgressBar>

Creates the progress bar for a fuzz or invariant campaign, if progress is shown.

fn fuzz_minimize_target_id(&self, test_name: &str) -> String

fn symbolic_artifact( &self, test_name: &str, kind: SymbolicCounterexampleArtifactKind, symbolic: &SymbolicResult, fail_on_revert: bool, calls: Vec<SymbolicCounterexampleCall>, ) -> SymbolicCounterexampleArtifact

Builds a symbolic counterexample artifact for this test.

fn write_symbolic_artifact( &self, file_name: &str, artifact: &SymbolicCounterexampleArtifact, ) -> Option<SymbolicArtifactRef>

Writes artifact to the stable per-test path, so the latest counterexample replaces older ones, and returns a reference to it.

fn persist_sequence_artifact( &self, test_name: &str, file_name: &str, calls: Vec<SymbolicCounterexampleCall>, fail_on_revert: bool, storage: &[SymbolicStorageAssignment], failure: Option<SymbolicInvariantArtifactFailure>, ) -> Option<SymbolicArtifactRef>

Persists a replay-confirmed stateful counterexample as a sequence artifact.

fn sequence_calls( &self, call_sequence: &[BaseCounterExample], ) -> Vec<SymbolicCounterexampleCall>

Converts a counterexample sequence into artifact calls.

fn replay_confirmed_symbolic_single_call( &self, call: &SymbolicCounterexampleCall, expected_reason: Option<&str>, ) -> Result<(RawCallResult<FEN>, Option<String>), String>

Replays a single-call minimization candidate and checks it fails for expected_reason.

fn replay_invariant_error_sequence( &mut self, replay: SequenceReplay<'_>, original_calls: &[BasicTxDetails], inner_sequence: Option<Vec<Option<BasicTxDetails>>>, identified_contracts: &ContractsByAddress, current_settings: &InvariantSettings, artifact: SequenceArtifactSpec<'_>, progress: Option<&ProgressBar>, position: Option<(usize, usize)>, ) -> Result<ReplayedInvariantSequence>

Shrinks and replays a failing invariant call sequence, persisting the confirmed counterexample as a symbolic artifact.

fn replay_error( &mut self, config: InvariantConfig, executor: Executor<FEN>, calls: &[BasicTxDetails], inner_sequence: Option<Vec<Option<BasicTxDetails>>>, expect_assertion_failure: bool, target_value: Option<I256>, invariant_contract: &InvariantContract<'_>, target_invariant: &Function, identified_contracts: &ContractsByAddress, progress: Option<&ProgressBar>, position: Option<(usize, usize)>, ) -> Result<ReplayErrorResult>

Shrinks and replays a failing call sequence, collecting logs, traces and coverage into the test result. Returns the counterexample, the terminal check outcome when shrinking re-checked the sequence, and the fork block number.

fn minimize_symbolic_invariant_sequence( &self, replay: SequenceReplay<'_>, calls: &[BasicTxDetails], identified_contracts: &ContractsByAddress, current_settings: &InvariantSettings, ) -> Option<MinimizedSequence>

fn symbolic_sequence_sender_candidates( &self, current_settings: &InvariantSettings, ) -> Vec<Address>

fn symbolic_sequence_failure( &self, replay: SequenceReplay<'_>, calls: &[SymbolicCounterexampleCall], ) -> Option<CheckSequenceOutcome>

Replays calls concretely and returns the outcome if the sequence still fails.

fn replay_persisted_call_sequence( &self, invariant_contract: &InvariantContract<'_>, call_sequence: &mut [BaseCounterExample], expect_assertion_failure: bool, storage: &[SymbolicStorageAssignment], ) -> Result<(Vec<BasicTxDetails>, CheckSequenceOutcome)>

Converts a persisted counterexample into transactions (applying show_solidity in place) and replays it through check_sequence.

fn replay_persisted_handler_failures( &self, handlers_dir: &Path, current_settings: &InvariantSettings, ) -> (HashMap<(Address, Selector), InvariantFuzzError>, HashMap<(Address, Selector, B256), SymbolicHandlerReplayStorage>)

Replays persisted handler-side assertion bugs. A file is kept only if the anchor still asserts at the same (reverter, selector) site; stale files (anchor no longer asserts, asserts at a different site, or earlier call asserts) are deleted in place.

fn apply_function_inline_config(&mut self, func: &Function) -> Result<()>

Configures this runner with the inline configuration for the contract.

fn run( self, func: &Function, invariants: &[&Function], shared_invariant_namespace: bool, kind: TestFunctionKind, call_after_invariant: bool, identified_contracts: Option<&ContractsByAddress>, ) -> TestResult

fn run_unit_test(self, func: &Function) -> TestResult

Runs a single unit test.

Applies before test txes (if any), runs current test and returns the TestResult.

Before test txes are applied in order and state modifications committed to the EVM database (therefore the unit test call will be made on modified state). State modifications of before test txes and unit test function call are discarded after test ends, similar to eth_call.

fn call_test( &mut self, func: &Function, args: &[DynSolValue], ) -> Result<(RawCallResult<FEN>, Option<String>), ()>

Calls func on the test contract, returning the raw result and revert reason. Skipped and failed calls are recorded in the test result and returned as Err.

fn symbolic_run_input<'f>( &'f self, func: &'f Function, sender: Address, collect_success_input: bool, corpus_seeds: Vec<SymbolicConcreteInput>, branch_target: Option<SymbolicBranchTarget>, ) -> SymbolicRunInput<'f, FEN>

Builds the symbolic executor input for one run of func.

fn fuzz_test_paths<'f>( &self, func: &'f Function, fuzz_config: &mut FuzzConfig, ) -> (Cow<'f, str>, Option<PathBuf>, (PathBuf, PathBuf))

Sets the per-test corpus directory in fuzz_config and returns the test path name, the legacy corpus directory and the persisted failure (dir, file) paths.

fn import_symbolic_fuzz_corpus( &self, func: &Function, ) -> (Vec<SymbolicConcreteInput>, Option<SymbolicCorpusSeedMetadata>)

Imports persisted fuzz corpus entries as symbolic path-priority hints.

fn import_symbolic_fuzz_frontiers( &self, func: &Function, fuzz_config: &FuzzConfig, ) -> Vec<(u64, Address, SymbolicBranchTarget, SymbolicConcreteInput)>

Imports persisted fuzz branch frontiers as (id, sender, branch target, input) seeds.

fn import_symbolic_invariant_frontiers( &self, invariant_contract: &InvariantContract<'_>, invariant_config: &InvariantConfig, ) -> Vec<(FuzzBranchFrontierRecord, Arc<[BasicTxDetails]>)>

fn symbolic_corpus_seed_input( &self, func: &Function, tx_seq: &[BasicTxDetails], ) -> Option<SymbolicConcreteInput>

fn run_symbolic_test(self, func: &Function) -> TestResult

Runs a symbolic test and replays any discovered counterexample concretely.

fn replay_symbolic_counterexample( &mut self, func: &Function, args: Vec<DynSolValue>, calldata: Bytes, stats: SymbolicStats, symbolic_config: &SymbolicConfig, ) -> (TestStatus, Option<String>, Option<CounterExample>, SymbolicResult)

Replays a symbolic counterexample concretely, minimizing and persisting it when it reproduces.

fn run_symbolic_artifact_replay( self, func: &Function, invariants: &[&Function], call_after_invariant: bool, ) -> TestResult

Replays a durable symbolic counterexample artifact against this freshly set up test.

fn replay_symbolic_artifact( &mut self, func: &Function, invariants: &[&Function], call_after_invariant: bool, ) -> Result<(), String>

Replays a persisted symbolic counterexample artifact against func, failing with the mismatch reason when the recorded outcome does not reproduce.

fn try_seed_fuzz_corpus_from_frontiers( &self, func: &Function, fuzz_config: &FuzzConfig, )

fn invariant_sequence_failure_site( &self, invariant_contract: &InvariantContract<'_>, invariant_idx: usize, sequence: &[BasicTxDetails], replay_order: &[usize], call_after_invariant: bool, ) -> Option<CheckSequenceFailureSite>

fn solve_invariants_from_frontier_prefix( &self, invariant_contract: &InvariantContract<'_>, invariant_indexes: &[usize], prefix_executor: &Executor<FEN>, target: &SymbolicInvariantTarget, sender: Address, prefix: &[BasicTxDetails], ) -> Vec<(usize, CheckSequenceFailureSite, Vec<BasicTxDetails>)>

fn try_seed_invariant_corpus_from_frontiers( &self, invariant_contract: &InvariantContract<'_>, invariant_config: &InvariantConfig, sender_filters: &SenderFilters, targeted_contracts: &FuzzRunIdentifiedContracts, dynamic_target_ctx: &DynamicTargetCtx<'_>, )

fn try_seed_fuzz_corpus_symbolically( &self, func: &Function, fuzz_config: &FuzzConfig, )

fn persist_symbolic_fuzz_seed( &self, corpus: &FuzzCorpusConfig, sender: Address, calldata: Bytes, ) -> Result<Option<PathBuf>>

Persists a concretely confirmed symbolic input as a fuzz corpus seed.

fn symbolic_fuzz_seed_replay( &self, sender: Address, input: &SymbolicConcreteInput, fuzz_config: &FuzzConfig, ) -> Option<bool>

Replays a symbolic seed concretely: Some(success), or None if the input was rejected.

fn run_table_test(self, func: &Function) -> TestResult

Runs a table test. The parameters dataset (table) is created from defined parameter fixtures, therefore each test table parameter should have the same number of fixtures defined. E.g. for table test

• table_test(uint256 amount, bool swap) fixtures are defined as
• uint256[] public fixtureAmount = [2, 5]
• bool[] public fixtureSwap = [true, false] The table_test is then called with the pair of args (2, true) and (5, false).

fn run_invariant_test( self, func: &Function, invariants: Vec<(&Function, bool)>, shared_invariant_namespace: bool, call_after_invariant: bool, identified_contracts: &ContractsByAddress, ) -> TestResult

fn sort_predicate_results( &self, results: impl Iterator<Item = InvariantPredicateResult>, ) -> Vec<InvariantPredicateResult>

Orders predicate results by their declaration position in the test contract ABI.

fn invariant_skip_reason(&self, func: &Function) -> Option<SkipReason>

fn run_fuzz_test(self, func: &Function) -> TestResult

Runs a fuzzed test.

Applies the before test txes (if any), fuzzes the current function and returns the TestResult.

Before test txes are applied in order and state modifications committed to the EVM database (therefore the fuzz test will use the modified state). State modifications of before test txes and fuzz test are discarded after test ends, similar to eth_call.

fn prepare_test(&mut self, func: &Function) -> Result<(), ()>

fn fuzz_runner(&self) -> TestRunner

fn run_showmap( self, func: &Function, test_name: &str, corpus_dir: Option<PathBuf>, showmap: &ShowmapConfig, target: ShowmapReplayTarget<'_>, ) -> TestResult

Replays the persisted corpus and writes AFL-afl-showmap-style files.

fn invariant_runner(&self) -> TestRunner

fn clone_executor(&self) -> Executor<FEN>

fn clone_executor_with_symbolic_storage( &self, storage: &[SymbolicStorageAssignment], ) -> Result<Executor<FEN>>

fn build_fuzz_state( &self, invariant: bool, func: Option<&Function>, ) -> EvmFuzzState

fn build_fuzz_state_uncached( &self, invariant: bool, config: FuzzDictionaryConfig, ) -> EvmFuzzState

Trait Implementations

impl<'a, FEN: FoundryEvmNetwork> Deref for FunctionRunner<'a, FEN>

type Target = Cow<'a, TestRunnerConfig<FEN>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.