Remove unused code

Author: tmr232

src/test/commentTest.test.ts

@@ -1,9 +1,14 @@
-import { test } from "bun:test";
+import { test, expect } from "bun:test";
 import { testFunctions as testFuncsForGo } from "./collect-go";
 import { testFunctions as testFuncsForC } from "./collect-c";
 import { TestManager } from "./commentTestManager";
+
 const testManager = new TestManager({
   testFunctions: [...testFuncsForC, ...testFuncsForGo],
 });
 
-test.each(testManager.allTests)(testManager.nameFormat, testManager.invoke);
+test.each(testManager.allTests)(
+  testManager.nameFormat,
+  // @ts-expect-error: Mismatch between function types
+  testManager.invokeWith((failure: string) => expect().fail(failure)),
+);

src/test/commentTestHandlers.ts

@@ -53,7 +53,7 @@ function getMarkerMap(cfg: CFG): Map<string, string> {
   return markerMap;
 }
 
-type RequirementHandler = (testFunc: TestFunction) => null | string;
+export type RequirementHandler = (testFunc: TestFunction) => null | string;
 export const requirementTests: {
   [key: string]: RequirementHandler | undefined;
 } = {

src/test/commentTestManager.ts

@@ -1,29 +1,31 @@
-import { requirementTests } from "./commentTestHandlers";
+import {
+  requirementTests,
+  type RequirementHandler,
+} from "./commentTestHandlers";
 import type { TestFunction } from "./commentTestTypes";
-import { expect } from "bun:test";
 
 interface TestManagerOptions {
   testFunctions: TestFunction[];
 }
 export class TestManager {
   private readonly testFunctions: TestFunction[];
-  private readonly testMap: Map<string, TestFunction>;
   public readonly nameFormat = "%s";
-  // @ts-expect-error: Implicit any type
-  public readonly invoke = (_name, testFunc, reqHandler) => {
-    const failure: null | string = reqHandler(testFunc);
-    if (failure) {
-      expect().fail(failure);
-    } else {
-      expect().pass();
-    }
-  };
 
   constructor(options: TestManagerOptions) {
     this.testFunctions = options.testFunctions;
-    this.testMap = new Map(
-      this.testFunctions.map((testFunc) => [testFunc.name, testFunc]),
-    );
+  }
+
+  public invokeWith(failureCallback: (failure: string) => void) {
+    return (
+      _name: string,
+      testFunc: TestFunction,
+      reqHandler: RequirementHandler,
+    ) => {
+      const failure: null | string = reqHandler(testFunc);
+      if (failure) {
+        failureCallback(failure);
+      }
+    };
   }
 
   public get allTests() {