supply default function

Author: meowbmw

assembly/default.ts

@@ -0,0 +1,3 @@
+export function emptyFunction(): void {
+  // this is an empty function used to make sure default.test.ts will get run
+}

src/core/execute.ts

@@ -6,7 +6,7 @@ import { instantiate, Imports as ASImports } from "@assemblyscript/loader";
 import { AssertResult } from "../assertResult.js";
 import { Imports, ImportsArgument } from "../index.js";
 import { IAssertResult, InstrumentResult } from "../interface.js";
-import { mockInstruFunc, covInstruFunc } from "../utils/import.js";
+import { mockInstruFunc, covInstruFunc, parseWasmImports } from "../utils/import.js";
 const readFile = promises.readFile;
 
 function nodeExecutor(wasms: string[], outFolder: string, imports: Imports) {
@@ -30,6 +30,24 @@ function nodeExecutor(wasms: string[], outFolder: string, imports: Imports) {
         ...userDefinedImportsObject,
       } as ASImports;
       const binary = await readFile(wasm);
+      // getting a list of wasm import functions
+      const importList = await parseWasmImports(binary);
+      // supplying default function here, so no more need to define all of them in as-test.js
+      for (const imp of importList) {
+        if (imp.kind === "function") {
+          const moduleName = imp.module;
+          const funcName = imp.name;
+          if (!importObject[moduleName]) {
+            importObject[moduleName] = {};
+          }
+          if (!importObject[moduleName][funcName]) {
+            importObject[moduleName][funcName] = (...args: any[]): any => {
+              console.log(`Default stub called for ${moduleName}.${funcName}, args:`, args);
+              return 0;
+            };
+          }
+        }
+      }
       const ins = await instantiate(binary, importObject);
       importsArg.module = ins.module;
       importsArg.instance = ins.instance;

src/utils/import.ts

@@ -87,3 +87,19 @@ export function covInstruFunc(wasm: string) {
   };
   return { covInstrument };
 }
+
+export async function parseWasmImports(binary: Buffer) {
+  // list imports of a given wasm binary (buffer)
+  const mod = await WebAssembly.compile(binary);
+
+  const importList = WebAssembly.Module.imports(mod);
+
+  // importList format should be as follows：
+  // [
+  //   { module: 'env', name: 'memory', kind: 'memory' },
+  //   { module: 'env', name: 'myFunction', kind: 'function' },
+  //   ...
+  // ]
+
+  return importList;
+}

tests/as/default.test.ts

@@ -0,0 +1,48 @@
+import { describe, test, expect, endTest } from "../../assembly";
+import { emptyFunction } from "../../assembly/default";
+
+// Default Stub Injection Tests
+// Making sure that external functions can supplied with an empty default function so that users will be free of supplying their own
+
+@external("myenv", "processEvent")
+declare function processEvent(eventId: i32): void;
+
+@external("externalMath", "add")
+declare function add(a: i32, b: i32): i32;
+
+@external("system", "getStatus")
+declare function getStatus(): i32;
+
+@external("logger", "logWarning")
+declare function logWarning(messageId: i32): i32;
+
+@external("customOps", "combineValues")
+declare function combineValues(a: i32, b: f32, c: i64): i32;
+
+describe("Default Stub Injection Tests", () => {
+    test("Test processEvent (i32) -> void", () => {
+        processEvent(101);
+    });
+
+    test("Test add (i32, i32) -> i32", () => {
+        const result = add(10, 5);
+        expect(result).equal(0);
+    });
+
+    test("Test getStatus () -> i32", () => {
+        const result = getStatus();
+        expect(result).equal(0);
+    });
+
+    test("Test logWarning (i32) -> i32", () => {
+        const result = logWarning(12345);
+        expect(result).equal(0);
+    });
+
+    test("Test combineValues (i32, f32, i64) -> i32", () => {
+        const result = combineValues(1, 2.5, 1000);
+        expect(result).equal(0);
+    });
+});
+
+endTest();