Struct fuzzcheck::mutators::unique::UniqueMutator

pub struct UniqueMutator<T, TH, Focus, M> where
    T: Clone + 'static,
    TH: Hash,
    M: Mutator<T>,
    Focus: Fn(&T) -> &TH, { /* private fields */ }

Experimental mutator which tries to prevent duplicate values to be tested, using a bloom filter

Important: this mutator cannot be used as a submutator.

Implementations

impl<T, TH, Focus, M> UniqueMutator<T, TH, Focus, M> where
    T: Clone + 'static,
    TH: Hash,
    M: Mutator<T>,
    Focus: Fn(&T) -> &TH, 

pub fn new(mutator: M, focus: Focus) -> Self

Create a new UniqueMutator by wrapping another mutator.

The Focus closure points to the hashable part of the value. This should almost always be the identity function. But there is an exception when we don’t care about some part of the generated value. For example, a grammar-based mutator implements Mutator<(AST, String)>, but it is very likely that the test function will only operate on the String and not the AST. In that case, the Focus closure is |x| &x.1.

Trait Implementations

impl<T, TH, Focus, M> Mutator<T> for UniqueMutator<T, TH, Focus, M> where
    T: Clone + 'static,
    TH: Hash,
    M: Mutator<T>,
    Focus: Fn(&T) -> &TH,
    Self: 'static, 

type Cache = <M as Mutator<T>>::Cache

Accompanies each value to help compute its complexity and mutate it efficiently.

type MutationStep = <M as Mutator<T>>::MutationStep

Contains information about what mutations have already been tried.

type ArbitraryStep = <M as Mutator<T>>::ArbitraryStep

Contains information about what arbitrary values have already been generated.

type UnmutateToken = <M as Mutator<T>>::UnmutateToken

Describes how to reverse a mutation

fn default_arbitrary_step(&self) -> Self::ArbitraryStep

The first ArbitraryStep value to be passed to ordered_arbitrary

fn is_valid(&self, value: &T) -> bool

Quickly verifies that the value conforms to the mutator’s expectations

fn validate_value(&self, value: &T) -> Option<Self::Cache>

Verifies that the value conforms to the mutator’s expectations and, if it does, returns the Cache associated with that value.

fn default_mutation_step(
    &self,
    value: &T,
    cache: &Self::Cache
) -> Self::MutationStep

Returns the first MutationStep associated with the value and cache.

fn max_complexity(&self) -> f64

The maximum complexity that a value can possibly have.

fn min_complexity(&self) -> f64

The minimum complexity that a value can possibly have.

fn complexity(&self, value: &T, cache: &Self::Cache) -> f64

Computes the complexity of the value.

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(T, f64)>

Generates an entirely new value based on the given ArbitraryStep.

fn random_arbitrary(&self, _max_cplx: f64) -> (T, f64)

Generates an entirely new value.

fn ordered_mutate(
    &self,
    value: &mut T,
    cache: &mut Self::Cache,
    step: &mut Self::MutationStep,
    subvalue_provider: &dyn SubValueProvider,
    max_cplx: f64
) -> Option<(Self::UnmutateToken, f64)>

Mutates a value (and optionally its cache) based on the given MutationStep.

fn random_mutate(
    &self,
    value: &mut T,
    cache: &mut Self::Cache,
    max_cplx: f64
) -> (Self::UnmutateToken, f64)

Mutates a value (and optionally its cache).

fn unmutate(&self, value: &mut T, cache: &mut Self::Cache, t: Self::UnmutateToken)

Undoes a mutation performed on the given value and cache, described by the given UnmutateToken.

fn visit_subvalues<'a>(
    &self,
    value: &'a T,
    cache: &'a Self::Cache,
    visit: &mut dyn FnMut(&'a dyn Any, f64)
)

Call the given closure on all subvalues and their complexities.

fn global_search_space_complexity(&self) -> f64

The log2 of the number of values that can be produced by this mutator, or an approximation of this number (e.g. the number of bits that are needed to identify each possible value).