feat: add a histrical wit-bindgen

__wasm/wit-bindgen-sample/wit-bindgen/tests/runtime/variants/wasm.rs

@@ -0,0 +1,98 @@
+wit_bindgen_rust::import!("../../tests/runtime/variants/imports.wit");
+wit_bindgen_rust::export!("../../tests/runtime/variants/exports.wit");
+
+use exports::*;
+
+struct Exports;
+
+impl exports::Exports for Exports {
+    fn test_imports() {
+        use imports::*;
+
+        assert_eq!(roundtrip_option(Some(1.0)), Some(1));
+        assert_eq!(roundtrip_option(None), None);
+        assert_eq!(roundtrip_option(Some(2.0)), Some(2));
+        assert_eq!(roundtrip_result(Ok(2)), Ok(2.0));
+        assert_eq!(roundtrip_result(Ok(4)), Ok(4.0));
+        assert_eq!(roundtrip_result(Err(5.3)), Err(5));
+
+        assert_eq!(roundtrip_enum(E1::A), E1::A);
+        assert_eq!(roundtrip_enum(E1::B), E1::B);
+
+        assert_eq!(invert_bool(true), false);
+        assert_eq!(invert_bool(false), true);
+
+        let (a1, a2, a3, a4, a5, a6) =
+            variant_casts((C1::A(1), C2::A(2), C3::A(3), C4::A(4), C5::A(5), C6::A(6.0)));
+        assert!(matches!(a1, C1::A(1)));
+        assert!(matches!(a2, C2::A(2)));
+        assert!(matches!(a3, C3::A(3)));
+        assert!(matches!(a4, C4::A(4)));
+        assert!(matches!(a5, C5::A(5)));
+        assert!(matches!(a6, C6::A(b) if b == 6.0));
+
+        let (a1, a2, a3, a4, a5, a6) = variant_casts((
+            C1::B(1),
+            C2::B(2.0),
+            C3::B(3.0),
+            C4::B(4.0),
+            C5::B(5.0),
+            C6::B(6.0),
+        ));
+        assert!(matches!(a1, C1::B(1)));
+        assert!(matches!(a2, C2::B(b) if b == 2.0));
+        assert!(matches!(a3, C3::B(b) if b == 3.0));
+        assert!(matches!(a4, C4::B(b) if b == 4.0));
+        assert!(matches!(a5, C5::B(b) if b == 5.0));
+        assert!(matches!(a6, C6::B(b) if b == 6.0));
+
+        let (a1, a2, a3, a4) = variant_zeros((Z1::A(1), Z2::A(2), Z3::A(3.0), Z4::A(4.0)));
+        assert!(matches!(a1, Z1::A(1)));
+        assert!(matches!(a2, Z2::A(2)));
+        assert!(matches!(a3, Z3::A(b) if b == 3.0));
+        assert!(matches!(a4, Z4::A(b) if b == 4.0));
+
+        let (a1, a2, a3, a4) = variant_zeros((Z1::B, Z2::B, Z3::B, Z4::B));
+        assert!(matches!(a1, Z1::B));
+        assert!(matches!(a2, Z2::B));
+        assert!(matches!(a3, Z3::B));
+        assert!(matches!(a4, Z4::B));
+
+        variant_typedefs(None, false, Err(()));
+
+        assert_eq!(
+            variant_enums(true, Ok(()), MyErrno::Success),
+            (false, Err(()), MyErrno::A)
+        );
+    }
+
+    fn roundtrip_option(a: Option<f32>) -> Option<u8> {
+        a.map(|x| x as u8)
+    }
+
+    fn roundtrip_result(a: Result<u32, f32>) -> Result<f64, u8> {
+        match a {
+            Ok(a) => Ok(a.into()),
+            Err(b) => Err(b as u8),
+        }
+    }
+
+    fn roundtrip_enum(a: E1) -> E1 {
+        assert_eq!(a, a);
+        a
+    }
+
+    fn invert_bool(a: bool) -> bool {
+        !a
+    }
+
+    fn variant_casts(a: Casts) -> Casts {
+        a
+    }
+
+    fn variant_zeros(a: Zeros) -> Zeros {
+        a
+    }
+
+    fn variant_typedefs(_: Option<u32>, _: bool, _: Result<u32, ()>) {}
+}