Struct fuzzcheck::mutators::integer::I8Mutator

pub struct I8Mutator { /* fields omitted */ }

Trait Implementations

impl Clone for I8Mutator

fn clone(&self) -> I8Mutator

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for I8Mutator

fn default() -> Self

Returns the “default value” for a type.

impl Mutator<i8> for I8Mutator

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

type Cache = ()

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

type MutationStep = u64

Contains information about what mutations have already been tried.

type ArbitraryStep = u64

Contains information about what arbitrary values have already been generated.

type UnmutateToken = i8

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: &i8
) -> Option<(Self::Cache, Self::MutationStep)>

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

fn complexity(&self, _value: &i8, _cache: &Self::Cache) -> f64

Computes the complexity of the value.

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

Generates an entirely new value based on the given ArbitraryStep.

fn random_arbitrary(&self, _max_cplx: f64) -> (i8, f64)

Generates an entirely new value. The generated value should be smaller than the given max_cplx. However, if that is not possible, then it should return a value of the lowest possible complexity. Returns the value itself and its complexity, which must be equal to self.complexity(value, cache)

fn ordered_mutate(
    &self,
    value: &mut i8,
    _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. The mutated value should be within the given max_cplx. Returns None if it no longer possible to mutate the value to a new state, or if it is not possible to keep it under max_cplx. Otherwise, return the UnmutateToken that describes how to undo the mutation as well as the new complexity of the value.

fn random_mutate(
    &self,
    value: &mut i8,
    _cache: &mut Self::Cache,
    _max_cplx: f64
) -> (Self::UnmutateToken, f64)

Mutates a value (and optionally its cache). The mutated value should be within the given max_cplx. But if that is not possible, then it should mutate the value so that it has a minimal complexity. Returns the UnmutateToken that describes how to undo the mutation as well as the new complexity of the value.

fn unmutate(
    &self,
    value: &mut i8,
    _cache: &mut Self::Cache,
    t: Self::UnmutateToken
)

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