Function invalidated_frame_handles

tests/all/debug.rs:1031–1089

()

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn invalidated_frame_handles() -> wasmtime::Result<()> {
    let (module, mut store) = get_module_and_store(
        |_config| {},
        r#"
    (module
      (import "" "" (func))
      (func (export "main")
        (local i32 i32)
        i32.const 1
        local.set 0
        i32.const 2
        local.set 1
        call 2
        call 0)
      (func
        (local i32 i32)
        i32.const 3
        local.set 0
        i32.const 4
        local.set 1
        call 0))
        "#,
    )?;

    let handle: Arc<Mutex<Option<FrameHandle>>> = Arc::new(Mutex::new(None));

    let hostfunc = Func::wrap_async(&mut store, move |mut caller, _args: ()| {
        let handle = handle.clone();
        Box::new(async move {
            let frame = handle.lock().unwrap().take();
            if let Some(frame) = frame {
                // Ensure that the handle has been invalidated.
                assert!(!frame.is_valid(&mut caller));
                // Ensure that attempts to fetch data from the frame
                // fail with a clean `Err`, not a panic or crash.
                let result = frame.wasm_function_index_and_pc(&mut caller);
                assert!(result.is_err());
                // Ensure that we can get a new frame handle and use it.
                let frame = caller.debug_exit_frames().next().unwrap();
                assert_eq!(frame.num_locals(&mut caller)?, 2);
                assert_eq!(frame.local(&mut caller, 0)?.unwrap_i32(), 1);
                assert_eq!(frame.local(&mut caller, 1)?.unwrap_i32(), 2);
            } else {
                let frame = caller.debug_exit_frames().next().unwrap();
                assert_eq!(frame.num_locals(&mut caller)?, 2);
                assert_eq!(frame.local(&mut caller, 0)?.unwrap_i32(), 3);
                assert_eq!(frame.local(&mut caller, 1)?.unwrap_i32(), 4);
                *handle.lock().unwrap() = Some(frame);
            }
            Ok(())
        })
    });

    let instance = Instance::new_async(&mut store, &module, &[Extern::Func(hostfunc)]).await?;
    let main = instance.get_func(&mut store, "main").unwrap();
    main.call_async(&mut store, &[], &mut []).await?;

    Ok(())