Function deserialize_raw_avoids_copy

tests/all/module.rs:589–621

()

#[test]
#[cfg_attr(miri, ignore)]
fn deserialize_raw_avoids_copy() {
    // target pulley; executing code directly requires virtual memory
    let mut config = Config::new();
    let target = format!("{}", Triple::pulley_host());
    config.target(&target).unwrap();
    let engine = Engine::new(&config).unwrap();
    let wat = String::from(
        r#"
        (module
            (func (export "add") (param $lhs i32) (param $rhs i32) (result i32)
                (i32.add (local.get $lhs) (local.get $rhs))
            )
        )
        "#,
    );
    let module = Module::new(&engine, &wat).unwrap();
    let mut serialized = module.serialize().expect("Serialize failed");
    let serialized_ptr = std::ptr::slice_from_raw_parts(serialized.as_mut_ptr(), serialized.len());
    let module_memory = std::ptr::NonNull::new(serialized_ptr.cast_mut()).unwrap();
    let deserialized_module =
        unsafe { Module::deserialize_raw(&engine, module_memory).expect("Deserialize Failed") };

    // assert that addresses haven't changed, no full copy
    // TODO: haven't been able to find a pub way of doing this

    // basic verification that the loaded module works
    let mut store = Store::new(&engine, ());
    let instance = Instance::new(&mut store, &deserialized_module, &[]).unwrap();
    let f = instance
        .get_typed_func::<(i32, i32), i32>(&mut store, "add")
        .unwrap();
    assert_eq!(f.call(&mut store, (26, 50)).unwrap(), 76);
}

#[test]
#[cfg_attr(miri, ignore)]