refactor(tests): reorganize and improve test coverage

- Restructure integration tests with describe blocks for better organization
- Remove redundant simple tests that duplicated other test files
- Add new tests for: unary operators, exponentiation, bitwise operations,
  array/object literals, operator precedence, edge cases
- Streamline compile.test.ts and evaluate.test.ts to focus on unit testing
- Add practical scenario tests (price calculation, coordinate transform)
- Improve optimization tests with partial inlining and special value handling

Author: codehz

src/compile.test.ts

@@ -1,103 +1,136 @@
-import { expect, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 import { z } from "zod";
-import { compile } from "./compile";
-import { expr } from "./expr";
-import { variable } from "./variable";
+import { compile, expr, variable } from "./index";
 
-test("compile: simple variable expression", () => {
-  const x = variable(z.number());
-  const y = variable(z.number());
+describe("compile 单元测试", () => {
+  describe("编译输出格式", () => {
+    test("基本结构: [变量名数组, ...表达式]", () => {
+      const x = variable(z.number());
+      const y = variable(z.number());
+
+      const sum = expr({ x, y })("x + y");
+      const result = compile(sum, { x, y });
 
-  const sum = expr({ x, y })("x + y");
-  const result = compile(sum, { x, y });
+      expect(result).toHaveLength(2);
+      expect(result[0]).toEqual(["x", "y"]);
+      expect(typeof result[1]).toBe("string");
+    });
+
+    test("变量占位符替换", () => {
+      const x = variable(z.number());
+      const y = variable(z.number());
+
+      const sum = expr({ x, y })("x + y");
+      const result = compile(sum, { x, y });
 
-  // 预期结果：[["x", "y"], "$0+$1"]（通过 AST 规范化输出，无空格）
-  expect(result).toHaveLength(2);
-  expect(result[0]).toEqual(["x", "y"]);
-  expect(result[1]).toBe("$0+$1");
-});
-
-test("compile: nested expressions with inline optimization", () => {
-  const x = variable(z.number());
-  const y = variable(z.number());
-
-  const sum = expr({ x, y })("x + y");
-  const product = expr({ x, y })("x * y");
-  const result = expr({ sum, product })("sum + product");
-
-  // 默认开启内联优化
-  const compiled = compile(result, { x, y });
-
-  // 内联优化后，只剩一个表达式
-  expect(compiled).toHaveLength(2);
-  expect(compiled[0]).toEqual(["x", "y"]);
-  expect(compiled[1]).toBe("$0+$1+$0*$1");
-});
-
-test("compile: nested expressions without inline", () => {
-  const x = variable(z.number());
-  const y = variable(z.number());
-
-  const sum = expr({ x, y })("x + y");
-  const product = expr({ x, y })("x * y");
-  const result = expr({ sum, product })("sum + product");
-
-  // 禁用内联优化
-  const compiled = compile(result, { x, y }, { inline: false });
-
-  // 预期：[["x", "y"], "$0+$1", "$0*$1", "$2+$3"]（规范化输出）
-  expect(compiled).toHaveLength(4);
-  expect(compiled[0]).toEqual(["x", "y"]);
-  expect(compiled[1]).toBe("$0+$1");
-  expect(compiled[2]).toBe("$0*$1");
-  expect(compiled[3]).toBe("$2+$3");
-});
-
-test("compile: expression with single variable", () => {
-  const x = variable(z.number());
-
-  const double = expr({ x })("x * 2");
-  const result = compile(double, { x });
-
-  expect(result).toHaveLength(2);
-  expect(result[0]).toEqual(["x"]);
-  expect(result[1]).toBe("$0*2");
-});
-
-test("compile: complex placeholder replacement", () => {
-  const x = variable(z.number());
-  const xy = variable(z.number());
-
-  // xy 是较长的名称，通过 AST 解析可以正确区分
-  const expr1 = expr({ xy, x })("xy + x");
-  const result = compile(expr1, { xy, x });
-
-  expect(result).toHaveLength(2);
-  expect(result[0]).toEqual(["xy", "x"]);
-  // xy 应该被替换为 $0，x 应该被替换为 $1
-  expect(result[1]).toBe("$0+$1");
-});
-
-test("compile: detects undefined variable reference", () => {
-  const x = variable(z.number());
-  const y = variable(z.number());
-
-  const sum = expr({ x, y })("x + y + z");
-
-  expect(() => {
-    compile(sum, { x, y });
-  }).toThrow();
-});
-
-test("compile: variable order matches declaration", () => {
-  const a = variable(z.number());
-  const b = variable(z.number());
-  const c = variable(z.number());
-
-  const expr1 = expr({ a, b, c })("a + b + c");
-  const result = compile(expr1, { a, b, c });
+      // 变量被替换为 $0, $1 等
+      expect(result[1]).toBe("$0+$1");
+    });
 
-  expect(result[0]).toEqual(["a", "b", "c"]);
-  // 规范化输出: a+b+c -> $0+$1+$2
-  expect(result[1]).toBe("$0+$1+$2");
+    test("变量顺序与声明顺序一致", () => {
+      const a = variable(z.number());
+      const b = variable(z.number());
+      const c = variable(z.number());
+
+      const expr1 = expr({ a, b, c })("c + b + a");
+      const result = compile(expr1, { a, b, c });
+
+      expect(result[0]).toEqual(["a", "b", "c"]);
+    });
+
+    test("相似变量名正确区分", () => {
+      const x = variable(z.number());
+      const xy = variable(z.number());
+
+      // xy 不应该被 x 的替换影响
+      const e = expr({ xy, x })("xy + x");
+      const result = compile(e, { xy, x });
+
+      expect(result[0]).toEqual(["xy", "x"]);
+      expect(result[1]).toBe("$0+$1");
+    });
+  });
+
+  describe("错误检测", () => {
+    test("检测未定义的变量引用", () => {
+      const x = variable(z.number());
+      const y = variable(z.number());
+
+      const sum = expr({ x, y })("x + y + z");
+
+      expect(() => {
+        compile(sum, { x, y });
+      }).toThrow();
+    });
+
+    test("检测表达式中引用不存在的上下文变量", () => {
+      const x = variable(z.number());
+
+      const e1 = expr({ x })("x + 1");
+      const e2 = expr({ e1 })("e1 + e2"); // e2 不存在
+
+      expect(() => {
+        compile(e2, { x });
+      }).toThrow();
+    });
+  });
+
+  describe("内联优化输出", () => {
+    test("内联模式减少表达式数量", () => {
+      const x = variable(z.number());
+      const y = variable(z.number());
+
+      const sum = expr({ x, y })("x + y");
+      const product = expr({ x, y })("x * y");
+      const result = expr({ sum, product })("sum + product");
+
+      const inlined = compile(result, { x, y }); // 默认内联
+      const notInlined = compile(result, { x, y }, { inline: false });
+
+      expect(inlined.length).toBe(2);
+      expect(notInlined.length).toBe(4);
+    });
+
+    test("非内联模式保留所有中间表达式", () => {
+      const x = variable(z.number());
+      const y = variable(z.number());
+
+      const sum = expr({ x, y })("x + y");
+      const product = expr({ x, y })("x * y");
+      const result = expr({ sum, product })("sum + product");
+
+      const compiled = compile(result, { x, y }, { inline: false });
+
+      expect(compiled).toHaveLength(4);
+      expect(compiled[0]).toEqual(["x", "y"]);
+      expect(compiled[1]).toBe("$0+$1"); // sum
+      expect(compiled[2]).toBe("$0*$1"); // product
+      expect(compiled[3]).toBe("$2+$3"); // result
+    });
+  });
+
+  describe("AST 规范化", () => {
+    test("输出不包含多余空格", () => {
+      const x = variable(z.number());
+      const y = variable(z.number());
+
+      // 原始表达式有空格
+      const e = expr({ x, y })("x + y * 2");
+      const result = compile(e, { x, y });
+
+      // 输出应该是规范化的
+      expect(result[1]).toBe("$0+$1*2");
+    });
+
+    test("保留必要的括号", () => {
+      const x = variable(z.number());
+      const y = variable(z.number());
+
+      const e = expr({ x, y })("(x + y) * 2");
+      const result = compile(e, { x, y });
+
+      // 括号应该被保留以保持正确的运算顺序
+      expect(result[1]).toBe("($0+$1)*2");
+    });
+  });
 });