feature/named_invoke - refactor tests to use named invoke

DLR-FT · Jul 17, 2024 · 92b177c · 92b177c
1 parent dc86604
commit 92b177c
Show file tree

Hide file tree

Showing 8 changed files with 150 additions and 57 deletions.
diff --git a/src/execution/mod.rs b/src/execution/mod.rs
@@ -76,6 +76,7 @@ where
         func_name: &str,
         param: Param,
     ) -> Result<Returns> {
+        // TODO: Optimize this search for better than linear-time. Pre-processing will likely be required
         let func_idx = self.exports.iter().find_map(|export| {
             if export.name == func_name {
                 match export.desc {

diff --git a/tests/arithmetic/division.rs b/tests/arithmetic/division.rs
@@ -21,16 +21,50 @@ pub fn division_signed_simple() {
 
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(10, instance.invoke_func(0, (20, 2)).unwrap());
-    assert_eq!(9_001, instance.invoke_func(0, (81_018_001, 9_001)).unwrap());
-    assert_eq!(-10, instance.invoke_func(0, (20, -2)).unwrap());
-    assert_eq!(10, instance.invoke_func(0, (-20, -2)).unwrap());
-    assert_eq!(-10, instance.invoke_func(0, (-20, 2)).unwrap());
-    assert_eq!(10, instance.invoke_func(0, (20, 2)).unwrap());
-    assert_eq!(9_001, instance.invoke_func(0, (81_018_001, 9_001)).unwrap());
-    assert_eq!(-10, instance.invoke_func(0, (20, -2)).unwrap());
-    assert_eq!(10, instance.invoke_func(0, (-20, -2)).unwrap());
-    assert_eq!(-10, instance.invoke_func(0, (-20, 2)).unwrap());
+    assert_eq!(
+        10,
+        instance.invoke_named("signed_division", (20, 2)).unwrap()
+    );
+    assert_eq!(
+        9_001,
+        instance
+            .invoke_named("signed_division", (81_018_001, 9_001))
+            .unwrap()
+    );
+    assert_eq!(
+        -10,
+        instance.invoke_named("signed_division", (20, -2)).unwrap()
+    );
+    assert_eq!(
+        10,
+        instance.invoke_named("signed_division", (-20, -2)).unwrap()
+    );
+    assert_eq!(
+        -10,
+        instance.invoke_named("signed_division", (-20, 2)).unwrap()
+    );
+    assert_eq!(
+        10,
+        instance.invoke_named("signed_division", (20, 2)).unwrap()
+    );
+    assert_eq!(
+        9_001,
+        instance
+            .invoke_named("signed_division", (81_018_001, 9_001))
+            .unwrap()
+    );
+    assert_eq!(
+        -10,
+        instance.invoke_named("signed_division", (20, -2)).unwrap()
+    );
+    assert_eq!(
+        10,
+        instance.invoke_named("signed_division", (-20, -2)).unwrap()
+    );
+    assert_eq!(
+        -10,
+        instance.invoke_named("signed_division", (-20, 2)).unwrap()
+    );
 }
 
 /// A simple function to test signed division's RuntimeError when dividing by 0
@@ -53,7 +87,7 @@ pub fn division_signed_panic_dividend_0() {
 
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    let result = instance.invoke_func::<(i32, i32), i32>(0, (222, 0));
+    let result = instance.invoke_named::<(i32, i32), i32>("signed_division", (222, 0));
 
     assert_eq!(result.unwrap_err(), RuntimeError(DivideBy0));
 }
@@ -78,7 +112,7 @@ pub fn division_signed_panic_result_unrepresentable() {
 
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    let result = instance.invoke_func::<(i32, i32), i32>(0, (i32::MIN, -1));
+    let result = instance.invoke_named::<(i32, i32), i32>("signed_division", (i32::MIN, -1));
 
     assert_eq!(result.unwrap_err(), RuntimeError(UnrepresentableResult));
 }
@@ -103,15 +137,53 @@ pub fn division_unsigned_simple() {
 
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(10, instance.invoke_func(0, (20, 2)).unwrap());
-    assert_eq!(9_001, instance.invoke_func(0, (81_018_001, 9_001)).unwrap());
-    assert_eq!(0, instance.invoke_func(0, (i32::MIN, -1)).unwrap());
-
-    assert_eq!(0, instance.invoke_func(0, (i32::MIN, -1)).unwrap());
-    assert_eq!(-20, instance.invoke_func(0, (-20, 1)).unwrap());
-    assert_eq!(2147483638, instance.invoke_func(0, (-20, 2)).unwrap());
-    assert_eq!(1431655758, instance.invoke_func(0, (-20, 3)).unwrap());
-    assert_eq!(1073741819, instance.invoke_func(0, (-20, 4)).unwrap());
+    assert_eq!(
+        10,
+        instance.invoke_named("unsigned_division", (20, 2)).unwrap()
+    );
+    assert_eq!(
+        9_001,
+        instance
+            .invoke_named("unsigned_division", (81_018_001, 9_001))
+            .unwrap()
+    );
+    assert_eq!(
+        0,
+        instance
+            .invoke_named("unsigned_division", (i32::MIN, -1))
+            .unwrap()
+    );
+
+    assert_eq!(
+        0,
+        instance
+            .invoke_named("unsigned_division", (i32::MIN, -1))
+            .unwrap()
+    );
+    assert_eq!(
+        -20,
+        instance
+            .invoke_named("unsigned_division", (-20, 1))
+            .unwrap()
+    );
+    assert_eq!(
+        2147483638,
+        instance
+            .invoke_named("unsigned_division", (-20, 2))
+            .unwrap()
+    );
+    assert_eq!(
+        1431655758,
+        instance
+            .invoke_named("unsigned_division", (-20, 3))
+            .unwrap()
+    );
+    assert_eq!(
+        1073741819,
+        instance
+            .invoke_named("unsigned_division", (-20, 4))
+            .unwrap()
+    );
 }
 
 /// A simple function to test unsigned division's RuntimeError when dividing by 0
@@ -134,7 +206,7 @@ pub fn division_unsigned_panic_dividend_0() {
 
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    let result = instance.invoke_func::<(i32, i32), i32>(0, (222, 0));
+    let result = instance.invoke_named::<(i32, i32), i32>("unsigned_division", (222, 0));
 
     assert_eq!(result.unwrap_err(), RuntimeError(DivideBy0));
 }
diff --git a/tests/arithmetic/multiply.rs b/tests/arithmetic/multiply.rs
@@ -18,10 +18,16 @@ pub fn multiply() {
 
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(33, instance.invoke_func(0, 11).unwrap());
-    assert_eq!(0, instance.invoke_func(0, 0).unwrap());
-    assert_eq!(-30, instance.invoke_func(0, -10).unwrap());
+    assert_eq!(33, instance.invoke_named("multiply", 11).unwrap());
+    assert_eq!(0, instance.invoke_named("multiply", 0).unwrap());
+    assert_eq!(-30, instance.invoke_named("multiply", -10).unwrap());
 
-    assert_eq!(i32::MAX - 5, instance.invoke_func(0, i32::MAX - 1).unwrap());
-    assert_eq!(i32::MIN + 3, instance.invoke_func(0, i32::MIN + 1).unwrap());
+    assert_eq!(
+        i32::MAX - 5,
+        instance.invoke_named("multiply", i32::MAX - 1).unwrap()
+    );
+    assert_eq!(
+        i32::MIN + 3,
+        instance.invoke_named("multiply", i32::MIN + 1).unwrap()
+    );
 }
diff --git a/tests/arithmetic/remainder.rs b/tests/arithmetic/remainder.rs
@@ -26,14 +26,17 @@ pub fn remainder_signed_simple() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(0, instance.invoke_func(0, (20, 2)).unwrap());
-    assert_eq!(999, instance.invoke_func(0, (10_000, 9_001)).unwrap());
-    assert_eq!(-2, instance.invoke_func(0, (-20, 3)).unwrap());
-    assert_eq!(-2, instance.invoke_func(0, (-20, -3)).unwrap());
-    assert_eq!(2, instance.invoke_func(0, (20, -3)).unwrap());
-    assert_eq!(2, instance.invoke_func(0, (20, 3)).unwrap());
-    assert_eq!(0, instance.invoke_func(0, (i32::MIN, -1)).unwrap());
-    assert_eq!(0, instance.invoke_func(0, (i32::MIN, 2)).unwrap());
+    assert_eq!(0, instance.invoke_named("rem_s", (20, 2)).unwrap());
+    assert_eq!(
+        999,
+        instance.invoke_named("rem_s", (10_000, 9_001)).unwrap()
+    );
+    assert_eq!(-2, instance.invoke_named("rem_s", (-20, 3)).unwrap());
+    assert_eq!(-2, instance.invoke_named("rem_s", (-20, -3)).unwrap());
+    assert_eq!(2, instance.invoke_named("rem_s", (20, -3)).unwrap());
+    assert_eq!(2, instance.invoke_named("rem_s", (20, 3)).unwrap());
+    assert_eq!(0, instance.invoke_named("rem_s", (i32::MIN, -1)).unwrap());
+    assert_eq!(0, instance.invoke_named("rem_s", (i32::MIN, 2)).unwrap());
 }
 
 /// A simple function to test signed remainder's RuntimeError when dividing by 0
@@ -46,7 +49,7 @@ pub fn remainder_signed_panic_dividend_0() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    let result = instance.invoke_func::<(i32, i32), i32>(0, (222, 0));
+    let result = instance.invoke_named::<(i32, i32), i32>("rem_s", (222, 0));
 
     assert_eq!(
         result.unwrap_err(),
@@ -64,26 +67,37 @@ pub fn remainder_unsigned_simple() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(0, instance.invoke_func(0, (i32::MIN, 2)).unwrap());
-    assert_eq!(i32::MIN, instance.invoke_func(0, (i32::MIN, -2)).unwrap());
+    assert_eq!(0, instance.invoke_named("rem_u", (i32::MIN, 2)).unwrap());
+    assert_eq!(
+        i32::MIN,
+        instance.invoke_named("rem_u", (i32::MIN, -2)).unwrap()
+    );
     assert_eq!(
         (i32::MIN + 2) * (-1),
-        instance.invoke_func(0, (-2, i32::MIN)).unwrap()
+        instance.invoke_named("rem_u", (-2, i32::MIN)).unwrap()
     );
-    assert_eq!(2, instance.invoke_func(0, (2, i32::MIN)).unwrap());
+    assert_eq!(2, instance.invoke_named("rem_u", (2, i32::MIN)).unwrap());
     assert_eq!(
         i32::MAX,
-        instance.invoke_func(0, (i32::MAX, i32::MIN)).unwrap()
+        instance
+            .invoke_named("rem_u", (i32::MAX, i32::MIN))
+            .unwrap()
     );
 
-    assert_eq!(0, instance.invoke_func(0, (20, 2)).unwrap());
-    assert_eq!(999, instance.invoke_func(0, (10_000, 9_001)).unwrap());
-    assert_eq!(2, instance.invoke_func(0, (-20, 3)).unwrap());
-    assert_eq!(-20, instance.invoke_func(0, (-20, -3)).unwrap());
-    assert_eq!(20, instance.invoke_func(0, (20, -3)).unwrap());
-    assert_eq!(2, instance.invoke_func(0, (20, 3)).unwrap());
-    assert_eq!(i32::MIN, instance.invoke_func(0, (i32::MIN, -1)).unwrap());
-    assert_eq!(0, instance.invoke_func(0, (i32::MIN, 2)).unwrap());
+    assert_eq!(0, instance.invoke_named("rem_u", (20, 2)).unwrap());
+    assert_eq!(
+        999,
+        instance.invoke_named("rem_u", (10_000, 9_001)).unwrap()
+    );
+    assert_eq!(2, instance.invoke_named("rem_u", (-20, 3)).unwrap());
+    assert_eq!(-20, instance.invoke_named("rem_u", (-20, -3)).unwrap());
+    assert_eq!(20, instance.invoke_named("rem_u", (20, -3)).unwrap());
+    assert_eq!(2, instance.invoke_named("rem_u", (20, 3)).unwrap());
+    assert_eq!(
+        i32::MIN,
+        instance.invoke_named("rem_u", (i32::MIN, -1)).unwrap()
+    );
+    assert_eq!(0, instance.invoke_named("rem_u", (i32::MIN, 2)).unwrap());
 }
 
 /// A simple function to test signed remainder's RuntimeError when dividing by 0
@@ -96,7 +110,7 @@ pub fn remainder_unsigned_panic_dividend_0() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    let result = instance.invoke_func::<(i32, i32), i32>(0, (222, 0));
+    let result = instance.invoke_named::<(i32, i32), i32>("rem_u", (222, 0));
 
     assert_eq!(
         result.unwrap_err(),

diff --git a/tests/basic_memory.rs b/tests/basic_memory.rs
@@ -20,6 +20,6 @@ fn basic_memory() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    let _ = instance.invoke_func::<i32, ()>(0, 42);
-    assert_eq!(42, instance.invoke_func(1, ()).unwrap());
+    let _ = instance.invoke_named::<i32, ()>("store_num", 42);
+    assert_eq!(42, instance.invoke_named("load_num", ()).unwrap());
 }
diff --git a/tests/globals.rs b/tests/globals.rs
@@ -28,8 +28,8 @@ fn globals() {
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
     // Set global to 17. 3 is returned as previous (default) value.
-    assert_eq!(3, instance.invoke_func(0, 17).unwrap());
+    assert_eq!(3, instance.invoke_named("set", 17).unwrap());
 
     // Now 17 will be returned when getting the global
-    assert_eq!(17, instance.invoke_func(1, ()).unwrap());
+    assert_eq!(17, instance.invoke_named("get", ()).unwrap());
 }
diff --git a/tests/same_type_fn.rs b/tests/same_type_fn.rs
@@ -21,6 +21,6 @@ fn same_type_fn() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(-5, instance.invoke_func(0, -6).unwrap());
-    assert_eq!(-4, instance.invoke_func(1, -6).unwrap());
+    assert_eq!(-5, instance.invoke_named("add_one", -6).unwrap());
+    assert_eq!(-4, instance.invoke_named("add_two", -6).unwrap());
 }
diff --git a/tests/start_function.rs b/tests/start_function.rs
@@ -25,5 +25,5 @@ fn start_function() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(42, instance.invoke_func(1, ()).unwrap());
+    assert_eq!(42, instance.invoke_named("load_num", ()).unwrap());
 }