feat: add a histrical wit-bindgen

2023-01-01 00:25:48 +08:00
parent 01e8f5a959
commit aa50d63aec
419 changed files with 45283 additions and 1 deletions
--- a/__wasm/wit-bindgen-sample/wit-bindgen/tests/runtime/unions/wasm.rs
+++ b/__wasm/wit-bindgen-sample/wit-bindgen/tests/runtime/unions/wasm.rs
@@ -0,0 +1,171 @@
+wit_bindgen_rust::import!("../../tests/runtime/unions/imports.wit");
+wit_bindgen_rust::export!("../../tests/runtime/unions/exports.wit");
+
+use exports::*;
+
+struct Exports;
+
+impl exports::Exports for Exports {
+    fn test_imports() {
+        use imports::*;
+
+        // All-Integers
+        // Booleans
+        assert!(matches!(add_one_integer(AllIntegers::Bool(false)), AllIntegers::Bool(true)));
+        assert!(matches!(add_one_integer(AllIntegers::Bool(true)), AllIntegers::Bool(false)));
+        // Unsigned integers
+        assert!(matches!(add_one_integer(AllIntegers::U8(0)), AllIntegers::U8(1)));
+        assert!(matches!(add_one_integer(AllIntegers::U8(u8::MAX)), AllIntegers::U8(0)));
+        assert!(matches!(add_one_integer(AllIntegers::U16(0)), AllIntegers::U16(1)));
+        assert!(matches!(add_one_integer(AllIntegers::U16(u16::MAX)), AllIntegers::U16(0)));
+        assert!(matches!(add_one_integer(AllIntegers::U32(0)), AllIntegers::U32(1)));
+        assert!(matches!(add_one_integer(AllIntegers::U32(u32::MAX)), AllIntegers::U32(0)));
+        assert!(matches!(add_one_integer(AllIntegers::U64(0)), AllIntegers::U64(1)));
+        assert!(matches!(add_one_integer(AllIntegers::U64(u64::MAX)), AllIntegers::U64(0)));
+        // Signed integers
+        assert!(matches!(add_one_integer(AllIntegers::I8(0)), AllIntegers::I8(1)));
+        assert!(matches!(add_one_integer(AllIntegers::I8(i8::MAX)), AllIntegers::I8(i8::MIN)));
+        assert!(matches!(add_one_integer(AllIntegers::I16(0)), AllIntegers::I16(1)));
+        assert!(matches!(add_one_integer(AllIntegers::I16(i16::MAX)), AllIntegers::I16(i16::MIN)));
+        assert!(matches!(add_one_integer(AllIntegers::I32(0)), AllIntegers::I32(1)));
+        assert!(matches!(add_one_integer(AllIntegers::I32(i32::MAX)), AllIntegers::I32(i32::MIN)));
+        assert!(matches!(add_one_integer(AllIntegers::I64(0)), AllIntegers::I64(1)));
+        assert!(matches!(add_one_integer(AllIntegers::I64(i64::MAX)), AllIntegers::I64(i64::MIN)));
+
+        // All-Floats
+        assert!(matches!(add_one_float(AllFloats::F32(0.0)), AllFloats::F32(1.0)));
+        assert!(matches!(add_one_float(AllFloats::F64(0.0)), AllFloats::F64(1.0)));
+
+        // All-Text
+        assert!(matches!(replace_first_char(AllTextParam::Char('a'), 'z'), AllTextResult::Char('z')));
+        let rhs = "zbc".to_string();
+        assert!(matches!(replace_first_char(AllTextParam::String("abc"), 'z'), AllTextResult::String(rhs)));
+
+        // All-Integers
+        assert!(matches!(identify_integer(AllIntegers::Bool(true)), 0));
+        assert!(matches!(identify_integer(AllIntegers::U8(0)), 1));
+        assert!(matches!(identify_integer(AllIntegers::U16(0)), 2));
+        assert!(matches!(identify_integer(AllIntegers::U32(0)), 3));
+        assert!(matches!(identify_integer(AllIntegers::U64(0)), 4));
+        assert!(matches!(identify_integer(AllIntegers::I8(0)), 5));
+        assert!(matches!(identify_integer(AllIntegers::I16(0)), 6));
+        assert!(matches!(identify_integer(AllIntegers::I32(0)), 7));
+        assert!(matches!(identify_integer(AllIntegers::I64(0)), 8));
+
+        // All-Floats
+        assert!(matches!(identify_float(AllFloats::F32(0.0)), 0));
+        assert!(matches!(identify_float(AllFloats::F64(0.0)), 1));
+
+        // All-Text
+        assert!(matches!(identify_text(AllTextParam::Char('a')), 0));
+        assert!(matches!(identify_text(AllTextParam::String("abc")), 1));
+
+        // Duplicated
+        assert!(matches!(add_one_duplicated(DuplicatedS32::I320(0)), DuplicatedS32::I320(1)));
+        assert!(matches!(add_one_duplicated(DuplicatedS32::I321(1)), DuplicatedS32::I321(2)));
+        assert!(matches!(add_one_duplicated(DuplicatedS32::I322(2)), DuplicatedS32::I322(3)));
+
+        assert!(matches!(identify_duplicated(DuplicatedS32::I320(0)), 0));
+        assert!(matches!(identify_duplicated(DuplicatedS32::I321(0)), 1));
+        assert!(matches!(identify_duplicated(DuplicatedS32::I321(0)), 2));
+
+        // Distinguishable
+        assert!(matches!(add_one_distinguishable_num(DistinguishableNum::F64(0.0)), DistinguishableNum::F64(1.0)));
+        assert!(matches!(add_one_distinguishable_num(DistinguishableNum::I64(0)), DistinguishableNum::I64(1)));
+
+        assert!(matches!(identify_distinguishable_num(DistinguishableNum::F64(0.0)), 0));
+        assert!(matches!(identify_distinguishable_num(DistinguishableNum::I64(1)), 1));
+    }
+
+    fn add_one_integer(num: AllIntegers) -> AllIntegers {
+        match num {
+            // Boolean
+            AllIntegers::Bool(b) => AllIntegers::Bool(!b),
+            // Unsigneed Integers
+            AllIntegers::U8(n) => AllIntegers::U8(n.wrapping_add(1)),
+            AllIntegers::U16(n) => AllIntegers::U16(n.wrapping_add(1)),
+            AllIntegers::U32(n) => AllIntegers::U32(n.wrapping_add(1)),
+            AllIntegers::U64(n) => AllIntegers::U64(n.wrapping_add(1)),
+            // Signed Integers
+            AllIntegers::I8(n) => AllIntegers::I8(n.wrapping_add(1)),
+            AllIntegers::I16(n) => AllIntegers::I16(n.wrapping_add(1)),
+            AllIntegers::I32(n) => AllIntegers::I32(n.wrapping_add(1)),
+            AllIntegers::I64(n) => AllIntegers::I64(n.wrapping_add(1)),
+        }
+    }
+
+    fn add_one_float(num: AllFloats) -> AllFloats {
+        match num {
+            AllFloats::F32(n) => AllFloats::F32(n + 1.0),
+            AllFloats::F64(n) => AllFloats::F64(n + 1.0),
+        }
+    }
+
+    fn replace_first_char(text: AllText, letter: char) -> AllText {
+        match text {
+            AllText::Char(c) => AllText::Char(letter),
+            AllText::String(s) => AllText::String(format!("{}{}", letter, &s[1..]))
+        }
+    }
+
+    fn identify_integer(num: AllIntegers) -> u8 {
+        match num {
+            // Boolean
+            AllIntegers::Bool(_b) => 0,
+            // Unsigneed Integers
+            AllIntegers::U8(_n) => 1,
+            AllIntegers::U16(_n) => 2,
+            AllIntegers::U32(_n) => 3,
+            AllIntegers::U64(_n) => 4,
+            // Signed Integers
+            AllIntegers::I8(_n) => 5,
+            AllIntegers::I16(_n) => 6,
+            AllIntegers::I32(_n) => 7,
+            AllIntegers::I64(_n) => 8,
+        }
+    }
+
+    fn identify_float(num: AllFloats) -> u8 {
+        match num {
+            AllFloats::F32(_n) => 0,
+            AllFloats::F64(_n) => 1,
+        }
+    }
+
+    fn identify_text(text: AllText) -> u8 {
+        match text {
+            AllText::Char(_c) => 0,
+            AllText::String(_s) => 1
+        }
+    }
+
+    fn add_one_duplicated(num: DuplicatedS32) -> DuplicatedS32 {
+        match num {
+            DuplicatedS32::I320(n) => DuplicatedS32::I320(n.wrapping_add(1)),
+            DuplicatedS32::I321(n) => DuplicatedS32::I321(n.wrapping_add(1)),
+            DuplicatedS32::I322(n) => DuplicatedS32::I322(n.wrapping_add(1)),
+        }
+    }
+
+    fn identify_duplicated(num: DuplicatedS32) -> u8 {
+        match num {
+            DuplicatedS32::I320(_n) => 0,
+            DuplicatedS32::I321(_n) => 1,
+            DuplicatedS32::I322(_n) => 2,
+        }
+    }
+
+    fn add_one_distinguishable_num(num: DistinguishableNum) -> DistinguishableNum {
+        match num {
+            DistinguishableNum::F64(n) => DistinguishableNum::F64(n + 1.0),
+            DistinguishableNum::I64(n) => DistinguishableNum::I64(n.wrapping_add(1)),
+        }
+    }
+
+    fn identify_distinguishable_num(num: DistinguishableNum) -> u8 {
+        match num {
+            DistinguishableNum::F64(_n) => 0,
+            DistinguishableNum::I64(_n) => 1,
+        }
+    }
+}