Struct FunctionRunner

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

Executes a single test function, returning a TestResult.

Fields

tcfg: Cow<'a, TestRunnerConfig>

The function-level configuration.

executor: Cow<'a, Executor>

The EVM executor.

cr: &'a ContractRunner<'a>

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> FunctionRunner<'a>

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

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

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, kind: TestFunctionKind, call_after_invariant: bool, identified_contracts: Option<&ContractsByAddress>, ) -> TestResult

fn run_unit_test(self, func: &Function, should_fail: bool) -> 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 run_invariant_test( self, func: &Function, call_after_invariant: bool, identified_contracts: &ContractsByAddress, ) -> TestResult

fn run_fuzz_test(self, func: &Function, should_fail: bool) -> 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<(), ()>

Prepares single unit test and fuzz test execution:

• set up the test result and executor
• check if before test txes are configured and apply them in order

Before test txes are arrays of arbitrary calldata obtained by calling the beforeTest function with test selector as a parameter.

Unit tests within same contract (or even current test) are valid options for before test tx configuration. Test execution stops if any of before test txes fails.

fn fuzz_runner(&self) -> TestRunner

fn invariant_runner(&self) -> TestRunner

fn clone_executor(&self) -> Executor

Methods from Deref<Target = Cow<'a, TestRunnerConfig>>

pub fn is_borrowed(&self) -> bool

🔬This is a nightly-only experimental API. (cow_is_borrowed)

Returns true if the data is borrowed, i.e. if to_mut would require additional work.

Examples

#![feature(cow_is_borrowed)]
use std::borrow::Cow;

let cow = Cow::Borrowed("moo");
assert!(cow.is_borrowed());

let bull: Cow<'_, str> = Cow::Owned("...moo?".to_string());
assert!(!bull.is_borrowed());

pub fn is_owned(&self) -> bool

🔬This is a nightly-only experimental API. (cow_is_borrowed)

Returns true if the data is owned, i.e. if to_mut would be a no-op.

Examples

#![feature(cow_is_borrowed)]
use std::borrow::Cow;

let cow: Cow<'_, str> = Cow::Owned("moo".to_string());
assert!(cow.is_owned());

let bull = Cow::Borrowed("...moo?");
assert!(!bull.is_owned());

Trait Implementations

impl<'a> Deref for FunctionRunner<'a>

type Target = Cow<'a, TestRunnerConfig>

The resulting type after dereferencing.

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

Dereferences the value.

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: 5600 bytes