Struct TestArgs 

pub struct TestArgs {

    pub global: GlobalArgs,
    pub path: Option<GlobMatcher>,
    debug: bool,
    flamegraph: bool,
    flamechart: bool,
    decode_internal: bool,
    dump: Option<PathBuf>,
    gas_report: bool,
    gas_snapshot_check: Option<bool>,
    gas_snapshot_emit: Option<bool>,
    allow_failure: bool,
    suppress_successful_traces: bool,
    pub junit: bool,
    pub fail_fast: bool,
    etherscan_api_key: Option<String>,
    list: bool,
    pub fuzz_seed: Option<U256>,
    pub fuzz_runs: Option<u64>,
    pub fuzz_timeout: Option<u64>,
    pub fuzz_input_file: Option<String>,
    pub show_progress: bool,
    pub rerun: bool,
    pub summary: bool,
    pub detailed: bool,
    pub disable_labels: bool,
    filter: FilterArgs,
    evm: EvmArgs,
    pub build: BuildOpts,
    pub watch: WatchArgs,
}

CLI arguments for forge test.

Fields

global: GlobalArgs

path: Option<GlobMatcher>

The contract file you want to test, it’s a shortcut for –match-path.

debug: bool

Run a single test in the debugger.

The matching test will be opened in the debugger regardless of the outcome of the test.

If the matching test is a fuzz test, then it will open the debugger on the first failure case. If the fuzz test does not fail, it will open the debugger on the last fuzz case.

flamegraph: bool

Generate a flamegraph for a single test. Implies --decode-internal.

A flame graph is used to visualize which functions or operations within the smart contract are consuming the most gas overall in a sorted manner.

flamechart: bool

Generate a flamechart for a single test. Implies --decode-internal.

A flame chart shows the gas usage over time, illustrating when each function is called (execution order) and how much gas it consumes at each point in the timeline.

decode_internal: bool

Identify internal functions in traces.

This will trace internal functions and decode stack parameters.

Parameters stored in memory (such as bytes or arrays) are currently decoded only when a single function is matched, similarly to --debug, for performance reasons.

dump: Option<PathBuf>

Dumps all debugger steps to file.

gas_report: bool

Print a gas report.

gas_snapshot_check: Option<bool>

Check gas snapshots against previous runs.

gas_snapshot_emit: Option<bool>

Enable/disable recording of gas snapshot results.

allow_failure: bool

Exit with code 0 even if a test fails.

suppress_successful_traces: bool

Suppress successful test traces and show only traces for failures.

junit: bool

Output test results as JUnit XML report.

fail_fast: bool

Stop running tests after the first failure.

etherscan_api_key: Option<String>

The Etherscan (or equivalent) API key.

list: bool

List tests instead of running them.

fuzz_seed: Option<U256>

Set seed used to generate randomness during your fuzz runs.

fuzz_runs: Option<u64>

fuzz_timeout: Option<u64>

Timeout for each fuzz run in seconds.

fuzz_input_file: Option<String>

File to rerun fuzz failures from.

show_progress: bool

Show test execution progress.

rerun: bool

Re-run recorded test failures from last run. If no failure recorded then regular test run is performed.

summary: bool

Print test summary table.

detailed: bool

Print detailed test summary table.

disable_labels: bool

Disables the labels in the traces.

filter: FilterArgs

evm: EvmArgs

build: BuildOpts

watch: WatchArgs

Implementations

impl TestArgs

pub async fn run(self) -> Result<TestOutcome>

pub fn get_sources_to_compile( &self, config: &Config, test_filter: &ProjectPathsAwareFilter, ) -> Result<BTreeSet<PathBuf>>

Returns a list of files that need to be compiled in order to run all the tests that match the given filter.

This means that it will return all sources that are not test contracts or that match the filter. We want to compile all non-test sources always because tests might depend on them dynamically through cheatcodes.

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

Executes all the tests in the project.

This will trigger the build process first. On success all test contracts that match the configured filter will be executed

Returns the test results for all matching tests.

pub async fn run_tests( &mut self, project_root: &Path, config: Config, evm_opts: EvmOpts, output: &ProjectCompileOutput, filter: &ProjectPathsAwareFilter, coverage: bool, ) -> Result<TestOutcome>

Executes all the tests in the project.

See Self::compile_and_run for more details.

async fn run_tests_inner( &self, runner: MultiContractRunner, config: Arc<Config>, verbosity: u8, filter: &ProjectPathsAwareFilter, output: &ProjectCompileOutput, ) -> Result<TestOutcome>

Run all tests that matches the filter predicate from a test runner

pub fn filter(&self, config: &Config) -> Result<ProjectPathsAwareFilter>

Returns the flattened FilterArgs arguments merged with [Config]. Loads and applies filter from file if only last test run failures performed.

pub fn is_watch(&self) -> bool

Returns whether BuildArgs was configured with --watch

pub(crate) fn watchexec_config(&self) -> Result<Config>

Returns the [watchexec::Config] necessary to bootstrap a new watch loop.

Trait Implementations

impl Args for TestArgs

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

impl Clone for TestArgs

fn clone(&self) -> TestArgs

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CommandFactory for TestArgs

fn command<'b>() -> Command

Build a [Command] that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a [Command] that can update self.

impl Debug for TestArgs

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> From<&'a TestArgs> for Figment

fn from(args: &'a TestArgs) -> Self

Converts to this type from the input type.

impl FromArgMatches for TestArgs

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for TestArgs

fn parse() -> Self

Parse from std::env::args_os(), [exit][Error::exit] on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, [exit][Error::exit] on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, [exit][Error::exit] on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.

impl Provider for TestArgs

fn metadata(&self) -> Metadata

Returns the [Metadata] for this provider, identifying itself and its configuration sources.

fn data(&self) -> Result<Map<Profile, Dict>, Error>

Returns the configuration data.

fn profile(&self) -> Option<Profile>

Optionally returns a profile to set on the Figment this provider is merged into. The profile is only set if self is merged.

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