Trait ExecutionProcessor

pub trait ExecutionProcessor<EM, I, OT, S> {
    // Required methods
    fn check_results(
        &mut self,
        state: &mut S,
        manager: &mut EM,
        input: &I,
        observers: &OT,
        exit_kind: &ExitKind,
    ) -> Result<ExecuteInputResult, Error>;
    fn process_execution(
        &mut self,
        state: &mut S,
        manager: &mut EM,
        input: &I,
        exec_res: &ExecuteInputResult,
        exit_kind: &ExitKind,
        observers: &OT,
    ) -> Result<Option<CorpusId>, Error>;
    fn serialize_and_dispatch(
        &mut self,
        state: &mut S,
        manager: &mut EM,
        input: &I,
        exec_res: &ExecuteInputResult,
        observers: &OT,
        exit_kind: &ExitKind,
    ) -> Result<(), Error>;
    fn dispatch_event(
        &mut self,
        state: &mut S,
        manager: &mut EM,
        input: &I,
        exec_res: &ExecuteInputResult,
        obs_buf: Option<Vec<u8>>,
        exit_kind: &ExitKind,
    ) -> Result<(), Error>;
    fn evaluate_execution(
        &mut self,
        state: &mut S,
        manager: &mut EM,
        input: &I,
        observers: &OT,
        exit_kind: &ExitKind,
        send_events: bool,
    ) -> Result<(ExecuteInputResult, Option<CorpusId>), Error>;
}

Evaluates if an input is interesting using the feedback

Required Methods

fn check_results( &mut self, state: &mut S, manager: &mut EM, input: &I, observers: &OT, exit_kind: &ExitKind, ) -> Result<ExecuteInputResult, Error>

Check the outcome of the execution, find if it is worth for corpus or objectives

fn process_execution( &mut self, state: &mut S, manager: &mut EM, input: &I, exec_res: &ExecuteInputResult, exit_kind: &ExitKind, observers: &OT, ) -> Result<Option<CorpusId>, Error>

Process ExecuteInputResult. Add to corpus, solution or ignore

fn serialize_and_dispatch( &mut self, state: &mut S, manager: &mut EM, input: &I, exec_res: &ExecuteInputResult, observers: &OT, exit_kind: &ExitKind, ) -> Result<(), Error>

serialize and send event via manager

fn dispatch_event( &mut self, state: &mut S, manager: &mut EM, input: &I, exec_res: &ExecuteInputResult, obs_buf: Option<Vec<u8>>, exit_kind: &ExitKind, ) -> Result<(), Error>

send event via manager

fn evaluate_execution( &mut self, state: &mut S, manager: &mut EM, input: &I, observers: &OT, exit_kind: &ExitKind, send_events: bool, ) -> Result<(ExecuteInputResult, Option<CorpusId>), Error>

Evaluate if a set of observation channels has an interesting state

Implementors

impl<CS, EM, F, I, IC, IF, OF, OT, S> ExecutionProcessor<EM, I, OT, S> for StdFuzzer<CS, F, IC, IF, OF>

where CS: Scheduler<I, S>, EM: EventFirer<I, S>, F: Feedback<EM, I, OT, S>, I: Input, OF: Feedback<EM, I, OT, S>, OT: ObserversTuple<I, S> + Serialize, S: HasCorpus<I> + MaybeHasClientPerfMonitor + HasExecutions + HasCurrentTestcase<I> + HasSolutions<I> + HasLastFoundTime,