Function pulley_provenance_test_async_components

tests/all/pulley.rs:419–488

()

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn pulley_provenance_test_async_components() -> Result<()> {
    let config = provenance_test_config();
    let engine = Engine::new(&config)?;
    let component = if cfg!(miri) {
        unsafe {
            Component::deserialize_file(
                &engine,
                "./tests/all/pulley_provenance_test_async_component.cwasm",
            )?
        }
    } else {
        Component::from_file(
            &engine,
            "./tests/all/pulley_provenance_test_async_component.wat",
        )?
    };
    {
        let mut store = Store::new(&engine, ());
        let mut linker = component::Linker::new(&engine);
        linker
            .root()
            .func_wrap_concurrent("return-slowly", |_, ()| {
                Box::pin(async {
                    for _ in 0..5 {
                        tokio::task::yield_now().await;
                    }
                    Ok(())
                })
            })?;

        let instance = linker.instantiate_async(&mut store, &component).await?;

        let run = instance.get_typed_func::<(), ()>(&mut store, "run-stackless")?;
        store
            .run_concurrent(async move |accessor| {
                wasmtime::error::Ok(run.call_concurrent(accessor, ()).await?)
            })
            .await??;

        let run = instance.get_typed_func::<(), ()>(&mut store, "run-stackful")?;
        store
            .run_concurrent(async move |accessor| {
                wasmtime::error::Ok(run.call_concurrent(accessor, ()).await?)
            })
            .await??;

        let run = instance.get_typed_func::<(), ()>(&mut store, "run-stackless-stackless")?;
        store
            .run_concurrent(async move |accessor| {
                wasmtime::error::Ok(run.call_concurrent(accessor, ()).await?)
            })
            .await??;

        let run = instance.get_typed_func::<(), ()>(&mut store, "run-stackful-stackful")?;
        store
            .run_concurrent(async move |accessor| {
                wasmtime::error::Ok(run.call_concurrent(accessor, ()).await?)
            })