Add tuple-with-map and single-entry map runtime tests

Exercise map inside an anonymous tuple (filter_mode_preserve_top path)
and the single-entry boundary case.

Author: yordis

tests/runtime/map/runner.rs

@@ -21,6 +21,8 @@ impl Guest for Component {
         test_nested_roundtrip();
         test_variant_roundtrip();
         test_result_roundtrip();
+        test_tuple_roundtrip();
+        test_single_entry_roundtrip();
     }
 }
 
@@ -174,3 +176,23 @@ fn test_result_roundtrip() {
         Ok(_) => panic!("expected Err"),
     }
 }
+
+fn test_tuple_roundtrip() {
+    let mut map = NamesById::new();
+    map.insert(7, "seven".to_string());
+    let (result_map, result_num) = tuple_roundtrip((&map, 42));
+    assert_eq!(result_map.len(), 1);
+    assert_eq!(result_map.get(&7).map(String::as_str), Some("seven"));
+    assert_eq!(result_num, 42);
+}
+
+fn test_single_entry_roundtrip() {
+    let mut input = NamesById::new();
+    input.insert(99, "ninety-nine".to_string());
+    let result = single_entry_roundtrip(&input);
+    assert_eq!(result.len(), 1);
+    assert_eq!(
+        result.get(&99).map(String::as_str),
+        Some("ninety-nine"),
+    );
+}

tests/runtime/map/test.rs

@@ -96,4 +96,16 @@ impl exports::test::maps::to_test::Guest for Component {
     fn result_roundtrip(a: Result<NamesById, String>) -> Result<NamesById, String> {
         a
     }
+
+    fn tuple_roundtrip(a: (NamesById, u64)) -> (NamesById, u64) {
+        assert_eq!(a.0.len(), 1);
+        assert_eq!(a.0.get(&7).map(String::as_str), Some("seven"));
+        assert_eq!(a.1, 42);
+        a
+    }
+
+    fn single_entry_roundtrip(a: NamesById) -> NamesById {
+        assert_eq!(a.len(), 1);
+        a
+    }
 }

tests/runtime/map/test.wit

@@ -26,6 +26,8 @@ interface to-test {
   nested-roundtrip: func(a: map<string, map<u32, string>>) -> map<string, map<u32, string>>;
   variant-roundtrip: func(a: map-or-string) -> map-or-string;
   result-roundtrip: func(a: result<names-by-id, string>) -> result<names-by-id, string>;
+  tuple-roundtrip: func(a: tuple<names-by-id, u64>) -> tuple<names-by-id, u64>;
+  single-entry-roundtrip: func(a: names-by-id) -> names-by-id;
 }
 
 world test {