Asserts function refactoring

Cargo.toml

@@ -8,3 +8,4 @@ version = "0.1.0"
 smplx-std = { version = ">=0.0.6, <0.1.0" }
 
 anyhow = { version = "1.0.101" }
+rand = { version = "0.8.6" }

simf/asserts.simf

@@ -1,55 +1,57 @@
 /// Asserts that two u8 are equal
-pub fn assert_eq8(a: u8, b: u8) {
+fn assert_eq_8(a: u8, b: u8) {
     assert!(jet::eq_8(a, b));
 }
 
 /// Asserts that two u16 are equal
-pub fn assert_eq16(a: u16, b: u16) {
+fn assert_eq_16(a: u16, b: u16) {
     assert!(jet::eq_16(a, b));
 }
 
 /// Asserts that two u32 are equal
-pub fn assert_eq32(a: u32, b: u32) {
+fn assert_eq_32(a: u32, b: u32) {
     assert!(jet::eq_32(a, b));
 }
 
 /// Asserts that two u64 are equal
-pub fn assert_eq64(a: u64, b: u64) {
+fn assert_eq_64(a: u64, b: u64) {
     assert!(jet::eq_64(a, b));
 }
 
+// todo: assert_eq_128
+
 /// Asserts that two u256 are equal
-pub fn assert_eq256(a: u256, b: u256) {
+fn assert_eq_256(a: u256, b: u256) {
     assert!(jet::eq_256(a, b));
 }
 
 /// Asserts that provided u8 Option value is a None
-pub fn assert_none8(val: Option<u8>) {
+fn assert_none_8(val: Option<u8>) {
     assert!(is_none::<u8>(val));
 }
 
 /// Asserts that provided u16 Option value is a None
-pub fn assert_none16(val: Option<u16>) {
+fn assert_none_16(val: Option<u16>) {
     assert!(is_none::<u16>(val));
 }
 
 /// Asserts that provided u32 Option value is a None
-pub fn assert_none32(val: Option<u32>) {
+fn assert_none_32(val: Option<u32>) {
     assert!(is_none::<u32>(val));
 }
 
 /// Asserts that provided u64 Option value is a None
-pub fn assert_none64(val: Option<u64>) {
+fn assert_none_64(val: Option<u64>) {
     assert!(is_none::<u64>(val));
 }
 
 /// Asserts that provided u128 Option value is a None
-pub fn assert_none128(val: Option<u128>) {
+fn assert_none_128(val: Option<u128>) {
     assert!(is_none::<u128>(val));
 }
 
 /// Asserts that provided u256 Option value is a None
-pub fn assert_none256(val: Option<u256>) {
+fn assert_none_256(val: Option<u256>) {
     assert!(is_none::<u256>(val));
 }
 

simf/mock/asserts_mock.simf

@@ -1,132 +1,150 @@
 // todo: switch to function import when available
-pub fn assert_eq8(a: u8, b: u8) { // 1
+fn assert_eq_8(a: u8, b: u8) { // 0
     assert!(jet::eq_8(a, b));
 }
 
-pub fn assert_eq16(a: u16, b: u16) { // 2
+fn assert_eq_16(a: u16, b: u16) { // 1
     assert!(jet::eq_16(a, b));
 }
 
-pub fn assert_eq32(a: u32, b: u32) { // 3
+fn assert_eq_32(a: u32, b: u32) { // 2
     assert!(jet::eq_32(a, b));
 }
 
-pub fn assert_eq64(a: u64, b: u64) { // 4
+fn assert_eq_64(a: u64, b: u64) { // 3
     assert!(jet::eq_64(a, b));
 }
 
-pub fn assert_eq256(a: u256, b: u256) { // 5
+// todo: assert_eq_128
+
+fn assert_eq_256(a: u256, b: u256) { // 4
     assert!(jet::eq_256(a, b));
 }
 
-pub fn assert_none8(val: Option<u8>) { // 6
+fn assert_none_8(val: Option<u8>) { // 5
     assert!(is_none::<u8>(val));
 }
 
-pub fn assert_none16(val: Option<u16>) { // 7
+fn assert_none_16(val: Option<u16>) { // 6
     assert!(is_none::<u16>(val));
 }
 
-pub fn assert_none32(val: Option<u32>) { // 8
+fn assert_none_32(val: Option<u32>) { // 7
     assert!(is_none::<u32>(val));
 }
 
-pub fn assert_none64(val: Option<u64>) { // 9
+fn assert_none_64(val: Option<u64>) { // 8
     assert!(is_none::<u64>(val));
 }
 
-pub fn assert_none128(val: Option<u128>) { // 10
+fn assert_none_128(val: Option<u128>) { // 9
     assert!(is_none::<u128>(val));
 }
 
-pub fn assert_none256(val: Option<u256>) { // 11
+fn assert_none_256(val: Option<u256>) { // 10
     assert!(is_none::<u256>(val));
 }
 
+// helper
 fn if_test_this_function(index: u8, flag: u8) -> bool {
    jet::eq_8(index, flag)
 }
 
 fn main() {
-    let flag: u8 = witness::FLAG;
-    let ifHappyPath: bool = if_test_this_function(0, flag);
+    let function_index: u8 = witness::FUNCTION_INDEX;
+
+    let first_arg_u8: Option<u8> = witness::FIRST_ARG_U8;
+    let second_arg_u8: Option<u8> = witness::SECOND_ARG_U8;
+
+    let first_arg_u16: Option<u16> = witness::FIRST_ARG_U16;
+    let second_arg_u16: Option<u16> = witness::SECOND_ARG_U16;
+
+    let first_arg_u32: Option<u32> = witness::FIRST_ARG_U32;
+    let second_arg_u32: Option<u32> = witness::SECOND_ARG_U32;
+
+    let first_arg_u64: Option<u64> = witness::FIRST_ARG_U64;
+    let second_arg_u64: Option<u64> = witness::SECOND_ARG_U64;
 
-    let some_u8: u8 = 255;
-    let some_u16: u16 = 65535;
-    let some_u32: u32 = 4294967295;
-    let some_u64: u64 = 18446744073709551615;
-    let some_u128: u128 = 340282366920938463463374607431768211455;
-    let some_u256: u256 = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
+    let first_arg_u128: Option<u128> = witness::FIRST_ARG_U128;
+    let second_arg_u128: Option<u128> = witness::SECOND_ARG_U128;
+
+    let first_arg_u256: Option<u256> = witness::FIRST_ARG_U256;
+    let second_arg_u256: Option<u256> = witness::SECOND_ARG_U256;
+
+    match if_test_this_function(0, function_index) {
+        true => {
+            assert_eq_8(unwrap(first_arg_u8), unwrap(second_arg_u8));
+        },
+        false => (),
+    };
+
+    match if_test_this_function(1, function_index) {
+        true => {
+            assert_eq_16(unwrap(first_arg_u16), unwrap(second_arg_u16));
+        },
+        false => (),
+    };
+
+    match if_test_this_function(2, function_index) {
+        true => {
+            assert_eq_32(unwrap(first_arg_u32), unwrap(second_arg_u32));
+        },
+        false => (),
+    };
+
+    match if_test_this_function(3, function_index) {
+        true => {
+            assert_eq_64(unwrap(first_arg_u64), unwrap(second_arg_u64));
+        },
+        false => (),
+    };
+
+    match if_test_this_function(4, function_index) {
+        true => {
+            assert_eq_256(unwrap(first_arg_u256), unwrap(second_arg_u256));
+        },
+        false => (),
+    };
+
+    match if_test_this_function(5, function_index) {
+        true => {
+            assert_none_8(first_arg_u8);
+        },
+        false => (),
+    };
+
+    match if_test_this_function(6, function_index) {
+        true => {
+            assert_none_16(first_arg_u16);
+        },
+        false => (),
+    };
+
+    match if_test_this_function(7, function_index) {
+        true => {
+            assert_none_32(first_arg_u32);
+        },
+        false => (),
+    };
+
+    match if_test_this_function(8, function_index) {
+        true => {
+            assert_none_64(first_arg_u64);
+        },
+        false => (),
+    };
+
+    match if_test_this_function(9, function_index) {
+        true => {
+            assert_none_128(first_arg_u128);
+        },
+        false => (),
+    };
 
-    match ifHappyPath {
+    match if_test_this_function(10, function_index) {
         true => {
-            assert_eq8(some_u8, some_u8);
-            assert_eq16(some_u16, some_u16);
-            assert_eq32(some_u32, some_u32);
-            assert_eq64(some_u64, some_u64);
-            assert_eq256(some_u256, some_u256);
-
-            assert_none8(None);
-            assert_none16(None);
-            assert_none32(None);
-            assert_none64(None);
-            assert_none128(None);
-            assert_none256(None);
-        }, false => { 
-            match if_test_this_function(1, flag) {
-                true => assert_eq8(1, 2),
-                false => (),
-            };
-
-            match if_test_this_function(2, flag) {
-                true => assert_eq16(1, 2),
-                false => (),
-            };
-
-            match if_test_this_function(3, flag) {
-                true => assert_eq32(1, 2),
-                false => (),
-            };
-
-            match if_test_this_function(4, flag) {
-                true => assert_eq64(1, 2),
-                false => (),
-            };
-
-            match if_test_this_function(5, flag) {
-                true => assert_eq256(1, 2),
-                false => (),
-            };
-
-            match if_test_this_function(6, flag) {
-                true => assert_none8(Some(some_u8)),
-                false => (),
-            };
-
-            match if_test_this_function(7, flag) {
-                true => assert_none16(Some(some_u16)),
-                false => (),
-            };
-
-            match if_test_this_function(8, flag) {
-                true => assert_none32(Some(some_u32)),
-                false => (),
-            };
-
-            match if_test_this_function(9, flag) {
-                true => assert_none64(Some(some_u64)),
-                false => (),
-            };
-
-            match if_test_this_function(10, flag) {
-                true => assert_none128(Some(some_u128)),
-                false => (),
-            };
-
-            match if_test_this_function(11, flag) {
-                true => assert_none256(Some(some_u256)),
-                false => (),
-            };
-        }
-    }
+            assert_none_256(first_arg_u256);
+        },
+        false => (),
+    };
 }