Supply default function

.prettierignore

@@ -6,3 +6,4 @@
 /tests/ts/fixture
 /third_party
 /tests/cpp/lit/**/*.json
+/tests/as/default.test.ts

jest.config.ts

@@ -15,6 +15,7 @@ const config: JestConfigWithTsJest = {
   moduleNameMapper: {
     "^(\\.{1,2}/.*)\\.js$": "$1",
   },
+  modulePathIgnorePatterns: ["tests/ts/e2e"],
   testPathIgnorePatterns: ["./dist"],
   testTimeout: 10000,
 };

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,26 @@ 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]?.[funcName]) {
+            if (!importObject[moduleName]) {
+              importObject[moduleName] = {};
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+            (importObject[moduleName] as any)[funcName] = (...args: any[]): any => {
+              // notify that a default function has been called
+              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/ts/e2e/default.test.ts

@@ -0,0 +1,47 @@
+import { describe, test, expect, endTest } from "../../../assembly";
+
+// 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();

tests/ts/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "assemblyscript/std/assembly.json",
+  "include": ["./e2e/*.ts"],
+  "compilerOptions": {
+    "strictBindCallApply": false
+  }
+}