Function static_api_test

crates/fuzzing/src/oracles/component_api.rs:234–333

Generate zero or more sets of arbitrary argument and result values and execute the test using those values, asserting that they flow from host-to-guest and guest-to-host unchanged.

(
    input: &mut Unstructured<'a>,
    declarations: &Declarations,
)

/// Generate zero or more sets of arbitrary argument and result values and execute the test using those
/// values, asserting that they flow from host-to-guest and guest-to-host unchanged.
pub fn static_api_test<'a, P, R>(
    input: &mut Unstructured<'a>,
    declarations: &Declarations,
) -> arbitrary::Result<()>
where
    P: ComponentNamedList
        + Lift
        + Lower
        + Clone
        + PartialEq
        + Debug
        + Arbitrary<'a>
        + Send
        + Sync
        + 'static,
    R: ComponentNamedList
        + Lift
        + Lower
        + Clone
        + PartialEq
        + Debug
        + Arbitrary<'a>
        + Send
        + Sync
        + 'static,
{
    crate::init_fuzzing();

    let mut store = store::<Box<dyn Any + Send>>(input, Box::new(()))?;
    let engine = store.engine();
    let wat = declarations.make_component();
    let wat = wat.as_bytes();
    crate::oracles::log_wasm(wat);
    let component = Component::new(&engine, wat).unwrap();
    let mut linker = Linker::new(&engine);

    fn host_function<P, R>(
        cx: StoreContextMut<'_, Box<dyn Any + Send>>,
        params: P,
    ) -> wasmtime::Result<R>
    where
        P: Debug + PartialEq + 'static,
        R: Debug + Clone + 'static,
    {
        log::trace!("received parameters {params:?}");
        let data: &(P, R) = cx.data().downcast_ref().unwrap();
        let (expected_params, result) = data;
        assert_eq!(params, *expected_params);
        log::trace!("returning result {result:?}");
        Ok(result.clone())
    }

    if declarations.options.host_async {
        linker
            .root()
            .func_wrap_concurrent(IMPORT_FUNCTION, |a, params| {
                Box::pin(async move {
                    a.with(|mut cx| host_function::<P, R>(cx.as_context_mut(), params))