-

Author: Bashamega

src/test.ts

@@ -14,68 +14,85 @@ function normalizeLineEndings(text: string): string {
   return text.replace(/\r\n?/g, "\n");
 }
 
-function getFiles(folder: URL) {
+function compareToBaselines(baselineFolder: URL, outputFolder: URL) {
+  let baselineFiles: string[] = [];
   try {
-    return fs.readdirSync(folder);
+    baselineFiles = fs.readdirSync(baselineFolder);
   } catch {
-    return [];
+    // do nothing
   }
-}
 
-function readFileContent(filePath: URL) {
-  return normalizeLineEndings(fs.readFileSync(filePath, "utf-8"));
-}
+  let outputFiles: string[] = [];
+  try {
+    outputFiles = fs.readdirSync(outputFolder);
+  } catch {
+    // do nothing
+  }
 
-function compareToBaselines(baselineFolder: URL, outputFolder: URL) {
-  const files = new Set([
-    ...getFiles(baselineFolder),
-    ...getFiles(outputFolder),
-  ]);
+  for (const file of new Set([...baselineFiles, ...outputFiles])) {
+    if (file.startsWith(".")) {
+      continue;
+    }
 
-  for (const file of files) {
-    if (file.startsWith(".")) continue;
+    let baselineStats: fs.Stats | undefined;
+    try {
+      baselineStats = fs.statSync(new URL(file, baselineFolder));
+    } catch {
+      // do nothing
+    }
 
-    const baselinePath = new URL(file, baselineFolder);
-    const outputPath = new URL(file, outputFolder);
+    let outputStats: fs.Stats | undefined;
+    try {
+      outputStats = fs.statSync(new URL(file, outputFolder));
+    } catch {
+      // do nothing
+    }
 
-    const isBaselineFile =
-      fs.existsSync(baselinePath) && fs.statSync(baselinePath).isFile();
-    const isOutputFile =
-      fs.existsSync(outputPath) && fs.statSync(outputPath).isFile();
+    const baseline = baselineStats?.isFile()
+      ? normalizeLineEndings(
+          fs.readFileSync(new URL(file, baselineFolder)).toString(),
+        )
+      : null;
 
-    const baseline = isBaselineFile ? readFileContent(baselinePath) : null;
-    const generated = isOutputFile ? readFileContent(outputPath) : null;
+    const generated = outputStats?.isFile()
+      ? normalizeLineEndings(
+          fs.readFileSync(new URL(file, outputFolder)).toString(),
+        )
+      : null;
 
     if (baseline !== null || generated !== null) {
       if (baseline !== generated) {
-        console.error(`Test failed: '${file}' is different from baseline.`);
+        console.error(
+          `Test failed: '${file}' is different from baseline file.`,
+        );
         printUnifiedDiff(baseline ?? "", generated ?? "");
         return false;
       }
+
       continue;
     }
 
-    if (fs.existsSync(baselinePath)) {
-      if (
-        !compareToBaselines(
-          new URL(`${file}/`, baselineFolder),
-          new URL(`${file}/`, outputFolder),
-        )
-      ) {
+    if (baselineStats?.isDirectory() || outputStats?.isDirectory()) {
+      const childBaselineFolder = new URL(`${file}/`, baselineFolder);
+      const childOutputFolder = new URL(`${file}/`, outputFolder);
+      if (!compareToBaselines(childBaselineFolder, childOutputFolder)) {
         return false;
       }
+
+      continue;
     }
   }
   return true;
 }
 
 function compileGeneratedFiles(lib: string, ...files: string[]) {
   try {
-    const fileArgs = files
-      .map((file) => fileURLToPath(new URL(file, outputFolder)))
-      .join(" ");
     child_process.execSync(
-      `node ${fileURLToPath(tscPath)} --strict --lib ${lib} --types --noEmit ${fileArgs}`,
+      `node ${fileURLToPath(
+        tscPath,
+      )} --strict --lib ${lib} --types --noEmit ${files
+        .map((file) => fileURLToPath(new URL(file, outputFolder)))
+        .join(" ")}`,
     );
   } catch (e: any) {
     console.error(`Test failed: could not compile '${files.join(",")}':`);
@@ -87,64 +104,36 @@ function compileGeneratedFiles(lib: string, ...files: string[]) {
 }
 
 function test() {
-  const compileSets = [
-    ["es5", ["dom.generated.d.ts"]],
-    ["es6", ["dom.generated.d.ts", "dom.iterable.generated.d.ts"]],
-    ["es2018", ["dom.generated.d.ts", "dom.asynciterable.generated.d.ts"]],
-    ["es5", ["webworker.generated.d.ts"]],
-    ["es6", ["webworker.generated.d.ts", "webworker.iterable.generated.d.ts"]],
-    [
-      "es2018",
-      ["webworker.generated.d.ts", "webworker.asynciterable.generated.d.ts"],
-    ],
-    ["es5", ["sharedworker.generated.d.ts"]],
-    [
-      "es6",
-      ["sharedworker.generated.d.ts", "sharedworker.iterable.generated.d.ts"],
-    ],
-    [
-      "es2018",
-      [
-        "sharedworker.generated.d.ts",
-        "sharedworker.asynciterable.generated.d.ts",
-      ],
-    ],
-    ["es5", ["serviceworker.generated.d.ts"]],
-    [
-      "es6",
-      ["serviceworker.generated.d.ts", "serviceworker.iterable.generated.d.ts"],
-    ],
-    [
-      "es2018",
-      [
-        "serviceworker.generated.d.ts",
-        "serviceworker.asynciterable.generated.d.ts",
-      ],
-    ],
-    ["es5", ["audioworklet.generated.d.ts"]],
-    [
-      "es6",
-      ["audioworklet.generated.d.ts", "audioworklet.iterable.generated.d.ts"],
-    ],
-    [
-      "es2018",
-      [
-        "audioworklet.generated.d.ts",
-        "audioworklet.asynciterable.generated.d.ts",
-      ],
-    ],
+  const targets = ["es5", "es6", "es2018"];
+  const modules = [
+    "dom",
+    "webworker",
+    "sharedworker",
+    "serviceworker",
+    "audioworklet",
   ];
+  const suffixes: Record<string, string[]> = {
+    es5: ["generated.d.ts"],
+    es6: ["generated.d.ts", "iterable.generated.d.ts"],
+    es2018: ["generated.d.ts", "asynciterable.generated.d.ts"],
+  };
 
-  if (
+  const allPassed =
     compareToBaselines(baselineFolder, outputFolder) &&
-    compileSets.every(([lib, files]) =>
-      compileGeneratedFiles(lib as string, ...files),
-    )
-  ) {
+    modules.every((mod) =>
+      targets.every((target) =>
+        compileGeneratedFiles(
+          target,
+          ...suffixes[target].map((s) => `${mod}.${s}`),
+        ),
+      ),
+    );
+
+  if (allPassed) {
     console.log("All tests passed.");
     process.exit(0);
   }
+
   process.exit(1);
 }
-
 test();