Struct fuzzcheck::sensors_and_pools::AndPool

pub struct AndPool<P1, P2> where
    P1: Pool,
    P2: Pool,  {
    pub p1: P1,
    pub p2: P2,
    pub ratio_choose_first: u8,
    // some fields omitted
}

A pool that combines two pools

Fields

p1: P1

p2: P2

ratio_choose_first: u8

Implementations

impl<P1, P2> AndPool<P1, P2> where
    P1: Pool,
    P2: Pool, 

pub fn new(p1: P1, p2: P2, ratio_choose_first: u8) -> Self

Trait Implementations

impl<P1, P2> CompatibleWithIteratorSensor for AndPool<P1, P2> where
    P1: CompatibleWithIteratorSensor,
    P2: CompatibleWithIteratorSensor<Observation = P1::Observation>, 

type Observation = P1::Observation

type ObservationState = (P1::ObservationState, P2::ObservationState)

fn start_observing(&mut self) -> Self::ObservationState

fn observe(
    &mut self,
    observation: &Self::Observation,
    input_complexity: f64,
    state: &mut Self::ObservationState
)

fn is_interesting(
    &self,
    observation_state: &Self::ObservationState,
    input_complexity: f64
) -> bool

fn finish_observing(
    &mut self,
    state: &mut Self::ObservationState,
    input_complexity: f64
)

fn add(
    &mut self,
    input_id: PoolStorageIndex,
    complexity: f64,
    observation_state: Self::ObservationState
) -> Vec<CorpusDelta>

impl<S1, S2, P1, P2> CompatibleWithSensor<AndSensor<S1, S2>> for AndPool<P1, P2> where
    S1: Sensor,
    S2: Sensor,
    P1: Pool,
    P2: Pool,
    P1: CompatibleWithSensor<S1>,
    P2: CompatibleWithSensor<S2>, 

fn process(
    &mut self,
    input_id: PoolStorageIndex,
    sensor: &mut AndSensor<S1, S2>,
    complexity: f64
) -> Vec<CorpusDelta>

impl<P1, P2> Pool for AndPool<P1, P2> where
    P1: Pool,
    P2: Pool, 

type Stats = AndPoolStats<P1::Stats, P2::Stats>

Statistics about the pool to be printed to the terminal as the fuzzer is running and saved to a .csv file after the run

fn len(&self) -> usize

The number of test cases in the pool

fn stats(&self) -> Self::Stats

The pool’s statistics

fn get_random_index(&mut self) -> Option<PoolStorageIndex>

Get the index of a random test case.

fn mark_test_case_as_dead_end(&mut self, idx: PoolStorageIndex)

Mark a certain test case as a dead end.