typia 13.0.1-dev.20260703.1 → 13.0.1

package/native/cmd/ttsc-typia/plain_classify_deep_nested_transform_test.go

@@ -1,184 +1,184 @@
-package main
-
-import (
-  "os"
-  "os/exec"
-  "path/filepath"
-  "strings"
-  "testing"
-)
-
-// TestPlainClassifyDeepNestedTransform stresses reconstruction through a deeply
-// nested, recursive class graph — for BOTH the from/new construction form
-// (new Forest(seed) where the seed is many levels deep) and the field-copy form
-// (classify<Branch> on a recursive instance type). Every level must come back as
-// a real instance with working prototype methods: nested classes, arrays of
-// classes, optional class members, a recursive class array, and a class nested
-// inside a seed all the way down.
-func TestPlainClassifyDeepNestedTransform(t *testing.T) {
-  project := plainClassifyDeepNestedProject(t)
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{
-      "--cwd", project,
-      "--tsconfig", "tsconfig.json",
-      "--file", "src/main.ts",
-      "--output", "js",
-    })
-  })
-  if code != 0 {
-    t.Fatalf("classify deep-nested transform failed: code=%d stderr=\n%s", code, errText)
-  }
-  if !strings.Contains(out, "new Forest(") {
-    t.Fatalf("the from/new form should emit new Forest(seed):\n%s", out)
-  }
-  if !strings.Contains(out, "Object.create") {
-    t.Fatalf("the field-copy form should emit Object.create:\n%s", out)
-  }
-  plainClassifyDeepNestedRun(t, project, out)
-}
-
-func plainClassifyDeepNestedProject(t *testing.T) string {
-  t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "plain-classify-deep-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
-  src := filepath.Join(dir, "src")
-  if err := os.MkdirAll(src, 0o755); err != nil {
-    t.Fatalf("mkdir fixture src: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(plainClassifyFromNewTSConfig), 0o644); err != nil {
-    t.Fatalf("write tsconfig: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(plainClassifyDeepNestedSource), 0o644); err != nil {
-    t.Fatalf("write source: %v", err)
-  }
-  return dir
-}
-
-func plainClassifyDeepNestedRun(t *testing.T, project string, js string) {
-  t.Helper()
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-  }
-  runtimeDir := filepath.Join(project, "runtime")
-  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
-    t.Fatalf("mkdir runtime dir: %v", err)
-  }
-  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
-  if err := os.WriteFile(filepath.Join(runtimeDir, "generic-internal-stub.cjs"), []byte(plainClassifyFromNewGenericStub), 0o644); err != nil {
-    t.Fatalf("write generic stub: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(plainClassifyFromNewRewrite(t, js)), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(plainClassifyDeepNestedRunner), 0o644); err != nil {
-    t.Fatalf("write runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  output, err := cmd.CombinedOutput()
-  if err != nil {
-    t.Fatalf("classify deep-nested runtime cases failed: %v\n%s", err, output)
-  }
-}
-
-const plainClassifyDeepNestedSource = `import typia from "typia";
-
-export class Leaf {
-  tag!: string;
-  weight!: number;
-  describe(): string {
-    return this.tag + ":" + this.weight;
-  }
-}
-
-export class Branch {
-  name!: string;
-  leaves!: Leaf[]; // array of classes
-  children!: Branch[]; // recursive class array
-  best?: Leaf; // optional class member
-  total(): number {
-    return this.leaves.reduce((s, l) => s + l.weight, 0);
-  }
-}
-
-// from/new: built via a single-arg constructor whose seed is a deep class graph.
-export class Forest {
-  root!: Branch;
-  registry!: Branch[];
-  constructor(seed: { root: Branch; registry: Branch[] }) {
-    this.root = seed.root;
-    this.registry = seed.registry;
-  }
-  size(): number {
-    return this.registry.length;
-  }
-}
-
-export const buildForest = typia.plain.createClassify<typeof Forest>();
-export const classifyBranch = typia.plain.createClassify<Branch>();
-`
-
-const plainClassifyDeepNestedRunner = `const mod = require("./main.cjs");
-
-const assert = (cond, msg) => {
-  if (!cond) throw new Error(msg);
-};
-
-const data = {
-  root: {
-    name: "r",
-    leaves: [
-      { tag: "a", weight: 1 },
-      { tag: "b", weight: 2 },
-    ],
-    children: [
-      {
-        name: "c1",
-        leaves: [{ tag: "x", weight: 9 }],
-        children: [
-          { name: "g1", leaves: [{ tag: "deep", weight: 4 }], children: [] },
-        ],
-        best: { tag: "z", weight: 5 },
-      },
-    ],
-  },
-  registry: [{ name: "reg", leaves: [], children: [] }],
-};
-
-// (1) from/new deep seed: new Forest(seed) with the whole graph reconstructed
-const forest = mod.buildForest(data);
-assert(forest instanceof mod.Forest, "forest should be a Forest instance");
-assert(forest.size() === 1, "Forest method should work");
-assert(forest.root instanceof mod.Branch, "root should be a Branch");
-assert(forest.root.total() === 3, "Branch.total method should work, got: " + forest.root.total());
-assert(forest.root.leaves[0] instanceof mod.Leaf, "root.leaves[0] should be a Leaf");
-assert(forest.root.leaves[0].describe() === "a:1", "Leaf method should work");
-assert(forest.root.children[0] instanceof mod.Branch, "child should be a Branch");
-assert(forest.root.children[0].leaves[0] instanceof mod.Leaf, "child leaf should be a Leaf");
-assert(forest.root.children[0].best instanceof mod.Leaf, "optional best should be a Leaf");
-assert(forest.root.children[0].best.describe() === "z:5", "optional Leaf method should work");
-assert(forest.root.children[0].children[0] instanceof mod.Branch, "grandchild should be a Branch (3 levels deep)");
-assert(forest.root.children[0].children[0].leaves[0].describe() === "deep:4", "deepest leaf should reconstruct");
-assert(forest.registry[0] instanceof mod.Branch, "registry entry should be a Branch");
-
-// (2) field-copy deep recursive instance form: classify<Branch>
-const branch = mod.classifyBranch({
-  name: "fc",
-  leaves: [{ tag: "p", weight: 7 }],
-  children: [{ name: "fc-child", leaves: [{ tag: "q", weight: 8 }], children: [] }],
-});
-assert(branch instanceof mod.Branch, "field-copy branch should be a Branch");
-assert(branch.leaves[0] instanceof mod.Leaf, "field-copy nested Leaf");
-assert(branch.children[0] instanceof mod.Branch, "field-copy recursive Branch");
-assert(branch.children[0].leaves[0].describe() === "q:8", "field-copy deepest leaf method");
-`
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestPlainClassifyDeepNestedTransform stresses reconstruction through a deeply
+// nested, recursive class graph — for BOTH the from/new construction form
+// (new Forest(seed) where the seed is many levels deep) and the field-copy form
+// (classify<Branch> on a recursive instance type). Every level must come back as
+// a real instance with working prototype methods: nested classes, arrays of
+// classes, optional class members, a recursive class array, and a class nested
+// inside a seed all the way down.
+func TestPlainClassifyDeepNestedTransform(t *testing.T) {
+  project := plainClassifyDeepNestedProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("classify deep-nested transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  if !strings.Contains(out, "new Forest(") {
+    t.Fatalf("the from/new form should emit new Forest(seed):\n%s", out)
+  }
+  if !strings.Contains(out, "Object.create") {
+    t.Fatalf("the field-copy form should emit Object.create:\n%s", out)
+  }
+  plainClassifyDeepNestedRun(t, project, out)
+}
+
+func plainClassifyDeepNestedProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "plain-classify-deep-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(plainClassifyFromNewTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(plainClassifyDeepNestedSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func plainClassifyDeepNestedRun(t *testing.T, project string, js string) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  if err := os.WriteFile(filepath.Join(runtimeDir, "generic-internal-stub.cjs"), []byte(plainClassifyFromNewGenericStub), 0o644); err != nil {
+    t.Fatalf("write generic stub: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(plainClassifyFromNewRewrite(t, js)), 0o644); err != nil {
+    t.Fatalf("write runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(plainClassifyDeepNestedRunner), 0o644); err != nil {
+    t.Fatalf("write runner: %v", err)
+  }
+  cmd := exec.Command(node, runner)
+  cmd.Dir = runtimeDir
+  output, err := cmd.CombinedOutput()
+  if err != nil {
+    t.Fatalf("classify deep-nested runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const plainClassifyDeepNestedSource = `import typia from "typia";
+
+export class Leaf {
+  tag!: string;
+  weight!: number;
+  describe(): string {
+    return this.tag + ":" + this.weight;
+  }
+}
+
+export class Branch {
+  name!: string;
+  leaves!: Leaf[]; // array of classes
+  children!: Branch[]; // recursive class array
+  best?: Leaf; // optional class member
+  total(): number {
+    return this.leaves.reduce((s, l) => s + l.weight, 0);
+  }
+}
+
+// from/new: built via a single-arg constructor whose seed is a deep class graph.
+export class Forest {
+  root!: Branch;
+  registry!: Branch[];
+  constructor(seed: { root: Branch; registry: Branch[] }) {
+    this.root = seed.root;
+    this.registry = seed.registry;
+  }
+  size(): number {
+    return this.registry.length;
+  }
+}
+
+export const buildForest = typia.plain.createClassify<typeof Forest>();
+export const classifyBranch = typia.plain.createClassify<Branch>();
+`
+
+const plainClassifyDeepNestedRunner = `const mod = require("./main.cjs");
+
+const assert = (cond, msg) => {
+  if (!cond) throw new Error(msg);
+};
+
+const data = {
+  root: {
+    name: "r",
+    leaves: [
+      { tag: "a", weight: 1 },
+      { tag: "b", weight: 2 },
+    ],
+    children: [
+      {
+        name: "c1",
+        leaves: [{ tag: "x", weight: 9 }],
+        children: [
+          { name: "g1", leaves: [{ tag: "deep", weight: 4 }], children: [] },
+        ],
+        best: { tag: "z", weight: 5 },
+      },
+    ],
+  },
+  registry: [{ name: "reg", leaves: [], children: [] }],
+};
+
+// (1) from/new deep seed: new Forest(seed) with the whole graph reconstructed
+const forest = mod.buildForest(data);
+assert(forest instanceof mod.Forest, "forest should be a Forest instance");
+assert(forest.size() === 1, "Forest method should work");
+assert(forest.root instanceof mod.Branch, "root should be a Branch");
+assert(forest.root.total() === 3, "Branch.total method should work, got: " + forest.root.total());
+assert(forest.root.leaves[0] instanceof mod.Leaf, "root.leaves[0] should be a Leaf");
+assert(forest.root.leaves[0].describe() === "a:1", "Leaf method should work");
+assert(forest.root.children[0] instanceof mod.Branch, "child should be a Branch");
+assert(forest.root.children[0].leaves[0] instanceof mod.Leaf, "child leaf should be a Leaf");
+assert(forest.root.children[0].best instanceof mod.Leaf, "optional best should be a Leaf");
+assert(forest.root.children[0].best.describe() === "z:5", "optional Leaf method should work");
+assert(forest.root.children[0].children[0] instanceof mod.Branch, "grandchild should be a Branch (3 levels deep)");
+assert(forest.root.children[0].children[0].leaves[0].describe() === "deep:4", "deepest leaf should reconstruct");
+assert(forest.registry[0] instanceof mod.Branch, "registry entry should be a Branch");
+
+// (2) field-copy deep recursive instance form: classify<Branch>
+const branch = mod.classifyBranch({
+  name: "fc",
+  leaves: [{ tag: "p", weight: 7 }],
+  children: [{ name: "fc-child", leaves: [{ tag: "q", weight: 8 }], children: [] }],
+});
+assert(branch instanceof mod.Branch, "field-copy branch should be a Branch");
+assert(branch.leaves[0] instanceof mod.Leaf, "field-copy nested Leaf");
+assert(branch.children[0] instanceof mod.Branch, "field-copy recursive Branch");
+assert(branch.children[0].leaves[0].describe() === "q:8", "field-copy deepest leaf method");
+`