Struct fuzzcheck::sensors_and_pools::ArrayOfCounters

pub struct ArrayOfCounters<const N: usize> { /* fields omitted */ }

A custom sensor consisting of an array of counters that can be manually set.

use fuzzcheck::sensors_and_pools::ArrayOfCounters;
// the “counters” array must be a static item
static mut COUNTERS: [u64; 2] = [0; 2];

// inside the fuzz test, you can create the sensor as follows
let sensor = ArrayOfCounters::new(unsafe { &mut COUNTERS });

fn test_function(x: &[bool]) {
    // you can then manually instrument a test function by changing the values of COUNTERS
    unsafe {
        COUNTERS[0] = x.len() as u64;
    }
    // ...
    unsafe {
        COUNTERS[1] = x.len() as u64;
    }
    // ...
}

The ObservationHandler of this sensor has the same type as the one from the default code coverage sensor. Therefore, most pools that are compatible with the code coverage sensor will also be compatible with the ArrayOfCounters sensor.

You can also use a different pool such as the UniqueValuesPool

Implementations

impl<const N: usize> ArrayOfCounters<N>

pub fn new(xs: &'static mut [u64; N]) -> Self

pub fn offset_counter_id_by(self, offset: usize) -> Self

pub fn len(&self) -> usize

Trait Implementations

impl<const N: usize> Sensor for ArrayOfCounters<N>

type ObservationHandler = &'a mut dyn FnMut((usize, u64))

A type that is used to retrieve the observations made by the sensor.

fn start_recording(&mut self)

Signal to the sensor that it should prepare to record observations

fn stop_recording(&mut self)

Signal to the sensor that it should stop recording observations

fn iterate_over_observations(&mut self, handler: Self::ObservationHandler)

Access the sensor’s observations through the handler