Struct fuzzcheck::mutators::boxed::BoxMutator

pub struct BoxMutator<M> {
    pub mutator: M,
}

Fields

mutator: M

Implementations

impl<M> BoxMutator<M>

pub fn new(mutator: M) -> Self

Trait Implementations

impl<M: Default> Default for BoxMutator<M>

fn default() -> BoxMutator<M>

Returns the “default value” for a type.

impl<T: Clone, M: Mutator<T>> Mutator<Box<T, Global>> for BoxMutator<M>

type Cache = M::Cache

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

type MutationStep = M::MutationStep

Contains information about what mutations have already been tried.

type ArbitraryStep = M::ArbitraryStep

Contains information about what arbitrary values have already been generated.

type UnmutateToken = M::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 validate_value(
    &self,
    value: &Box<T>
) -> Option<(Self::Cache, Self::MutationStep)>

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

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: &Box<T>, cache: &Self::Cache) -> f64

Computes the complexity of the value.

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

Generates an entirely new value based on the given ArbitraryStep.

fn random_arbitrary(&self, max_cplx: f64) -> (Box<T>, f64)

Generates an entirely new value. The generated value should be smaller than the given max_cplx. However, if that is not possible, then it should return a value of the lowest possible complexity. Returns the value itself and its complexity, which must be equal to self.complexity(value, cache)

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

Mutates a value (and optionally its cache) based on the given MutationStep. The mutated value should be within the given max_cplx. Returns None if it no longer possible to mutate the value to a new state, or if it is not possible to keep it under max_cplx. Otherwise, return the UnmutateToken that describes how to undo the mutation as well as the new complexity of the value.

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

Mutates a value (and optionally its cache). The mutated value should be within the given max_cplx. But if that is not possible, then it should mutate the value so that it has a minimal complexity. Returns the UnmutateToken that describes how to undo the mutation as well as the new complexity of the value.

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

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