Struct fuzzcheck_mutators::BoxMutator

pub struct BoxMutator<T: Clone, M: Mutator<T>> {
    pub mutator: M,
    // some fields omitted
}

Fields

mutator: M

Implementations

impl<T: Clone, M: Mutator<T>> BoxMutator<T, M>

pub fn new(mutator: M) -> Self

Trait Implementations

impl<T: Clone, M: Mutator<T>> Default for BoxMutator<T, M> where
    M: Default, 

fn default() -> Self

Returns the "default value" for a type.

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

type Cache = M::Cache

type MutationStep = M::MutationStep

type ArbitraryStep = M::ArbitraryStep

type UnmutateToken = M::UnmutateToken

fn cache_from_value(&self, value: &Box<T>) -> Self::Cache

Compute the cache for the given value

fn initial_step_from_value(&self, value: &Box<T>) -> Self::MutationStep

Compute the initial mutation step for the given value

fn max_complexity(&self) -> f64

The maximum complexity of an input of this type

fn min_complexity(&self) -> f64

The minimum complexity of an input of this type

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

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

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

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

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

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