From 383e5cb9c1765e73cd012bb1d964116c60d0fc4c Mon Sep 17 00:00:00 2001 From: George Cosma Date: Fri, 12 Jul 2024 16:46:40 +0300 Subject: [PATCH] feat: named_invoke - refactor tests to use named invoke Signed-off-by: George Cosma --- src/execution/mod.rs | 1 + tests/arithmetic/division.rs | 116 +++++++++++++++++++++++++++------- tests/arithmetic/multiply.rs | 16 +++-- tests/arithmetic/remainder.rs | 60 +++++++++++------- tests/basic_memory.rs | 4 +- tests/globals.rs | 4 +- tests/same_type_fn.rs | 4 +- tests/start_function.rs | 2 +- 8 files changed, 150 insertions(+), 57 deletions(-) diff --git a/src/execution/mod.rs b/src/execution/mod.rs index e4076ef58..8049b8ff1 100644 --- a/src/execution/mod.rs +++ b/src/execution/mod.rs @@ -74,6 +74,7 @@ where func_name: &str, param: Param, ) -> Result { + // 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 index 693898d77..2a17710ab 100644 --- 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 index e2baf140c..d921f5b92 100644 --- 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 index c85c6fd47..f8fdb8e89 100644 --- 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 index 5d84fbb6e..82a4720bd 100644 --- 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::(0, 42); - assert_eq!(42, instance.invoke_func(1, ()).unwrap()); + let _ = instance.invoke_named::("store_num", 42); + assert_eq!(42, instance.invoke_named("load_num", ()).unwrap()); } diff --git a/tests/globals.rs b/tests/globals.rs index 7616d19fc..5abdf020d 100644 --- 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 index 347c8e450..908b4abcd 100644 --- 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 index d1a3e6bbc..c57ee01fb 100644 --- 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()); }