Function instantiate_with_array_global

tests/all/arrays.rs:833–880

()

#[test]
fn instantiate_with_array_global() -> Result<()> {
    let mut store = gc_store()?;

    let module = Module::new(
        store.engine(),
        r#"
            (module
                (type (array i8))
                (import "" "" (global (ref null 0)))
                (export "g" (global 0))
            )
        "#,
    )?;

    let array_ty = ArrayType::new(
        store.engine(),
        FieldType::new(Mutability::Const, StorageType::I8),
    );
    let global_ty = GlobalType::new(
        ValType::Ref(RefType::new(
            true,
            HeapType::ConcreteArray(array_ty.clone()),
        )),
        Mutability::Const,
    );

    // Instantiate with a null-ref global.
    let g = Global::new(&mut store, global_ty.clone(), Val::AnyRef(None))?;
    let instance = Instance::new(&mut store, &module, &[g.into()])?;
    let g = instance.get_global(&mut store, "g").expect("export exists");
    let val = g.get(&mut store);
    assert!(val.unwrap_anyref().is_none());

    // Instantiate with a non-null-ref global.
    let pre = ArrayRefPre::new(&mut store, array_ty);
    let a0 = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(42)])?;
    let g = Global::new(&mut store, global_ty, a0.into())?;
    let instance = Instance::new(&mut store, &module, &[g.into()])?;
    let g = instance.get_global(&mut store, "g").expect("export exists");
    let val = g.get(&mut store);
    let anyref = val.unwrap_anyref().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)?);

    Ok(())
}

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