refactor: use ExecutionRecorder to collect assert result

It can reduce peak memory usage of wasm module because there are not need to encode assert info to json at the end of exection

Author: HerrCai0907

assembly/assertCollector.ts

@@ -0,0 +1,18 @@
+export namespace assertResult {
+
+  @external("__unittest_framework_env","addDescription")
+  export declare function addDescription(description: string): void;
+
+
+  @external("__unittest_framework_env","removeDescription")
+  export declare function removeDescription(): void;
+
+
+  @external("__unittest_framework_env","collectCheckResult")
+  export declare function collectCheckResult(
+    result: bool,
+    codeInfoIndex: number,
+    actualValue: string,
+    expectValue: string,
+  ): void;
+}

assembly/env.ts

@@ -1,5 +1,5 @@
 import { equal, isNull } from "./comparison";
-import { assertResult } from "./assertCollector";
+import { assertResult } from "./env";
 import { toJson } from "./formatPrint";
 
 

assembly/expect.ts

@@ -1,4 +1,4 @@
-import { assertResult } from "./assertCollector";
+import { assertResult } from "./env";
 import { MockFn, mockFunctionStatus } from "./mockInstrument";
 
 export function describeImpl(

assembly/implement.ts

@@ -5,58 +5,13 @@ import { basename } from "node:path";
 import { instantiate, Imports as ASImports } from "@assemblyscript/loader";
 import { AssertResult } from "../assertResult.js";
 import { Imports, ImportsArgument } from "../index.js";
-import { AssertFailMessage, AssertMessage, IAssertResult, InstrumentResult } from "../interface.js";
+import { InstrumentResult } from "../interface.js";
 import { mockInstruFunc, covInstruFunc } from "../utils/import.js";
 import { supplyDefaultFunction } from "../utils/index.js";
 import { parseImportFunctionInfo } from "../utils/wasmparser.js";
+import { ExecutionRecorder } from "./execution_recorder.js";
 const readFile = promises.readFile;
 
-class ExecutionRecorder implements IAssertResult {
-  total: number = 0;
-  fail: number = 0;
-  failed_info: AssertFailMessage = {};
-  currentTestDescriptions: string[] = [];
-
-  addDescription(description: string): void {
-    this.currentTestDescriptions.push(description);
-  }
-  removeDescription(): void {
-    this.currentTestDescriptions.pop();
-  }
-  collectCheckResult(result: boolean, codeInfoIndex: number, actualValue: string, expectValue: string): void {
-    this.total++;
-    if (!result) {
-      this.fail++;
-      const testCaseFullName = this.currentTestDescriptions.join(" - ");
-      const assertMessage: AssertMessage = [codeInfoIndex.toString(), actualValue, expectValue];
-      this.failed_info[testCaseFullName] = this.failed_info[testCaseFullName] || [];
-      this.failed_info[testCaseFullName].push(assertMessage);
-    }
-  }
-
-  getCollectionFuncSet(arg: ImportsArgument): Record<string, Record<string, unknown>> {
-    const exports = arg.exports!;
-    return {
-      __unittest_framework_env: {
-        addDescription: (description: number): void => {
-          this.addDescription(exports.__getString(description));
-        },
-        removeDescription: (): void => {
-          this.removeDescription();
-        },
-        collectCheckResult: (result: number, codeInfoIndex: number, actualValue: number, expectValue: number): void => {
-          this.collectCheckResult(
-            result != 0,
-            codeInfoIndex,
-            exports.__getString(actualValue),
-            exports.__getString(expectValue)
-          );
-        },
-      },
-    };
-  }
-}
-
 async function nodeExecutor(wasm: string, outFolder: string, imports: Imports): Promise<ExecutionRecorder> {
   const wasi = new WASI({
     args: ["node", basename(wasm)],

src/core/execute.ts

@@ -0,0 +1,47 @@
+import { ImportsArgument } from "../index.js";
+import { AssertFailMessage, AssertMessage, IAssertResult } from "../interface.js";
+
+export class ExecutionRecorder implements IAssertResult {
+  total: number = 0;
+  fail: number = 0;
+  failed_info: AssertFailMessage = {};
+  _currentTestDescriptions: string[] = [];
+
+  _addDescription(description: string): void {
+    this._currentTestDescriptions.push(description);
+  }
+  _removeDescription(): void {
+    this._currentTestDescriptions.pop();
+  }
+  collectCheckResult(result: boolean, codeInfoIndex: number, actualValue: string, expectValue: string): void {
+    this.total++;
+    if (!result) {
+      this.fail++;
+      const testCaseFullName = this._currentTestDescriptions.join(" - ");
+      const assertMessage: AssertMessage = [codeInfoIndex.toString(), actualValue, expectValue];
+      this.failed_info[testCaseFullName] = this.failed_info[testCaseFullName] || [];
+      this.failed_info[testCaseFullName].push(assertMessage);
+    }
+  }
+
+  getCollectionFuncSet(arg: ImportsArgument): Record<string, Record<string, unknown>> {
+    return {
+      __unittest_framework_env: {
+        addDescription: (description: number): void => {
+          this._addDescription(arg.exports!.__getString(description));
+        },
+        removeDescription: (): void => {
+          this._removeDescription();
+        },
+        collectCheckResult: (result: number, codeInfoIndex: number, actualValue: number, expectValue: number): void => {
+          this.collectCheckResult(
+            result != 0,
+            codeInfoIndex,
+            arg.exports!.__getString(actualValue),
+            arg.exports!.__getString(expectValue)
+          );
+        },
+      },
+    };
+  }
+}

src/core/execution_recorder.ts

@@ -0,0 +1,56 @@
+import { ExecutionRecorder } from "../../../../src/core/execution_recorder.js";
+
+describe("execution recorder", () => {
+  describe("description", () => {
+    test("add single description", () => {
+      const recorder = new ExecutionRecorder();
+      recorder._addDescription("description");
+
+      recorder.collectCheckResult(false, 0, "", "");
+      expect(recorder.failed_info).toHaveProperty("description");
+    });
+    test("add multiple descriptions", () => {
+      const recorder = new ExecutionRecorder();
+      recorder._addDescription("description1");
+      recorder._addDescription("description2");
+
+      recorder.collectCheckResult(false, 0, "", "");
+      expect(recorder.failed_info).toHaveProperty("description1 - description2");
+    });
+
+    test("remove  descriptions", () => {
+      const recorder = new ExecutionRecorder();
+      recorder._addDescription("description1");
+      recorder._addDescription("description2");
+      recorder._removeDescription();
+
+      recorder.collectCheckResult(false, 0, "", "");
+      expect(recorder.failed_info).toHaveProperty("description1");
+    });
+  });
+
+  describe("collectCheckResult", () => {
+    test("collect false result", () => {
+      const recorder = new ExecutionRecorder();
+      recorder.collectCheckResult(false, 0, "actual", "expect");
+
+      expect(recorder.total).toBe(1);
+      expect(recorder.fail).toBe(1);
+    });
+    test("collect true results", () => {
+      const recorder = new ExecutionRecorder();
+      recorder.collectCheckResult(true, 0, "actual1", "expect1");
+
+      expect(recorder.total).toBe(1);
+      expect(recorder.fail).toBe(0);
+    });
+    test("collect multiple results", () => {
+      const recorder = new ExecutionRecorder();
+      recorder.collectCheckResult(true, 0, "actual1", "expect1");
+      recorder.collectCheckResult(false, 1, "actual2", "expect2");
+
+      expect(recorder.total).toBe(2);
+      expect(recorder.fail).toBe(1);
+    });
+  });
+});

tests/ts/test/core/execution_recorder.test.ts

@@ -31,6 +31,7 @@ test("getIncludeFiles", () => {
   expect(getIncludeFiles(["src/core"], (s) => s.endsWith(".ts"))).toEqual([
     path.normalize("src/core/compile.ts"),
     path.normalize("src/core/execute.ts"),
+    path.normalize("src/core/execution_recorder.ts"),
     path.normalize("src/core/instrument.ts"),
     path.normalize("src/core/precompile.ts"),
   ]);