Add more webassembly tests

Author: RoyalIcing

lib/components_guide/rustler/math.ex

@@ -19,7 +19,13 @@ defmodule ComponentsGuide.Rustler.Math do
 
   def add(_, _), do: error()
   def reverse_string(_), do: error()
-  def wasm_example(_, _), do: error()
+  def wasm_example_0(_, _), do: error()
+  def wasm_example_1_i32(_, _, _), do: error()
+  def wasm_example_2_i32(_, _, _, _), do: error()
+  
+  def wasm_example(source, f), do: wasm_example_0(source, f)
+  def wasm_example(source, f, a), do: wasm_example_1_i32(source, f, a)
+  def wasm_example(source, f, a, b), do: wasm_example_2_i32(source, f, a, b)
 
   defp error, do: :erlang.nif_error(:nif_not_loaded)
 end

native/componentsguide_rustler_math/src/lib.rs

@@ -14,16 +14,16 @@ fn reverse_string(a: String) -> String {
 }
 
 #[rustler::nif]
-fn wasm_example(source: String, f: String) -> Result<i32, Error> {
+fn wasm_example_0(source: String, f: String) -> Result<i32, Error> {
     // return Ok(5);
     //return Err(Error::Term(Box::new("hello")));
-    return match wasm_example_interal(source, f) {
+    return match wasm_example_0_internal(source, f) {
       Ok(v) => Ok(v),
       Err(e) => Err(Error::Term(Box::new(e.to_string())))
     }
 }
 
-fn wasm_example_interal(source: String, f: String) -> Result<i32, anyhow::Error> {
+fn wasm_example_0_internal(source: String, f: String) -> Result<i32, anyhow::Error> {
     let engine = Engine::default();
 
     // We start off by creating a `Module` which represents a compiled form
@@ -60,4 +60,100 @@ fn wasm_example_interal(source: String, f: String) -> Result<i32, anyhow::Error>
     return Ok(result);
 }
 
-rustler::init!("Elixir.ComponentsGuide.Rustler.Math", [add, reverse_string, wasm_example]);
+#[rustler::nif]
+fn wasm_example_1_i32(source: String, f: String, a: i32) -> Result<i32, Error> {
+    return match wasm_example_1_i32_internal(source, f, a) {
+      Ok(v) => Ok(v),
+      Err(e) => Err(Error::Term(Box::new(e.to_string())))
+    }
+}
+
+fn wasm_example_1_i32_internal(source: String, f: String, a: i32) -> Result<i32, anyhow::Error> {
+    let engine = Engine::default();
+
+    // We start off by creating a `Module` which represents a compiled form
+    // of our input wasm module. In this case it'll be JIT-compiled after
+    // we parse the text format.
+    let module = Module::new(&engine, source)?;
+
+    // A `Store` is what will own instances, functions, globals, etc. All wasm
+    // items are stored within a `Store`, and it's what we'll always be using to
+    // interact with the wasm world. Custom data can be stored in stores but for
+    // now we just use `()`.
+    let mut store = Store::new(&engine, ());
+
+    // With a compiled `Module` we can then instantiate it, creating
+    // an `Instance` which we can actually poke at functions on.
+    let instance = Instance::new(&mut store, &module, &[])?;
+
+    // The `Instance` gives us access to various exported functions and items,
+    // which we access here to pull out our `answer` exported function and
+    // run it.
+    let answer = instance
+        .get_func(&mut store, &f)
+        .expect(&format!("{} was not an exported function", f));
+
+    // There's a few ways we can call the `answer` `Func` value. The easiest
+    // is to statically assert its signature with `typed` (in this case
+    // asserting it takes no arguments and returns one i32) and then call it.
+    let answer = answer.typed::<(i32), i32, _>(&store)?;
+
+    // And finally we can call our function! Note that the error propagation
+    // with `?` is done to handle the case where the wasm function traps.
+    let result = answer.call(&mut store, (a))?;
+
+    return Ok(result);
+}
+
+#[rustler::nif]
+fn wasm_example_2_i32(source: String, f: String, a: i32, b: i32) -> Result<i32, Error> {
+    return match wasm_example_2_i32_internal(source, f, a, b) {
+      Ok(v) => Ok(v),
+      Err(e) => Err(Error::Term(Box::new(e.to_string())))
+    }
+}
+
+fn wasm_example_2_i32_internal(source: String, f: String, a: i32, b: i32) -> Result<i32, anyhow::Error> {
+    let engine = Engine::default();
+
+    // We start off by creating a `Module` which represents a compiled form
+    // of our input wasm module. In this case it'll be JIT-compiled after
+    // we parse the text format.
+    let module = Module::new(&engine, source)?;
+
+    // A `Store` is what will own instances, functions, globals, etc. All wasm
+    // items are stored within a `Store`, and it's what we'll always be using to
+    // interact with the wasm world. Custom data can be stored in stores but for
+    // now we just use `()`.
+    let mut store = Store::new(&engine, ());
+
+    // With a compiled `Module` we can then instantiate it, creating
+    // an `Instance` which we can actually poke at functions on.
+    let instance = Instance::new(&mut store, &module, &[])?;
+
+    // The `Instance` gives us access to various exported functions and items,
+    // which we access here to pull out our `answer` exported function and
+    // run it.
+    let answer = instance
+        .get_func(&mut store, &f)
+        .expect(&format!("{} was not an exported function", f));
+
+    // There's a few ways we can call the `answer` `Func` value. The easiest
+    // is to statically assert its signature with `typed` (in this case
+    // asserting it takes no arguments and returns one i32) and then call it.
+    let answer = answer.typed::<(i32, i32), i32, _>(&store)?;
+
+    // And finally we can call our function! Note that the error propagation
+    // with `?` is done to handle the case where the wasm function traps.
+    let result = answer.call(&mut store, (a, b))?;
+
+    return Ok(result);
+}
+
+rustler::init!("Elixir.ComponentsGuide.Rustler.Math", [
+  add,
+  reverse_string,
+  wasm_example_0,
+  wasm_example_1_i32,
+  wasm_example_2_i32
+]);

test/components_guide/rustler/math_test.exs

@@ -22,4 +22,80 @@ defmodule ComponentsGuide.Rustler.MathTest do
 
     assert Math.wasm_example(wasm_source, "answer") == 42
   end
+  
+  test "wasm_example/2 dsl" do
+    # wasm_source = module(func(export("answer"), :result_i32, {:i32_const, 42}))
+    # wasm_source = module(func(export("answer"), Result.i32, {I32.const, 42}))
+    # wasm_source = module({:func, {:export, "answer"}, {:result, :i32}, {:i32_const, 42}})
+    
+    wasm_source = """
+    (module
+      (func (export "answer") (result i32)
+       i32.const 42
+      )
+    )
+    """
+
+    assert Math.wasm_example(wasm_source, "answer") == 42
+  end
+  
+  test "wasm_example/4 adding two numbers" do
+    wasm_source = """
+    (module
+      (func $add (param $a i32) (param $b i32) (result i32)
+        local.get $a
+        local.get $b
+        i32.add)
+      (export "add" (func $add))
+    )
+    """
+
+    assert Math.wasm_example(wasm_source, "add", 7, 5) == 12
+  end
+  
+  test "wasm_example/4 multiplying two numbers" do
+    wasm_source = """
+    (module
+      (func $multiply (param $a i32) (param $b i32) (result i32)
+        local.get $a
+        local.get $b
+        i32.mul)
+      (export "multiply" (func $multiply))
+    )
+    """
+
+    assert Math.wasm_example(wasm_source, "multiply", 7, 5) == 35
+  end
+  
+  test "wasm_example/4 checking a number is within a range" do
+    wasm_source = """
+    (module
+      (func $validate (param $num i32) (result i32)
+        (if (result i32)
+          (i32.lt_u (local.get $num) (i32.const 1))
+          (then return (i32.const 0))
+          (else (if (result i32)
+            (i32.gt_u (local.get $num) (i32.const 255))
+            (then return (i32.const 0))
+            (else return (i32.const 1))
+          ))
+        )
+      )
+      (export "validate" (func $validate))
+    )
+    """
+
+    assert Math.wasm_example(wasm_source, "validate", 0) == 0
+    assert Math.wasm_example(wasm_source, "validate", 1) == 1
+    assert Math.wasm_example(wasm_source, "validate", 10) == 1
+    assert Math.wasm_example(wasm_source, "validate", 13) == 1
+    assert Math.wasm_example(wasm_source, "validate", 255) == 1
+    assert Math.wasm_example(wasm_source, "validate", 256) == 0
+  end
+  
+  # defwasm multiply(a, b) do
+  #   Wasm.func multiply(a, b) do
+  #     W32.mul(a, b)
+  #   end
+  # end
 end