Enum DiffValue

pub enum DiffValue {
    I32(i32),
    I64(i64),
    F32(u32),
    F64(u64),
    V128(u128),
    FuncRef {
        null: bool,
    },
    ExternRef {
        null: bool,
    },
    AnyRef {
        null: bool,
    },
}

A value passed to and from evaluation. Note that reference types are not (yet) supported.

Variants

I32(i32)

I64(i64)

F32(u32)

F64(u64)

V128(u128)

FuncRef

Fields

null: bool

ExternRef

Fields

null: bool

AnyRef

Fields

null: bool

Implementations

impl DiffValue

pub fn arbitrary_of_type( u: &mut Unstructured<'_>, ty: DiffValueType, ) -> Result<Self>

Generate a DiffValue of the given ty type.

This function will bias the returned value 50% of the time towards one of a set of known values (e.g., NaN, -1, 0, infinity, etc.).

Trait Implementations

impl<'a> Arbitrary<'a> for DiffValue

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for DiffValue

fn clone(&self) -> DiffValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DiffValue

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

Formats the value using the given formatter.

impl From<&DiffValue> for SpecValue

fn from(v: &DiffValue) -> Self

Converts to this type from the input type.

impl From<&DiffValue> for Val

fn from(v: &DiffValue) -> Self

Converts to this type from the input type.

impl From<&DiffValue> for Val

fn from(v: &DiffValue) -> Self

Converts to this type from the input type.

impl From<Val> for DiffValue

fn from(value: Val) -> Self

Converts to this type from the input type.

impl Hash for DiffValue

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 Into<DiffValue> for SpecValue

fn into(self) -> DiffValue

Converts this type into the (usually inferred) input type.

impl Into<DiffValue> for Val

fn into(self) -> DiffValue

Converts this type into the (usually inferred) input type.

impl PartialEq for DiffValue

Implement equality checks. Note that floating-point values are not compared bit-for-bit in the case of NaNs: because Wasm floating-point numbers may be arithmetic NaNs with arbitrary payloads and Wasm operations are not required to propagate NaN payloads, we simply check that both sides are NaNs here. We could be more strict, though: we could check that the NaN signs are equal and that canonical NaN payloads remain canonical.

fn eq(&self, other: &Self) -> 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.