99 lines
2.9 KiB
Rust
99 lines
2.9 KiB
Rust
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, ()>) {}
|
|
}
|