미지수 괄호 문제 풀이 추가

lib/engine/variable-parenthesis.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  formatVariableExpressionLatex,
+  generateVariableParenthesisProblem,
+  generateVariableParenthesisSession,
+  gradeVariableParenthesisAnswer,
+} from "./variable-parenthesis";
+import type { VariableParenthesisProblem } from "./variable-types";
+
+function findCorrectChoiceIds(problem: VariableParenthesisProblem) {
+  return problem.correctTerms.map((term, index) => {
+    const choices = problem.choices[index as 0 | 1];
+    const choice = choices.find(
+      (item) =>
+        item.coefficient === term.coefficient && item.variable === term.variable,
+    );
+
+    if (!choice) throw new Error("correct choice not found.");
+
+    return choice.id;
+  }) as [string, string];
+}
+
+describe("variable parenthesis engine", () => {
+  it("generates a problem with exactly one variable term inside parentheses", () => {
+    const problem = generateVariableParenthesisProblem();
+    const terms = [problem.firstTerm, problem.secondTerm];
+
+    expect(terms.filter((term) => term.kind === "variable")).toHaveLength(1);
+    expect(terms.filter((term) => term.kind === "constant")).toHaveLength(1);
+    expect(problem.multiplier).toBeLessThan(0);
+    expect(Number.isInteger(problem.multiplier)).toBe(true);
+    expect(problem.firstTerm.coefficient).toBeGreaterThanOrEqual(1);
+    expect(problem.secondTerm.coefficient).toBeGreaterThanOrEqual(1);
+  });
+
+  it("distributes signs correctly for addition and subtraction", () => {
+    const problems = generateVariableParenthesisSession(50);
+
+    for (const problem of problems) {
+      const secondSign = problem.operator === "-" ? -1 : 1;
+
+      expect(problem.correctTerms[0].coefficient).toBe(
+        problem.multiplier * problem.firstTerm.coefficient,
+      );
+      expect(problem.correctTerms[1].coefficient).toBe(
+        problem.multiplier * secondSign * problem.secondTerm.coefficient,
+      );
+    }
+  });
+
+  it("creates positive and negative choices for each term", () => {
+    const problem = generateVariableParenthesisProblem();
+
+    problem.choices.forEach((choices, index) => {
+      const correctTerm = problem.correctTerms[index as 0 | 1];
+      const coefficients = choices.map((choice) => choice.coefficient).sort();
+
+      expect(choices).toHaveLength(2);
+      expect(coefficients).toEqual([
+        -Math.abs(correctTerm.coefficient),
+        Math.abs(correctTerm.coefficient),
+      ]);
+      expect(choices.every((choice) => choice.variable === correctTerm.variable))
+        .toBe(true);
+    });
+  });
+
+  it("grades selected choice ids", () => {
+    const problem = generateVariableParenthesisProblem();
+    const correctChoiceIds = findCorrectChoiceIds(problem);
+    const result = gradeVariableParenthesisAnswer(problem, {
+      selectedChoiceIds: correctChoiceIds,
+    });
+
+    expect(result.correct).toBe(true);
+    expect(result.correctAnswer).toEqual(problem.correctTerms);
+
+    const wrongFirstChoice = problem.choices[0].find(
+      (choice) => choice.id !== correctChoiceIds[0],
+    );
+
+    expect(wrongFirstChoice).toBeDefined();
+    expect(
+      gradeVariableParenthesisAnswer(problem, {
+        selectedChoiceIds: [wrongFirstChoice!.id, correctChoiceIds[1]],
+      }).correct,
+    ).toBe(false);
+  });
+
+  it("generates sessions without duplicate keys", () => {
+    const problems = generateVariableParenthesisSession(10);
+    const keys = new Set(problems.map((problem) => problem.key));
+
+    expect(problems).toHaveLength(10);
+    expect(keys.size).toBe(10);
+  });
+
+  it("formats expressions with variable terms", () => {
+    expect(
+      formatVariableExpressionLatex([
+        { kind: "variable", coefficient: -6, variable: "x", latex: "-6x" },
+        { kind: "constant", coefficient: 12, latex: "12" },
+      ]),
+    ).toBe("-6x + 12");
+  });
+});