Function tuple_result

tests/all/component_model/func.rs:638–691

()

#[test]
fn tuple_result() -> Result<()> {
    let component = r#"
        (component
            (core module $m
                (memory (export "memory") 1)
                (func (export "foo") (param i32 i32 f32 f64) (result i32)
                    (local $base i32)
                    (local.set $base (i32.const 8))
                    (i32.store8 offset=0 (local.get $base) (local.get 0))
                    (i32.store16 offset=2 (local.get $base) (local.get 1))
                    (f32.store offset=4 (local.get $base) (local.get 2))
                    (f64.store offset=8 (local.get $base) (local.get 3))
                    local.get $base
                )

                (func (export "invalid") (result i32)
                    i32.const -8
                )
            )
            (core instance $i (instantiate $m))

            (type $result (tuple s8 u16 float32 float64))
            (func (export "tuple")
                (param "a" s8) (param "b" u16) (param "c" float32) (param "d" float64) (result $result)
                (canon lift (core func $i "foo") (memory $i "memory"))
            )
            (func (export "invalid") (result $result)
                (canon lift (core func $i "invalid") (memory $i "memory"))
            )
        )
    "#;

    let engine = super::engine();
    let component = Component::new(&engine, component)?;
    let mut store = Store::new(&engine, ());
    let instance = Linker::new(&engine).instantiate(&mut store, &component)?;

    let input = (-1, 100, 3.0, 100.0);
    let output = instance
        .get_typed_func::<(i8, u16, f32, f64), ((i8, u16, f32, f64),)>(&mut store, "tuple")?
        .call(&mut store, input)?;
    assert_eq!((input,), output);

    let invalid_func =
        instance.get_typed_func::<(), ((i8, u16, f32, f64),)>(&mut store, "invalid")?;
    let err = invalid_func.call(&mut store, ()).err().unwrap();
    assert!(
        err.to_string().contains("pointer out of bounds of memory"),
        "{}",
        err
    );

    Ok(())
}

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