Struct fuzzcheck::mutators::vector::VecMutator

pub struct VecMutator<T, M> where
    T: Clone + 'static,
    M: Mutator<T>,  { /* fields omitted */ }

Implementations

impl<T, M> VecMutator<T, M> where
    T: Clone + 'static,
    M: Mutator<T>, 

pub fn new(m: M, len_range: RangeInclusive<usize>) -> Self

Trait Implementations

impl<T, M> Mutation<Vec<T, Global>, VecMutator<T, M>> for InsertElement where
    T: Clone + 'static,
    M: Mutator<T>, 

type RandomStep = InsertElementRandomStep

type Step = InsertElementStep<M::ArbitraryStep>

type Concrete = ConcreteInsertElement<T>

type Revert = RevertInsertElement

fn default_random_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>
) -> Option<Self::RandomStep>

fn random<'a>(
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    _random_step: &Self::RandomStep,
    max_cplx: f64
) -> Self::Concrete

fn default_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache
) -> Option<Self::Step>

fn from_step<'a>(
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    step: &'a mut Self::Step,
    max_cplx: f64
) -> Option<Self::Concrete>

fn apply<'a>(
    mutation: Self::Concrete,
    mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    _max_cplx: f64
) -> (Self::Revert, f64)

impl<T, M> Mutation<Vec<T, Global>, VecMutator<T, M>> for InsertManyElements where
    T: Clone + 'static,
    M: Mutator<T>, 

type RandomStep = InsertManyElementsStep

type Step = InsertManyElementsStep

type Concrete = ConcreteInsertManyElements<T>

type Revert = RevertInsertManyElements

fn default_random_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>
) -> Option<Self::RandomStep>

fn random<'a>(
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    random_step: &Self::RandomStep,
    max_cplx: f64
) -> Self::Concrete

fn default_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache
) -> Option<Self::Step>

fn from_step<'a>(
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    step: &'a mut Self::Step,
    max_cplx: f64
) -> Option<Self::Concrete>

fn apply<'a>(
    mutation: Self::Concrete,
    mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    _max_cplx: f64
) -> (Self::Revert, f64)

impl<T, M> Mutation<Vec<T, Global>, VecMutator<T, M>> for MutateElement where
    T: Clone + 'static,
    M: Mutator<T>, 

type RandomStep = MutateElementRandomStep

type Step = MutateElementStep<M::MutationStep>

type Concrete = ConcreteMutateElement<'a, M::MutationStep>

type Revert = RevertMutateElement<M::UnmutateToken>

fn default_random_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>
) -> Option<Self::RandomStep>

fn random<'a>(
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    _random_step: &Self::RandomStep,
    _max_cplx: f64
) -> Self::Concrete

fn default_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache
) -> Option<Self::Step>

fn from_step<'a>(
    mutator: &VecMutator<T, M>,
    _value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    step: &'a mut Self::Step,
    _max_cplx: f64
) -> Option<Self::Concrete>

fn apply<'a>(
    mutation: Self::Concrete,
    mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    max_cplx: f64
) -> (Self::Revert, f64)

impl<T, M> Mutation<Vec<T, Global>, VecMutator<T, M>> for OnlyChooseLength where
    T: Clone + 'static,
    M: Mutator<T>, 

type RandomStep = OnlyChooseLengthRandomStep

type Step = OnlyChooseLengthStep

type Concrete = ConcreteOnlyChooseLength

type Revert = RevertOnlyChooseLength<T>

fn default_random_step(
    &self,
    mutator: &VecMutator<T, M>,
    _value: &Vec<T>
) -> Option<Self::RandomStep>

fn random<'a>(
    mutator: &VecMutator<T, M>,
    _value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    _random_step: &Self::RandomStep,
    max_cplx: f64
) -> Self::Concrete

fn default_step(
    &self,
    mutator: &VecMutator<T, M>,
    _value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache
) -> Option<Self::Step>

fn from_step<'a>(
    mutator: &VecMutator<T, M>,
    _value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    step: &'a mut Self::Step,
    max_cplx: f64
) -> Option<Self::Concrete>

fn apply<'a>(
    mutation: Self::Concrete,
    mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    _cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    _max_cplx: f64
) -> (Self::Revert, f64)

impl<T, M> Mutation<Vec<T, Global>, VecMutator<T, M>> for Remove where
    T: Clone + 'static,
    M: Mutator<T>, 

type RandomStep = RemoveStep

type Step = RemoveStep

type Concrete = ConcreteRemove

type Revert = RevertRemove<T>

fn default_random_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>
) -> Option<Self::RandomStep>

fn random<'a>(
    _mutator: &VecMutator<T, M>,
    _value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    random_step: &Self::RandomStep,
    _max_cplx: f64
) -> Self::Concrete

fn default_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache
) -> Option<Self::Step>

fn from_step<'a>(
    _mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    step: &'a mut Self::Step,
    _max_cplx: f64
) -> Option<Self::Concrete>

fn apply<'a>(
    mutation: Self::Concrete,
    mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    _max_cplx: f64
) -> (Self::Revert, f64)

impl<T, M> Mutation<Vec<T, Global>, VecMutator<T, M>> for SwapElements where
    T: Clone + 'static,
    M: Mutator<T>, 

type RandomStep = SwapElementsStep

type Step = SwapElementsStep

type Concrete = ConcreteSwapElements

type Revert = RevertSwapElements

fn default_random_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>
) -> Option<Self::RandomStep>

fn random<'a>(
    _mutator: &VecMutator<T, M>,
    _value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    random_step: &Self::RandomStep,
    _max_cplx: f64
) -> Self::Concrete

fn default_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache
) -> Option<Self::Step>

fn from_step<'a>(
    _mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    step: &'a mut Self::Step,
    _max_cplx: f64
) -> Option<Self::Concrete>

fn apply<'a>(
    mutation: Self::Concrete,
    mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    _max_cplx: f64
) -> (Self::Revert, f64)

impl<T, M> Mutation<Vec<T, Global>, VecMutator<T, M>> for VectorMutation where
    T: Clone + 'static,
    M: Mutator<T>, 

type RandomStep = VectorMutationRandomStep<T, M>

type Step = VectorMutationStep<T, M>

type Concrete = ConcreteVectorMutation<'a, T, M>

type Revert = RevertVectorMutation<T, M>

fn default_random_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>
) -> Option<Self::RandomStep>

fn random<'a>(
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    step: &Self::RandomStep,
    max_cplx: f64
) -> Self::Concrete

fn default_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache
) -> Option<Self::Step>

fn from_step<'a>(
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    step: &'a mut Self::Step,
    max_cplx: f64
) -> Option<Self::Concrete>

fn apply<'a>(
    mutation: Self::Concrete,
    mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    max_cplx: f64
) -> (Self::Revert, f64)

impl<T, M> Mutation<Vec<T, Global>, VecMutator<T, M>> for RemoveAndInsertElement where
    T: Clone + 'static,
    M: Mutator<T>, 

type RandomStep = RemoveAndInsertElementRandomStep

type Step = RemoveAndInsertElementRandomStep

type Concrete = ConcreteRemoveAndInsertElement<T>

type Revert = RevertRemoveAndInsertElement<T>

fn default_random_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>
) -> Option<Self::RandomStep>

fn random<'a>(
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    _random_step: &Self::RandomStep,
    max_cplx: f64
) -> Self::Concrete

fn default_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache
) -> Option<Self::Step>

fn from_step<'a>(
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    step: &'a mut Self::Step,
    max_cplx: f64
) -> Option<Self::Concrete>

fn apply<'a>(
    mutation: Self::Concrete,
    _mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    _cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    _max_cplx: f64
) -> (Self::Revert, f64)

impl<T, M> Mutation<Vec<T, Global>, VecMutator<T, M>> for Arbitrary where
    T: Clone + 'static,
    M: Mutator<T>, 

type RandomStep = ArbitraryStep

type Step = ArbitraryStep

type Concrete = ConcreteArbitrary<T>

type Revert = RevertArbitrary<T>

fn default_random_step(
    &self,
    mutator: &VecMutator<T, M>,
    _value: &Vec<T>
) -> Option<Self::RandomStep>

fn random<'a>(
    mutator: &VecMutator<T, M>,
    _value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    _random_step: &Self::RandomStep,
    max_cplx: f64
) -> Self::Concrete

fn default_step(
    &self,
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    _cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache
) -> Option<Self::Step>

fn from_step<'a>(
    mutator: &VecMutator<T, M>,
    value: &Vec<T>,
    cache: &<VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    step: &'a mut Self::Step,
    max_cplx: f64
) -> Option<Self::Concrete>

fn apply<'a>(
    mutation: Self::Concrete,
    _mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    _cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache,
    _max_cplx: f64
) -> (Self::Revert, f64)

impl<T, M> Mutator<Vec<T, Global>> for VecMutator<T, M> where
    T: Clone + 'static,
    M: Mutator<T>, 

type Cache = VecMutatorCache<T, M>

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

type MutationStep = VectorMutationStep<T, M>

Contains information about what mutations have already been tried.

type ArbitraryStep = VecArbitraryStep

Contains information about what arbitrary values have already been generated.

type UnmutateToken = RevertVectorMutation<T, M>

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: &Vec<T>) -> Option<Self::Cache>

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

fn default_mutation_step(
    &self,
    value: &Vec<T>,
    cache: &Self::Cache
) -> Self::MutationStep

Returns the first MutationStep associated with the value and cache.

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

Computes the complexity of the value.

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

Generates an entirely new value based on the given ArbitraryStep.

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

Generates an entirely new value.

fn ordered_mutate(
    &self,
    value: &mut Vec<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.

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

Mutates a value (and optionally its cache).

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

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

type RecursingPartIndex: Clone

fn default_recursing_part_index(
    &self,
    value: &Value,
    cache: &Self::Cache
) -> Self::RecursingPartIndex

fn recursing_part<'a, T, M>(
    &self,
    parent: &M,
    value: &'a Value,
    index: &mut Self::RecursingPartIndex
) -> Option<&'a T> where
    T: Clone + 'static,
    M: Mutator<T>, 

impl<T, M> RevertMutation<Vec<T, Global>, VecMutator<T, M>> for RevertInsertElement where
    T: Clone + 'static,
    M: Mutator<T>, 

fn revert(
    self,
    _mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    _cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache
)

impl<T, M> RevertMutation<Vec<T, Global>, VecMutator<T, M>> for RevertInsertManyElements where
    T: Clone + 'static,
    M: Mutator<T>, 

fn revert(
    self,
    _mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    _cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache
)

impl<T, M> RevertMutation<Vec<T, Global>, VecMutator<T, M>> for RevertMutateElement<M::UnmutateToken> where
    T: Clone + 'static,
    M: Mutator<T>, 

fn revert(
    self,
    mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache
)

impl<T, M> RevertMutation<Vec<T, Global>, VecMutator<T, M>> for RevertOnlyChooseLength<T> where
    T: Clone + 'static,
    M: Mutator<T>, 

fn revert(
    self,
    _mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    _cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache
)

impl<T, M> RevertMutation<Vec<T, Global>, VecMutator<T, M>> for RevertRemove<T> where
    T: Clone + 'static,
    M: Mutator<T>, 

fn revert(
    self,
    _mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    _cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache
)

impl<T, M> RevertMutation<Vec<T, Global>, VecMutator<T, M>> for RevertSwapElements where
    T: Clone + 'static,
    M: Mutator<T>, 

fn revert(
    self,
    _mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    _cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache
)

impl<T, M> RevertMutation<Vec<T, Global>, VecMutator<T, M>> for RevertVectorMutation<T, M> where
    T: Clone + 'static,
    M: Mutator<T>, 

fn revert(
    self,
    mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache
)

impl<T, M> RevertMutation<Vec<T, Global>, VecMutator<T, M>> for RevertRemoveAndInsertElement<T> where
    T: Clone + 'static,
    M: Mutator<T>, 

fn revert(
    self,
    _mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    _cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache
)

impl<T, M> RevertMutation<Vec<T, Global>, VecMutator<T, M>> for RevertArbitrary<T> where
    T: Clone + 'static,
    M: Mutator<T>, 

fn revert(
    self,
    _mutator: &VecMutator<T, M>,
    value: &mut Vec<T>,
    _cache: &mut <VecMutator<T, M> as Mutator<Vec<T>>>::Cache
)