chore: modify tests to use new API changes

Signed-off-by: George Cosma <[email protected]>
DLR-FT · Sep 25, 2024 · 09c3435 · 09c3435
1 parent 7de2fe2
commit 09c3435
Show file tree

Hide file tree

Showing 21 changed files with 7,236 additions and 1,333 deletions.
diff --git a/benches/hook_performance_impact.rs b/benches/hook_performance_impact.rs
@@ -1,6 +1,6 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
-use wasm::{hooks::HookSet, validate, RuntimeInstance};
+use wasm::{hooks::HookSet, validate, RuntimeInstance, DEFAULT_MODULE};
 
 fn criterion_benchmark(c: &mut Criterion) {
     let wat = r#"
@@ -52,14 +52,18 @@ fn criterion_benchmark(c: &mut Criterion) {
     }
 
     let mut instance_non_empty_hookset =
-        RuntimeInstance::new_with_hooks(&validation_info, MyCustomHookSet).unwrap();
+        RuntimeInstance::new_with_hooks(DEFAULT_MODULE, &validation_info, MyCustomHookSet).unwrap();
 
+    let test_fn = instance_empty_hookset.get_function_by_index(0, 2).unwrap();
     c.bench_function("invoke_func EmptyHookSet", |b| {
-        b.iter(|| instance_empty_hookset.invoke_func::<_, ()>(black_box(2), black_box(42_i32)))
+        b.iter(|| instance_empty_hookset.invoke::<_, ()>(&test_fn, black_box(42_i32)))
     });
 
+    let test_fn = instance_non_empty_hookset
+        .get_function_by_index(0, 2)
+        .unwrap();
     c.bench_function("invoke_func MyCustomHookSet", |b| {
-        b.iter(|| instance_non_empty_hookset.invoke_func::<_, ()>(black_box(2), black_box(42_i32)))
+        b.iter(|| instance_non_empty_hookset.invoke::<_, ()>(&test_fn, black_box(42_i32)))
     });
 }
 

diff --git a/examples/stuff/main.rs b/examples/stuff/main.rs
@@ -53,15 +53,26 @@ fn main() -> ExitCode {
         }
     };
 
-    let twelve: i32 = instance.invoke_func(1, (5, 7)).unwrap();
+    let twelve: i32 = instance
+        .invoke(&instance.get_function_by_index(0, 1).unwrap(), (5, 7))
+        .unwrap();
     assert_eq!(twelve, 12);
 
-    let twelve_plus_one: i32 = instance.invoke_func(0, twelve).unwrap();
+    let twelve_plus_one: i32 = instance
+        .invoke(&instance.get_function_by_index(0, 0).unwrap(), twelve)
+        .unwrap();
     assert_eq!(twelve_plus_one, 13);
 
-    instance.invoke_func::<_, ()>(2, 42_i32).unwrap();
+    instance
+        .invoke::<_, ()>(&instance.get_function_by_index(0, 2).unwrap(), 42_i32)
+        .unwrap();
 
-    assert_eq!(instance.invoke_func::<(), i32>(3, ()).unwrap(), 42_i32);
+    assert_eq!(
+        instance
+            .invoke::<(), i32>(&instance.get_function_by_index(0, 3).unwrap(), ())
+            .unwrap(),
+        42_i32
+    );
 
     ExitCode::SUCCESS
 }
diff --git a/tests/add_one.rs b/tests/add_one.rs
@@ -1,4 +1,4 @@
-use wasm::{validate, RuntimeInstance};
+use wasm::{validate, RuntimeInstance, DEFAULT_MODULE};
 
 const MULTIPLY_WAT_TEMPLATE: &'static str = r#"
     (module
@@ -18,9 +18,39 @@ fn i32_add_one() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(12, instance.invoke_named("add_one", 11).unwrap());
-    assert_eq!(1, instance.invoke_named("add_one", 0).unwrap());
-    assert_eq!(-5, instance.invoke_named("add_one", -6).unwrap());
+    assert_eq!(
+        12,
+        instance
+            .invoke(
+                &instance
+                    .get_function_by_name(DEFAULT_MODULE, "add_one")
+                    .unwrap(),
+                11
+            )
+            .unwrap()
+    );
+    assert_eq!(
+        1,
+        instance
+            .invoke(
+                &instance
+                    .get_function_by_name(DEFAULT_MODULE, "add_one")
+                    .unwrap(),
+                0
+            )
+            .unwrap()
+    );
+    assert_eq!(
+        -5,
+        instance
+            .invoke(
+                &instance
+                    .get_function_by_name(DEFAULT_MODULE, "add_one")
+                    .unwrap(),
+                -6
+            )
+            .unwrap()
+    );
 }
 
 /// A simple function to add 1 to an i64 and return the result
@@ -32,7 +62,22 @@ fn i64_add_one() {
     let validation_info = validate(&wasm_bytes).expect("validation failed");
     let mut instance = RuntimeInstance::new(&validation_info).expect("instantiation failed");
 
-    assert_eq!(12 as i64, instance.invoke_func(0, 11 as i64).unwrap());
-    assert_eq!(1 as i64, instance.invoke_func(0, 0 as i64).unwrap());
-    assert_eq!(-5 as i64, instance.invoke_func(0, -6 as i64).unwrap());
+    assert_eq!(
+        12 as i64,
+        instance
+            .invoke(&instance.get_function_by_index(0, 0).unwrap(), 11 as i64)
+            .unwrap()
+    );
+    assert_eq!(
+        1 as i64,
+        instance
+            .invoke(&instance.get_function_by_index(0, 0).unwrap(), 0 as i64)
+            .unwrap()
+    );
+    assert_eq!(
+        -5 as i64,
+        instance
+            .invoke(&instance.get_function_by_index(0, 0).unwrap(), -6 as i64)
+            .unwrap()
+    );
 }