Struct OptionalMutator

pub struct OptionalMutator<M> { /* private fields */ }

Mapping Mutator for dealing with input parts wrapped in Option.

Allows using Mutators for a certain type on (parts of) other input types that can be mapped to an Option of said type.

Returns MutationResult::Skipped if the mapper returns None.

Example

use libafl::{
   inputs::MutVecInput,
   mutators::{ByteIncMutator, MutationResult, Mutator, OptionalMutator},
   state::NopState,
};

let inner = ByteIncMutator::new();
let mut outer = OptionalMutator::new(inner);

let mut input_raw = vec![1];
let input: MutVecInput = (&mut input_raw).into();
let mut input_wrapped = Some(input);
let mut state: NopState<Option<MutVecInput>> = NopState::new();
let res = outer.mutate(&mut state, &mut input_wrapped).unwrap();
assert_eq!(res, MutationResult::Mutated);
assert_eq!(input_raw, vec![2]);

let mut empty_input: Option<MutVecInput> = None;
let res2 = outer.mutate(&mut state, &mut empty_input).unwrap();
assert_eq!(res2, MutationResult::Skipped);

Implementations

impl<M> OptionalMutator<M>

pub fn new(inner: M) -> Self

where M: Named,

Creates a new OptionalMutator

Trait Implementations

impl<M: Debug> Debug for OptionalMutator<M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I, S, M> Mutator<Option<I>, S> for OptionalMutator<M>

where M: Mutator<I, S>,

fn mutate( &mut self, state: &mut S, input: &mut Option<I>, ) -> Result<MutationResult, Error>

Mutate a given input

fn post_exec( &mut self, state: &mut S, new_corpus_id: Option<CorpusId>, ) -> Result<(), Error>

Post-process given the outcome of the execution new_corpus_id will be Some if a new crate::corpus::Testcase was created this execution.

impl<M> Named for OptionalMutator<M>

where M: Named,

fn name(&self) -> &Cow<'static, str>

Provide the name of this element.