Struct fuzzcheck_mutators::Enum1PayloadMutator

pub struct Enum1PayloadMutator<T0, M0, TupleKind0> where
    T0: Clone + TupleStructure<TupleKind0>,
    TupleKind0: RefTypes,
    M0: TupleMutator<T0, TupleKind0>,  {
    pub mutator_0: M0,
    // some fields omitted
}

Fields

mutator_0: M0

Implementations

impl<T0, M0, TupleKind0> Enum1PayloadMutator<T0, M0, TupleKind0> where
    T0: Clone + TupleStructure<TupleKind0>,
    TupleKind0: RefTypes,
    M0: TupleMutator<T0, TupleKind0>, 

pub fn new(mutator_0: M0) -> Self

Trait Implementations

impl<T0, M0, TupleKind0> Default for Enum1PayloadMutator<T0, M0, TupleKind0> where
    T0: Clone + TupleStructure<TupleKind0>,
    TupleKind0: RefTypes,
    M0: TupleMutator<T0, TupleKind0>,
    M0: Default, 

fn default() -> Self

Returns the "default value" for a type.

impl<T, T0, M0, TupleKind0> Mutator<T> for Enum1PayloadMutator<T0, M0, TupleKind0> where
    T: Clone + Enum1PayloadStructure<TupleKind0 = TupleKind0, T0 = T0>,
    T0: Clone + TupleStructure<TupleKind0>,
    M0: TupleMutator<T0, TupleKind0>,
    TupleKind0: RefTypes, 

type Cache = Either2<M0::Cache, ()>

type MutationStep = Enum1PayloadMutationStep<M0::MutationStep, Self::ArbitraryStep>

type ArbitraryStep = Enum1PayloadArbitraryStep<M0::ArbitraryStep>

type UnmutateToken = Either2<M0::UnmutateToken, (T, Self::Cache)>

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

Compute the cache for the given value

fn initial_step_from_value(&self, value: &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: &T, cache: &Self::Cache) -> f64

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

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

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

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

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