Struct fuzzcheck_mutators::Tuple7Mutator

pub struct Tuple7Mutator<T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M3, M4, M5, M6> where
    T0: Clone,
    M0: Mutator<T0>,
    T1: Clone,
    M1: Mutator<T1>,
    T2: Clone,
    M2: Mutator<T2>,
    T3: Clone,
    M3: Mutator<T3>,
    T4: Clone,
    M4: Mutator<T4>,
    T5: Clone,
    M5: Mutator<T5>,
    T6: Clone,
    M6: Mutator<T6>,  {
    pub mutator_0: M0,
    pub mutator_1: M1,
    pub mutator_2: M2,
    pub mutator_3: M3,
    pub mutator_4: M4,
    pub mutator_5: M5,
    pub mutator_6: M6,
    // some fields omitted
}

Fields

mutator_0: M0

mutator_1: M1

mutator_2: M2

mutator_3: M3

mutator_4: M4

mutator_5: M5

mutator_6: M6

Implementations

impl<T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M3, M4, M5, M6> Tuple7Mutator<T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M3, M4, M5, M6> where
    T0: Clone,
    M0: Mutator<T0>,
    T1: Clone,
    M1: Mutator<T1>,
    T2: Clone,
    M2: Mutator<T2>,
    T3: Clone,
    M3: Mutator<T3>,
    T4: Clone,
    M4: Mutator<T4>,
    T5: Clone,
    M5: Mutator<T5>,
    T6: Clone,
    M6: Mutator<T6>, 

pub fn new(
    mutator_0: M0,
    mutator_1: M1,
    mutator_2: M2,
    mutator_3: M3,
    mutator_4: M4,
    mutator_5: M5,
    mutator_6: M6
) -> Self

pub fn replacing_mutator_0<M>(
    self,
    mutator: M
) -> Tuple7Mutator<T0, T1, T2, T3, T4, T5, T6, M, M1, M2, M3, M4, M5, M6> where
    M: Mutator<T0>, 

pub fn replacing_mutator_1<M>(
    self,
    mutator: M
) -> Tuple7Mutator<T0, T1, T2, T3, T4, T5, T6, M0, M, M2, M3, M4, M5, M6> where
    M: Mutator<T1>, 

pub fn replacing_mutator_2<M>(
    self,
    mutator: M
) -> Tuple7Mutator<T0, T1, T2, T3, T4, T5, T6, M0, M1, M, M3, M4, M5, M6> where
    M: Mutator<T2>, 

pub fn replacing_mutator_3<M>(
    self,
    mutator: M
) -> Tuple7Mutator<T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M, M4, M5, M6> where
    M: Mutator<T3>, 

pub fn replacing_mutator_4<M>(
    self,
    mutator: M
) -> Tuple7Mutator<T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M3, M, M5, M6> where
    M: Mutator<T4>, 

pub fn replacing_mutator_5<M>(
    self,
    mutator: M
) -> Tuple7Mutator<T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M3, M4, M, M6> where
    M: Mutator<T5>, 

pub fn replacing_mutator_6<M>(
    self,
    mutator: M
) -> Tuple7Mutator<T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M3, M4, M5, M> where
    M: Mutator<T6>, 

Trait Implementations

impl<T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M3, M4, M5, M6> Default for Tuple7Mutator<T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M3, M4, M5, M6> where
    T0: Clone,
    M0: Mutator<T0>,
    T1: Clone,
    M1: Mutator<T1>,
    T2: Clone,
    M2: Mutator<T2>,
    T3: Clone,
    M3: Mutator<T3>,
    T4: Clone,
    M4: Mutator<T4>,
    T5: Clone,
    M5: Mutator<T5>,
    T6: Clone,
    M6: Mutator<T6>,
    M0: Default,
    M1: Default,
    M2: Default,
    M3: Default,
    M4: Default,
    M5: Default,
    M6: Default, 

fn default() -> Self

Returns the "default value" for a type.

impl<T, T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M3, M4, M5, M6> TupleMutator<T, Tuple7<T0, T1, T2, T3, T4, T5, T6>> for Tuple7Mutator<T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M3, M4, M5, M6> where
    T: Clone,
    T0: Clone + 'static,
    M0: Mutator<T0>,
    T1: Clone + 'static,
    M1: Mutator<T1>,
    T2: Clone + 'static,
    M2: Mutator<T2>,
    T3: Clone + 'static,
    M3: Mutator<T3>,
    T4: Clone + 'static,
    M4: Mutator<T4>,
    T5: Clone + 'static,
    M5: Mutator<T5>,
    T6: Clone + 'static,
    M6: Mutator<T6>,
    T: TupleStructure<Tuple7<T0, T1, T2, T3, T4, T5, T6>>, 

type Cache = Cache<<M0 as Mutator<T0>>::Cache, <M1 as Mutator<T1>>::Cache, <M2 as Mutator<T2>>::Cache, <M3 as Mutator<T3>>::Cache, <M4 as Mutator<T4>>::Cache, <M5 as Mutator<T5>>::Cache, <M6 as Mutator<T6>>::Cache>

type MutationStep = MutationStep<<M0 as Mutator<T0>>::MutationStep, <M1 as Mutator<T1>>::MutationStep, <M2 as Mutator<T2>>::MutationStep, <M3 as Mutator<T3>>::MutationStep, <M4 as Mutator<T4>>::MutationStep, <M5 as Mutator<T5>>::MutationStep, <M6 as Mutator<T6>>::MutationStep>

type ArbitraryStep = ArbitraryStep<<M0 as Mutator<T0>>::ArbitraryStep, <M1 as Mutator<T1>>::ArbitraryStep, <M2 as Mutator<T2>>::ArbitraryStep, <M3 as Mutator<T3>>::ArbitraryStep, <M4 as Mutator<T4>>::ArbitraryStep, <M5 as Mutator<T5>>::ArbitraryStep, <M6 as Mutator<T6>>::ArbitraryStep>

type UnmutateToken = UnmutateToken<<M0 as Mutator<T0>>::UnmutateToken, <M1 as Mutator<T1>>::UnmutateToken, <M2 as Mutator<T2>>::UnmutateToken, <M3 as Mutator<T3>>::UnmutateToken, <M4 as Mutator<T4>>::UnmutateToken, <M5 as Mutator<T5>>::UnmutateToken, <M6 as Mutator<T6>>::UnmutateToken>

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn complexity<'a>(
    &'a self,
    _value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6),
    cache: &'a Self::Cache
) -> f64

fn cache_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6)
) -> Self::Cache

fn initial_step_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6)
) -> Self::MutationStep

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<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6),
    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 T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6),
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6),
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)