Struct libafl::corpus::testcase::Testcase

pub struct Testcase<I>where
    I: Input,{ /* private fields */ }

An entry in the Testcase Corpus

Implementations

impl<I> Testcase<I>where
    I: Input,

Impl of a testcase

pub fn load_input(&mut self) -> Result<&I, Error>

Returns this testcase with a loaded input

pub fn store_input(&mut self) -> Result<bool, Error>

Store the input to disk if possible

pub fn input(&self) -> &Option<I>

Get the input, if any

pub fn input_mut(&mut self) -> &mut Option<I>

Get the input, if any (mutable)

pub fn set_input(&mut self, input: I)

Set the input

pub fn filename(&self) -> &Option<String>

Get the filename, if any

pub fn filename_mut(&mut self) -> &mut Option<String>

Get the filename, if any (mutable)

pub fn set_filename(&mut self, filename: String)

Set the filename

pub fn exec_time(&self) -> &Option<Duration>

Get the execution time of the testcase

pub fn exec_time_mut(&mut self) -> &mut Option<Duration>

Get the execution time of the testcase (mutable)

pub fn set_exec_time(&mut self, time: Duration)

Sets the execution time of the current testcase

pub fn executions(&self) -> &usize

Get the executions

pub fn executions_mut(&mut self) -> &mut usize

Get the executions (mutable)

pub fn fuzz_level(&self) -> usize

Get the fuzz_level

pub fn set_fuzz_level(&mut self, fuzz_level: usize)

Set the fuzz_level

pub fn fuzzed(&self) -> bool

Get if it was fuzzed

pub fn set_fuzzed(&mut self, fuzzed: bool)

Set if it was fuzzed

pub fn new(input: I) -> Self

Create a new Testcase instance given an input

pub fn with_filename(input: I, filename: String) -> Self

Create a new Testcase instance given an Input and a filename

pub fn with_executions(input: I, executions: usize) -> Self

Create a new Testcase instance given an Input and the number of executions

impl<I> Testcase<I>where
    I: Input + HasLen,

Impl of a testcase when the input has len

pub fn cached_len(&mut self) -> Result<usize, Error>

Get the cached len

Trait Implementations

impl<I> Clone for Testcase<I>where
    I: Input + Clone,

fn clone(&self) -> Testcase<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I> Debug for Testcase<I>where
    I: Input + Debug,

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

Formats the value using the given formatter.

impl<I> Default for Testcase<I>where
    I: Input,

fn default() -> Self

Create a new default Testcase

impl<'de, I> Deserialize<'de> for Testcase<I>where
    I: Input + DeserializeOwned,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I> From<I> for Testcase<I>where
    I: Input,

Create a testcase from an input

fn from(input: I) -> Self

Converts to this type from the input type.

impl<I> HasMetadata for Testcase<I>where
    I: Input,

fn metadata(&self) -> &SerdeAnyMap

Get all the metadata into an hashbrown::HashMap

fn metadata_mut(&mut self) -> &mut SerdeAnyMap

Get all the metadata into an hashbrown::HashMap (mutable)

fn add_metadata<M>(&mut self, meta: M)where
    M: SerdeAny,

Add a metadata to the metadata map

fn has_metadata<M>(&self) -> boolwhere
    M: SerdeAny,

Check for a metadata

impl<I> Serialize for Testcase<I>where
    I: Input + DeserializeOwned,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.