Function arbitrary_val

crates/fuzzing/src/oracles/component_api.rs:34–161

Generate an arbitrary instance of the specified type.

(
    ty: &component::Type,
    fuel: &mut u32,
    input: &mut Unstructured,
)

/// Generate an arbitrary instance of the specified type.
fn arbitrary_val(
    ty: &component::Type,
    fuel: &mut u32,
    input: &mut Unstructured,
) -> arbitrary::Result<Val> {
    use component::Type;

    *fuel = fuel.saturating_sub(1);
    Ok(match ty {
        Type::Bool => Val::Bool(input.arbitrary()?),
        Type::S8 => Val::S8(input.arbitrary()?),
        Type::U8 => Val::U8(input.arbitrary()?),
        Type::S16 => Val::S16(input.arbitrary()?),
        Type::U16 => Val::U16(input.arbitrary()?),
        Type::S32 => Val::S32(input.arbitrary()?),
        Type::U32 => Val::U32(input.arbitrary()?),
        Type::S64 => Val::S64(input.arbitrary()?),
        Type::U64 => Val::U64(input.arbitrary()?),
        Type::Float32 => Val::Float32(input.arbitrary()?),
        Type::Float64 => Val::Float64(input.arbitrary()?),
        Type::Char => Val::Char(input.arbitrary()?),
        Type::String => {
            let string = if *fuel == 0 {
                String::new()
            } else {
                input.arbitrary()?
            };
            *fuel = fuel.saturating_sub(string.len() as u32);
            Val::String(string)
        }
        Type::List(list) => {
            let mut values = Vec::new();
            input.arbitrary_loop(Some(MIN_LIST_LENGTH), Some(MAX_LIST_LENGTH), |input| {
                if *fuel == 0 {
                    return Ok(ControlFlow::Break(()));
                }
                values.push(arbitrary_val(&list.ty(), fuel, input)?);

                Ok(ControlFlow::Continue(()))
            })?;

            Val::List(values)
        }
        Type::Record(record) => Val::Record(
            record
                .fields()
                .map(|field| {
                    Ok((
                        field.name.to_string(),
                        arbitrary_val(&field.ty, fuel, input)?,
                    ))
                })
                .collect::<arbitrary::Result<_>>()?,
        ),
        Type::Tuple(tuple) => Val::Tuple(
            tuple
                .types()
                .map(|ty| arbitrary_val(&ty, fuel, input))