Function wasm_sets_array_global

tests/all/arrays.rs:680–728

()

#[test]
#[cfg_attr(miri, ignore)]
fn wasm_sets_array_global() -> Result<()> {
    let mut store = gc_store()?;

    let module = Module::new(
        store.engine(),
        r#"
            (module
                (type (array i8))
                (global $g (export "g") (mut (ref null 0)) (ref.null 0))
                (func (export "get") (result (ref null 0))
                    global.get $g
                )
                (func (export "set") (param (ref null 0))
                    local.get 0
                    global.set $g
                )
            )
        "#,
    )?;

    let array_ty = ArrayType::new(
        store.engine(),
        FieldType::new(Mutability::Const, StorageType::I8),
    );
    let pre = ArrayRefPre::new(&mut store, array_ty.clone());
    let a0 = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(42)])?;

    let instance = Instance::new(&mut store, &module, &[])?;
    let set = instance.get_func(&mut store, "set").unwrap();
    set.call(&mut store, &[a0.into()], &mut [])?;

    // Get the global from the host.
    let g = instance.get_global(&mut store, "g").unwrap();
    let val = g.get(&mut store);
    let anyref = val.unwrap_anyref().expect("non-null");
    let a1 = anyref.unwrap_array(&store)?;
    assert_eq!(a1.len(&store)?, 1);
    assert_eq!(a1.get(&mut store, 0)?.unwrap_i32(), 42);
    assert!(Rooted::ref_eq(&store, &a0, &a1)?);

    // Get the global from the guest.
    let f = instance.get_typed_func::<(), Option<Rooted<ArrayRef>>>(&mut store, "get")?;
    let a2 = f.call(&mut store, ())?.expect("non-null");
    assert_eq!(a2.len(&store)?, 1);
    assert_eq!(a2.get(&mut store, 0)?.unwrap_i32(), 42);
    assert!(Rooted::ref_eq(&store, &a0, &a2)?);

    Ok(())
}

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