feat: implement setup and teardown

Author: HerrCai0907

assembly/env.ts

@@ -12,6 +12,14 @@ export namespace assertResult {
   export declare function registerTestFunction(index: u32): void;
 
 
+  @external("__unittest_framework_env","registerBeforeEachFunction")
+  export declare function registerBeforeEachFunction(index: u32): boolean;
+
+
+  @external("__unittest_framework_env","registerAfterEachFunction")
+  export declare function registerAfterEachFunction(index: u32): boolean;
+
+
   @external("__unittest_framework_env","collectCheckResult")
   export declare function collectCheckResult(
     result: bool,

assembly/implement.ts

@@ -15,9 +15,15 @@ export function testImpl(name: string, testFunction: () => void): void {
   assertResult.removeDescription();
 }
 
-export function beforeEachImpl(func: () => void): void {}
+export function beforeEachImpl(func: () => void): void {
+  const result = assertResult.registerBeforeEachFunction(func.index);
+  assert(result, "register setup function failed");
+}
 
-export function afterEachImpl(func: () => void): void {}
+export function afterEachImpl(func: () => void): void {
+  const result = assertResult.registerAfterEachFunction(func.index);
+  assert(result, "register teardown function failed");
+}
 
 export function mockImpl<T extends Function>(
   originalFunction: T,

src/core/execute.ts

@@ -77,18 +77,24 @@ async function nodeExecutor(
   }
   executionRecorder.finishTestFunction();
 
-  const execTestFunction = ins.exports["executeTestFunction"];
+  const execTestFunction = ins.exports["executeTestFunction"] as (a: number) => void;
   assert(typeof execTestFunction === "function");
 
   for (const testCase of executionRecorder.testCases) {
     if (isCrashed) {
       break;
     }
-    const { fullName, functionIndex } = testCase;
+    const { fullName, functionIndex, setupFunctions, teardownFunctions } = testCase;
     if (matchedTestNames.length === 0 || matchedTestNames.includes(fullName)) {
       executionRecorder.startTestFunction(fullName);
       try {
-        (execTestFunction as (a: number) => void)(functionIndex);
+        for (const setupFuncIndex of setupFunctions) {
+          execTestFunction(setupFuncIndex);
+        }
+        execTestFunction(functionIndex);
+        for (const teardownFuncIndex of teardownFunctions) {
+          execTestFunction(teardownFuncIndex);
+        }
       } catch (error) {
         await exceptionHandler(error);
       }

src/core/executionRecorder.ts

@@ -46,15 +46,21 @@ export class ExecutionResult implements IExecutionResult {
 
 class TestBlock {
   constructor(public description: string) {}
+  setupFunctions: number[] = [];
+  teardownFunctions: number[] = [];
 }
 
-class TestCase {
+export class TestCase {
   fullName: string;
+  setupFunctions: number[];
+  teardownFunctions: number[];
   constructor(
     testBlockStack: TestBlock[],
     public functionIndex: number
   ) {
     this.fullName = testBlockStack.map((block) => block.description).join(" ");
+    this.setupFunctions = testBlockStack.flatMap((block) => block.setupFunctions);
+    this.teardownFunctions = testBlockStack.flatMap((block) => block.teardownFunctions);
   }
 }
 
@@ -73,6 +79,30 @@ export class ExecutionRecorder implements UnitTestFramework {
   _removeDescription(): void {
     this.testBlockStack.pop();
   }
+
+  get lastTestBlock(): TestBlock | undefined {
+    return this.testBlockStack[this.testBlockStack.length - 1];
+  }
+  // return false if error
+  _registerSetup(functionIndex: number): boolean {
+    const lastTestBlock = this.lastTestBlock;
+    if (lastTestBlock === undefined) {
+      return false;
+    } else {
+      lastTestBlock.setupFunctions.push(functionIndex);
+      return true;
+    }
+  }
+  // return false if error
+  _registerTeardown(functionIndex: number): boolean {
+    const lastTestBlock = this.lastTestBlock;
+    if (lastTestBlock === undefined) {
+      return false;
+    } else {
+      lastTestBlock.teardownFunctions.push(functionIndex);
+      return true;
+    }
+  }
   _addTestCase(functionIndex: number): void {
     this.testCases.push(new TestCase(this.testBlockStack, functionIndex));
   }
@@ -128,6 +158,12 @@ export class ExecutionRecorder implements UnitTestFramework {
       registerTestFunction: (index: number): void => {
         this._addTestCase(index);
       },
+      registerBeforeEachFunction: (index: number): boolean => {
+        return this._registerSetup(index);
+      },
+      registerAfterEachFunction: (index: number): boolean => {
+        return this._registerTeardown(index);
+      },
       collectCheckResult: (result: number, codeInfoIndex: number, actualValue: number, expectValue: number): void => {
         this.collectCheckResult(
           result !== 0,

tests/e2e/run.js

@@ -55,13 +55,15 @@ runEndToEndTest("compilationFailed", "", (error, stdout, stderr) => {
   assert(error.code === 2);
 });
 
+runEndToEndTest("isolated-cli", "--isolated false", (error, stdout, stderr) => {});
+runEndToEndTest("isolated-false", "", (error, stdout, stderr) => {});
+runEndToEndTest("isolated-true", "", (error, stdout, stderr) => {});
+
 runEndToEndTest("printLogInFailedInfo", "", (error, stdout, stderr) => {
   assert(error.code === 1);
 });
 
-runEndToEndTest("isolated-true", "", (error, stdout, stderr) => {});
-runEndToEndTest("isolated-false", "", (error, stdout, stderr) => {});
-runEndToEndTest("isolated-cli", "--isolated false", (error, stdout, stderr) => {});
+runEndToEndTest("setup-teardown", "", (error, stdout, stderr) => {});
 
 runEndToEndTest(
   "testFiles",

tests/e2e/setup-teardown/as-test.config.js

@@ -0,0 +1,14 @@
+import path from "node:path";
+
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+
+/**
+ * @type {import("../../../config.d.ts").Config}
+ */
+export default {
+  include: [__dirname],
+  temp: path.join(__dirname, "tmp"),
+  output: path.join(__dirname, "tmp"),
+  mode: [],
+  isolated: true,
+};

tests/e2e/setup-teardown/setup.test.ts

@@ -0,0 +1,26 @@
+import { test, expect, describe, beforeEach } from "../../../assembly";
+
+let setup0 = 0;
+let setup1 = 0;
+describe("setup", () => {
+  beforeEach(() => {
+    setup0 = 10;
+    setup1 = 20;
+  });
+  test("1st", () => {
+    expect(setup0).equal(10);
+    expect(setup1).equal(20);
+    setup0 = 100;
+    setup1 = 200;
+  });
+  test("2nd", () => {
+    expect(setup0).equal(10);
+    expect(setup1).equal(20);
+    setup0 = 100;
+    setup1 = 200;
+  });
+  test("3nd", () => {
+    expect(setup0).equal(10);
+    expect(setup1).equal(20);
+  });
+});

tests/e2e/setup-teardown/setup_out_of_block.test.ts

@@ -0,0 +1,3 @@
+import { beforeEach } from "../../../assembly";
+
+beforeEach(() => {});

tests/e2e/setup-teardown/stdout.txt

@@ -0,0 +1,16 @@
+code analysis: OK
+compile test files: OK
+instrument: OK
+execute test files: OK
+
+test case: 12/13 (success/total)
+
+Error Message: 
+  tests/e2e/setup-teardown/tmp/setup_out_of_block.test - init: 
+    Test Crashed!
+Reason: unreachable
+  at assembly/implement/beforeEachImpl (assembly/implement.ts:20:2)
+  at assembly/index/beforeEach (assembly/index.ts:47:2)
+  at start:tests/e2e/setup-teardown/setup_out_of_block.test (tests/e2e/setup-teardown/tmp/setup_out_of_block.test.instrumented.wasm:1:547)
+  at ~start (tests/e2e/setup-teardown/tmp/setup_out_of_block.test.instrumented.wasm:1:325)
+

tests/e2e/setup-teardown/teardown.test.ts

@@ -0,0 +1,26 @@
+import { test, expect, describe, afterEach } from "../../../assembly";
+
+let teardown0 = 0;
+let teardown1 = 0;
+describe("teardown", () => {
+  afterEach(() => {
+    teardown0 = 10;
+    teardown1 = 20;
+  });
+  test("1st", () => {
+    expect(teardown0).equal(0);
+    expect(teardown1).equal(0);
+    teardown0 = 100;
+    teardown1 = 200;
+  });
+  test("2nd", () => {
+    expect(teardown0).equal(10);
+    expect(teardown1).equal(20);
+    teardown0 = 100;
+    teardown1 = 200;
+  });
+  test("3nd", () => {
+    expect(teardown0).equal(10);
+    expect(teardown1).equal(20);
+  });
+});