Struct fuzzcheck_mutators::Wrapped

pub struct Wrapped<T: 'static> { /* fields omitted */ }

Trait Implementations

impl<T: 'static> RefTypes for Wrapped<T>

type Owned = T

type Ref = &'a T

type Mut = &'a mut T

fn get_ref_from_mut<'a>(v: &'a Self::Mut) -> Self::Ref

impl<T, U, M> TupleMutator<U, Wrapped<T>> for Tuple1Mutator<T, M> where
    U: TupleStructure<Wrapped<T>>,
    T: Clone + 'static,
    M: Mutator<T>, 

type Cache = M::Cache

type MutationStep = M::MutationStep

type ArbitraryStep = M::ArbitraryStep

type UnmutateToken = M::UnmutateToken

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

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

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

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

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

fn random_arbitrary(&self, max_cplx: f64) -> (U, Self::Cache)

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

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

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