Function breakpoint_events

tests/all/debug.rs:788–920

()

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn breakpoint_events() -> wasmtime::Result<()> {
    let _ = env_logger::try_init();

    let (module, mut store) = get_module_and_store(
        |config| {
            config.wasm_exceptions(true);
        },
        r#"
    (module
      (func (export "main") (param i32 i32) (result i32)
        local.get 0
        local.get 1
        i32.add))
    "#,
    )?;

    debug_event_checker!(
        D, store,
        { 0 ;
          wasmtime::DebugEvent::Breakpoint => {
              let stack = store.debug_exit_frames().next().unwrap();
              assert_eq!(stack.num_locals(&mut store).unwrap(), 2);
              assert_eq!(stack.local(&mut store, 0).unwrap().unwrap_i32(), 1);
              assert_eq!(stack.local(&mut store, 1).unwrap().unwrap_i32(), 2);
              let (func, pc) = stack.wasm_function_index_and_pc(&mut store).unwrap().unwrap();
              assert_eq!(func.as_u32(), 0);
              assert_eq!(pc.raw(), 0x28);
              let stack = stack.parent(&mut store).unwrap();
              assert!(stack.is_none());
          }
        }
    );

    let (handler, counter) = D::new_and_counter();
    store.set_debug_handler(handler);
    store
        .edit_breakpoints()
        .unwrap()
        .add_breakpoint(&module, ModulePC::new(0x28))?;

    let instance = Instance::new_async(&mut store, &module, &[]).await?;
    let func = instance.get_func(&mut store, "main").unwrap();
    let mut results = [Val::I32(0)];
    func.call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)
        .await?;
    assert_eq!(counter.load(Ordering::Relaxed), 1);
    assert_eq!(results[0].unwrap_i32(), 3);

    let breakpoints = store.breakpoints().unwrap().collect::<Vec<_>>();
    assert_eq!(breakpoints.len(), 1);
    assert!(Module::same(&breakpoints[0].module, &module));
    assert_eq!(breakpoints[0].pc, ModulePC::new(0x28));

    store
        .edit_breakpoints()
        .unwrap()
        .remove_breakpoint(&module, ModulePC::new(0x28))?;
    func.call_async(&mut store, &[Val::I32(1), Val::I32(2)], &mut results)