Function maps

tests/all/component_model/dynamic.rs:140–212

()

#[test]
fn maps() -> Result<()> {
    let engine = super::map_engine();
    let mut store = Store::new(&engine, ());

    let component = Component::new(&engine, make_echo_component("(map u32 string)", 8))?;
    let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
    let func = instance.get_func(&mut store, "echo").unwrap();

    let input_map = vec![
        (Val::U32(1), Val::String("one".into())),
        (Val::U32(2), Val::String("two".into())),
        (Val::U32(3), Val::String("three".into())),
    ];
    let input = Val::Map(input_map);

    let mut output = [Val::Bool(false)];
    func.call(&mut store, &[input.clone()], &mut output)?;

    // Maps should round-trip correctly
    match &output[0] {
        Val::Map(output_map) => {
            assert_eq!(output_map.len(), 3);
            assert!(
                output_map
                    .iter()
                    .any(|(k, v)| *k == Val::U32(1) && *v == Val::String("one".into()))
            );
            assert!(
                output_map
                    .iter()
                    .any(|(k, v)| *k == Val::U32(2) && *v == Val::String("two".into()))
            );
            assert!(
                output_map
                    .iter()
                    .any(|(k, v)| *k == Val::U32(3) && *v == Val::String("three".into()))
            );
        }
        _ => panic!("expected map"),
    }

    // Sad path: type mismatch (wrong key type)
    // Need to create a fresh instance because errors can leave the instance in a bad state
    let mut store2 = Store::new(&engine, ());
    let instance2 = Linker::new(&engine).instantiate(&mut store2, &component)?;
    let func2 = instance2.get_func(&mut store2, "echo").unwrap();

    let err_map = vec![(Val::String("key".into()), Val::String("value".into()))];
    let err = Val::Map(err_map);
    let err = func2.call(&mut store2, &[err], &mut output).unwrap_err();
    assert!(err.to_string().contains("type mismatch"), "{err}");

    // Sad path: type mismatch (wrong value type)
    let mut store3 = Store::new(&engine, ());
    let instance3 = Linker::new(&engine).instantiate(&mut store3, &component)?;
    let func3 = instance3.get_func(&mut store3, "echo").unwrap();

    let err_map2 = vec![(Val::U32(1), Val::U32(42))];