test(typia-generate): assert regeneration is byte-identical

Extends the generate harness to re-run `typia generate` into a second
output directory and fail if any file differs from the first run,
pinning the non-deterministic emit order (unsorted Go map iteration)
fixed in the native Random/Protobuf/Metadata programmers on this branch.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

Author: samchon

tests/test-typia-generate/.gitignore

@@ -1 +1 @@
-src/output
+src/output*

tests/test-typia-generate/index.js

@@ -1,43 +1,66 @@
 /**
- * Verifies that `typia generate` actually transforms each input file.
+ * Verifies that `typia generate` transforms its input deterministically.
  *
- * Pins the regression where `typia generate` discarded the transform
- * result and copied the original input verbatim into the output. Every
- * `src/input/generate_*.ts` fixture contains `typia.*<T>()` call sites,
- * so a correctly transformed output can never be byte-identical to its
- * input file.
+ * Pins two regressions: (1) `typia generate` discarding the transform
+ * result and copying the input file verbatim into the output, and (2)
+ * non-deterministic emit order caused by unsorted Go map iteration in the
+ * native programmers. Every `src/input/generate_*.ts` fixture contains
+ * `typia.*<T>()` call sites, so a correct output is never byte-identical
+ * to its input and never changes between two generator runs.
  *
  * 1. Run `pnpm run generate` then `pnpm run build` (the `start` script).
- * 2. For each input file, read the matching generated output file.
- * 3. Fail if any output is missing or identical to its input file.
+ * 2. Assert each output differs from its input file (it was transformed).
+ * 3. Re-run the generator and assert every output is byte-identical.
  */
+const cp = require("child_process");
 const fs = require("fs");
 
 const inputDir = `${__dirname}/src/input`;
 const outputDir = `${__dirname}/src/output`;
+const repeatDir = `${__dirname}/src/output-repeat`;
 
 const main = () => {
   const files = fs
     .readdirSync(inputDir)
     .filter((file) => file.endsWith(".ts"));
   let failed = false;
+
+  // (1) every output must be transformed, not a verbatim copy of its input
   for (const file of files) {
-    const input = fs.readFileSync(`${inputDir}/${file}`, "utf8");
     const outputPath = `${outputDir}/${file}`;
     if (fs.existsSync(outputPath) === false) {
       console.error(`Bug on ${file}: output file was not generated.`);
       failed = true;
       continue;
     }
-    const output = fs.readFileSync(outputPath, "utf8");
-    if (input === output) {
+    const input = fs.readFileSync(`${inputDir}/${file}`, "utf8");
+    if (fs.readFileSync(outputPath, "utf8") === input) {
       console.error(
         `Bug on ${file}: output is identical to input (not transformed).`,
       );
       failed = true;
     }
   }
+
+  // (2) re-running the generator must produce byte-identical output
+  fs.rmSync(repeatDir, { recursive: true, force: true });
+  cp.execSync("pnpm run generate:repeat", {
+    cwd: __dirname,
+    stdio: "ignore",
+  });
+  for (const file of files) {
+    const first = fs.readFileSync(`${outputDir}/${file}`, "utf8");
+    const second = fs.readFileSync(`${repeatDir}/${file}`, "utf8");
+    if (first !== second) {
+      console.error(`Bug on ${file}: regeneration is not deterministic.`);
+      failed = true;
+    }
+  }
+  fs.rmSync(repeatDir, { recursive: true, force: true });
+
   if (failed) process.exit(1);
-  console.log(`All ${files.length} generate outputs were transformed.`);
+  console.log(
+    `All ${files.length} generate outputs are transformed and deterministic.`,
+  );
 };
 main();

tests/test-typia-generate/package.json

@@ -6,6 +6,7 @@
   "scripts": {
     "build": "ttsc",
     "generate": "ttsx node_modules/typia/src/executable/typia.ts generate --input src/input --output src/output",
+    "generate:repeat": "ttsx node_modules/typia/src/executable/typia.ts generate --input src/input --output src/output-repeat",
     "start": "pnpm run generate && pnpm run build && node index.js"
   },
   "repository": {