Function wasm_sets_array_in_table

tests/all/arrays.rs:780–830

()

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

    let module = Module::new(
        store.engine(),
        r#"
            (module
                (type (array i8))
                (table $t (export "t") 1 1 (ref null 0) (ref.null 0))
                (func (export "get") (result (ref null 0))
                    i32.const 0
                    table.get $t
                )
                (func (export "set") (param (ref null 0))
                    i32.const 0
                    local.get 0
                    table.set $t
                )
            )
        "#,
    )?;

    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 t = instance.get_table(&mut store, "t").unwrap();
    let val = t.get(&mut store, 0).expect("in bounds");
    let anyref = val.unwrap_any().expect("non-null");
    let a1 = anyref.unwrap_array(&store)?;
    assert_eq!(a1.len(&mut 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(&mut store)?, 1);
    assert_eq!(a2.get(&mut store, 0)?.unwrap_i32(), 42);
    assert!(Rooted::ref_eq(&store, &a0, &a2)?);

    Ok(())
}

#[test]
fn instantiate_with_array_global() -> Result<()> {