Struct IntStrategy

pub struct IntStrategy {
    bits: usize,
    fixtures: Vec<DynSolValue>,
    edge_weight: usize,
    fixtures_weight: usize,
    random_weight: usize,
}

Value tree for signed ints (up to int256). The strategy combines 3 different strategies, each assigned a specific weight:

1. Generate purely random value in a range. This will first choose bit size uniformly (up bits param). Then generate a value for this bit size.
2. Generate a random value around the edges (+/- 3 around min, 0 and max possible value)
3. Generate a value from a predefined fixtures set

To define int fixtures:

• return an array of possible values for a parameter named amount declare a function function fixture_amount() public returns (int32[] memory).
• use amount named parameter in fuzzed test in order to include fixtures in fuzzed values function testFuzz_int32(int32 amount).

If fixture is not a valid int type then error is raised and random value generated.

Fields

bits: usize

Bit size of int (e.g. 256)

fixtures: Vec<DynSolValue>

A set of fixtures to be generated

edge_weight: usize

The weight for edge cases (+/- 3 around 0 and max possible value)

fixtures_weight: usize

The weight for fixtures

random_weight: usize

The weight for purely random values

Implementations

impl IntStrategy

pub fn new(bits: usize, fixtures: Option<&[DynSolValue]>) -> Self

Create a new strategy. #Arguments

• bits - Size of uint in bits
• fixtures - A set of fixed values to be generated (according to fixtures weight)

fn generate_edge_tree(&self, runner: &mut TestRunner) -> NewTree<Self>

fn generate_fixtures_tree(&self, runner: &mut TestRunner) -> NewTree<Self>

fn generate_random_tree(&self, runner: &mut TestRunner) -> NewTree<Self>

Trait Implementations

impl Debug for IntStrategy

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

Formats the value using the given formatter.

impl Strategy for IntStrategy

type Tree = IntValueTree

The value tree generated by this Strategy.

type Value = Signed<256, 4>

The type of value used by functions under test generated by this Strategy.

fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self>

Generate a new value tree from the given runner.

fn prop_map<O, F>(self, fun: F) -> Map<Self, F>

where O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

Returns a strategy which produces values transformed by the function fun.

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

Returns a strategy which produces values of type O by transforming Self with Into<O>.

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

Returns a strategy which produces values transformed by the function fun, which is additionally given a random number generator.

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

Maps values produced by this strategy into new strategies and picks values from those strategies.

fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

Maps values produced by this strategy into new strategies and picks values from those strategies while considering the new strategies to be independent.

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

Similar to prop_ind_flat_map(), but produces 2-tuples with the input generated from self in slot 0 and the derived strategy in slot 1.

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

Returns a strategy which only produces transformed values where fun returns Some(value) and rejects those where fun returns None.

fn prop_union(self, other: Self) -> Union<Self>

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

Erases the type of this Strategy so it can be passed around as a simple trait object.

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

Erases the type of this Strategy so it can be passed around as a simple trait object.

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

Wraps this strategy to prevent values from being subject to shrinking.

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