Struct ContractRunner

pub struct ContractRunner<'a> {
    name: &'a str,
    contract: &'a TestContract,
    executor: Executor,
    progress: Option<&'a TestsProgress>,
    tokio_handle: &'a Handle,
    span: Span,
    tcfg: Cow<'a, TestRunnerConfig>,
    mcr: &'a MultiContractRunner,
}

A type that executes all tests of a contract

Fields

name: &'a str

The name of the contract.

contract: &'a TestContract

The data of the contract.

executor: Executor

The EVM executor.

progress: Option<&'a TestsProgress>

Overall test run progress.

tokio_handle: &'a Handle

The handle to the tokio runtime.

span: Span

The span of the contract.

tcfg: Cow<'a, TestRunnerConfig>

The contract-level configuration.

mcr: &'a MultiContractRunner

The parent runner.

Implementations

impl<'a> ContractRunner<'a>

pub fn new( name: &'a str, contract: &'a TestContract, executor: Executor, progress: Option<&'a TestsProgress>, tokio_handle: &'a Handle, span: Span, mcr: &'a MultiContractRunner, ) -> Self

pub fn setup(&mut self, call_setup: bool) -> TestSetup

Deploys the test contract inside the runner from the sending account, and optionally runs the setUp function on the test contract.

fn _setup(&mut self, call_setup: bool) -> Result<TestSetup>

fn initial_balance(&self) -> U256

fn apply_contract_inline_config(&mut self) -> Result<()>

Configures this runner with the inline configuration for the contract.

fn inline_config(&self, func: Option<&Function>) -> Result<Config>

Returns the configuration for a contract or function.

fn fuzz_fixtures(&mut self, address: Address) -> FuzzFixtures

Collect fixtures from test contract.

Fixtures can be defined:

• as storage arrays in test contract, prefixed with fixture
• as functions prefixed with fixture and followed by parameter name to be fuzzed

Storage array fixtures: uint256[] public fixture_amount = [1, 2, 3]; define an array of uint256 values to be used for fuzzing amount named parameter in scope of the current test.

Function fixtures: function fixture_owner() public returns (address[] memory){} returns an array of addresses to be used for fuzzing owner named parameter in scope of the current test.

pub fn run_tests(self, filter: &dyn TestFilter) -> SuiteResult

Runs all tests for a contract whose names match the provided regular expression

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 ContractRunner<'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: 5024 bytes