Enum Result_

pub enum Result_ {
    NoErrors,
    BadMalloc,
    Crash,
    Death,
    Exit,
    Leak,
    Oom,
    Timeout,
    Minimized,
    Cleansed,
    Merged,
    // some variants omitted
}

Indicates the result of a long-running fuzzing workflow.

Fuzzers have several “long-running” workflows; that is, the fuzzer may perform actions for an indefinite period of time. Fuzzing itself is the most notable example, as the fuzzing engine may continuously generate new inputs until an error is found. This workflow is represented by the Fuzz method below. Other long-running workflows include TryOne, Cleanse, Minimize and Merge.

These workflows continue executing after their associated call returns. Only one workflow at a time may be executing. Callers can use AddMonitor to monitor the status of the workflow, and GetArtifact to retrieve the Result and optionally associated Input when it completes.

Variants

NoErrors

The associated input did not cause any errors to be detected when tried.

BadMalloc

Trying the associated input triggered a memory allocation by an instrumented process that exceeded the configured limit. Some fuzzing engines, such as libFuzzer, may not distinguish between this result and OOM. To differentiate, examine the fuzzer output.

Crash

Trying the associated input triggered an exception in an instrumented process.

Death

Trying the associated input triggered an error in an instrumented process that was detected by a sanitizer runtime.

Exit

Trying the associated input caused an instrumented process to exit unexpectedly. Some fuzzing engines such as libFuzzer may combine this result with CRASH. To differentiate, examine the fuzzer output.

Leak

Trying the associated input triggered a memory leak in an instrumented process.

Oom

Trying the associated input caused an instrumented process’s memory usage to exceed the configured limit.

Timeout

Trying the associated input took longer than the configured limit.

Minimized

The associated input was produced by finding the shortest input that produces the same error as an original input. See Minimize.

Cleansed

The associated input was produced by replacing bytes in an original input with PII-free values while preserving the error produced. See Cleanse.

Merged

The fuzzer corpus has been compacted to only include the shortest inputs that preserve overall coverage. This workflow does not have an associated input. See Merge.

Implementations

impl Result_

pub fn from_primitive(prim: u32) -> Option<Self>

pub fn from_primitive_allow_unknown(prim: u32) -> Self

pub fn unknown() -> Self

pub const fn into_primitive(self) -> u32

pub fn is_unknown(&self) -> bool

Trait Implementations

impl Clone for Result_

fn clone(&self) -> Result_

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Result_

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

Formats the value using the given formatter.

impl<D: ResourceDialect> Decode<Result_, D> for Result_

fn new_empty() -> Self

Creates a valid instance of Self. The specific value does not matter, since it will be overwritten by decode.

unsafe fn decode( &mut self, decoder: &mut Decoder<'_, D>, offset: usize, _depth: Depth, ) -> Result<()>

Decodes an object of type T from the decoder’s buffers into self.

impl<D: ResourceDialect> Encode<Result_, D> for Result_

unsafe fn encode( self, encoder: &mut Encoder<'_, D>, offset: usize, _depth: Depth, ) -> Result<()>

Encodes the object into the encoder’s buffers. Any handles stored in the object are swapped for Handle::INVALID.

impl Hash for Result_

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Result_

fn cmp(&self, other: &Result_) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Result_

fn eq(&self, other: &Result_) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Result_

fn partial_cmp(&self, other: &Result_) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl TypeMarker for Result_

type Owned = Result_

The owned Rust type which this FIDL type decodes into.

fn inline_align(_context: Context) -> usize

Returns the minimum required alignment of the inline portion of the encoded object. It must be a (nonzero) power of two.

fn inline_size(_context: Context) -> usize

Returns the size of the inline portion of the encoded object, including padding for alignment. Must be a multiple of inline_align.

fn encode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and encoding requires no validation. When true, we can optimize encoding arrays and vectors of Self::Owned to a single memcpy.

fn decode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and decoding requires no validation. When true, we can optimize decoding arrays and vectors of Self::Owned to a single memcpy.

impl ValueTypeMarker for Result_

type Borrowed<'a> = Result_

The Rust type to use for encoding. This is a particular Encode<Self> type cheaply obtainable from &Self::Owned. There are three cases:

fn borrow(value: &<Self as TypeMarker>::Owned) -> Self::Borrowed<'_>

Cheaply converts from &Self::Owned to Self::Borrowed.

impl Copy for Result_

impl Eq for Result_

impl StructuralPartialEq for Result_