support testNamePattern option

Author: XMadrid

.gitignore

@@ -5,7 +5,7 @@
 /dist
 
 /build*
-/transform/listFunctions.mjs
+/transform/*.mjs
 /transform/tsconfig.tsbuildinfo
 
 /coverage

src/core/execute.ts

@@ -10,10 +10,16 @@ import { supplyDefaultFunction } from "../utils/index.js";
 import { parseImportFunctionInfo } from "../utils/wasmparser.js";
 import { ExecutionRecorder } from "./executionRecorder.js";
 import { CoverageRecorder } from "./covRecorder.js";
+import assert from "node:assert";
 
 const readFile = promises.readFile;
 
-async function nodeExecutor(wasm: string, outFolder: string, imports?: Imports): Promise<ExecutionRecorder> {
+async function nodeExecutor(
+  wasm: string,
+  outFolder: string,
+  matchedTestNames?: string[],
+  imports?: Imports
+): Promise<ExecutionRecorder> {
   const wasi = new WASI({
     args: ["node", basename(wasm)],
     env: process.env,
@@ -46,12 +52,23 @@ async function nodeExecutor(wasm: string, outFolder: string, imports?: Imports):
   try {
     wasi.start(ins);
     const execTestFunction = ins.exports["executeTestFunction"];
-    if (typeof execTestFunction === "function") {
-      for (const fncs of executionRecorder.registerFunctions) {
-        const functions = fncs[1];
-        (execTestFunction as (a: number) => void)(functions);
+    assert(typeof execTestFunction === "function");
+    if (matchedTestNames === undefined) {
+      // means execute all testFunctions
+      for (const functionInfo of executionRecorder.registerFunctions) {
+        const functionIndex = functionInfo[1];
+        (execTestFunction as (a: number) => void)(functionIndex);
         mockInstrumentFunc["mockFunctionStatus.clear"]();
       }
+    } else {
+      for (const functionInfo of executionRecorder.registerFunctions) {
+        const [testName, functionIndex] = functionInfo;
+        if (matchedTestNames.includes(testName)) {
+          console.log(testName);
+          (execTestFunction as (a: number) => void)(functionIndex);
+          mockInstrumentFunc["mockFunctionStatus.clear"]();
+        }
+      }
     }
   } catch (error) {
     if (error instanceof Error) {
@@ -66,14 +83,15 @@ async function nodeExecutor(wasm: string, outFolder: string, imports?: Imports):
 export async function execWasmBinarys(
   outFolder: string,
   instrumentResult: InstrumentResult[],
+  matchedTestNames?: string[],
   imports?: Imports
 ): Promise<AssertResult> {
   const assertRes = new AssertResult();
   ensureDirSync(outFolder);
   await Promise.all<void>(
     instrumentResult.map(async (res): Promise<void> => {
       const { instrumentedWasm, expectInfo } = res;
-      const recorder: ExecutionRecorder = await nodeExecutor(instrumentedWasm, outFolder, imports);
+      const recorder: ExecutionRecorder = await nodeExecutor(instrumentedWasm, outFolder, matchedTestNames, imports);
       await assertRes.merge(recorder, expectInfo);
     })
   );

src/core/executionRecorder.ts

@@ -14,14 +14,14 @@ export class ExecutionRecorder implements IAssertResult {
     this._currentTestDescriptions.pop();
   }
   registerTestFunction(fncIndex: number): void {
-    const testCaseFullName = this._currentTestDescriptions.join(" - ");
+    const testCaseFullName = this._currentTestDescriptions.join(" ");
     this.registerFunctions.push([testCaseFullName, fncIndex]);
   }
   collectCheckResult(result: boolean, codeInfoIndex: number, actualValue: string, expectValue: string): void {
     this.total++;
     if (!result) {
       this.fail++;
-      const testCaseFullName = this._currentTestDescriptions.join(" - ");
+      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);

src/core/precompile.ts

@@ -8,6 +8,7 @@ import { join, relative, resolve } from "node:path";
 import { getIncludeFiles } from "../utils/pathResolver.js";
 import { SourceFunctionInfo, UnittestPackage } from "../interface.js";
 import { projectRoot } from "../utils/projectRoot.js";
+import assert from "node:assert";
 
 export async function precompile(
   includes: string[],
@@ -40,6 +41,8 @@ export async function precompile(
         }
       }
     }
+
+    assert(matchedTestFiles.size > 0, `No matched testname using ${testNamePattern}`);
     return {
       testCodePaths: Array.from(matchedTestFiles),
       matchedTestNames: matchedTestNames,

src/index.ts

@@ -66,7 +66,12 @@ export async function start_unit_test(options: TestOption): Promise<boolean> {
   const instrumentResult = await instrument(wasmPaths, sourcePaths, options.collectCoverage);
   console.log(chalk.blueBright("instrument: ") + chalk.bold.greenBright("OK"));
 
-  const executedResult = await execWasmBinarys(options.tempFolder, instrumentResult, options.imports);
+  const executedResult = await execWasmBinarys(
+    options.tempFolder,
+    instrumentResult,
+    unittestPackage.matchedTestNames,
+    options.imports
+  );
   console.log(chalk.blueBright("execute testcases: ") + chalk.bold.greenBright("OK"));
 
   logAssertResult(executedResult);