@tscircuit/schematic-trace-solver 0.0.25 → 0.0.27

package/tests/examples/example07.test.ts

@@ -0,0 +1,12 @@
+import { test, expect } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { inputProblem } from "site/examples/example07.page"
+import "tests/fixtures/matcher"
+
+test("example07", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/examples/example08.test.ts

@@ -0,0 +1,12 @@
+import { test, expect } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { inputProblem } from "site/examples/example08.page"
+import "tests/fixtures/matcher"
+
+test("example08", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/examples/example09.test.ts

@@ -0,0 +1,12 @@
+import { test, expect } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { inputProblem } from "site/examples/example09.page"
+import "tests/fixtures/matcher"
+
+test("example09", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/examples/example10.test.ts

@@ -0,0 +1,12 @@
+import { test, expect } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { inputProblem } from "site/examples/example10.page"
+import "tests/fixtures/matcher"
+
+test("example10", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/examples/example11.test.tsx

@@ -0,0 +1,12 @@
+import { test, expect } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { inputProblem } from "site/examples/example11.page"
+import "tests/fixtures/matcher"
+
+test("example11", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/examples/example12.test.tsx

@@ -0,0 +1,12 @@
+import { test, expect } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { inputProblem } from "site/examples/example12.page"
+import "tests/fixtures/matcher"
+
+test("example12", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/examples/example13.test.tsx

@@ -0,0 +1,12 @@
+import { test, expect } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { inputProblem } from "site/examples/example13.page"
+import "tests/fixtures/matcher"
+
+test("example13", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/examples/example14.test.tsx

@@ -0,0 +1,12 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import { inputProblem } from "site/examples/example14.page"
+import "tests/fixtures/matcher"
+
+test.skip("example14 - should fail with net label placement collision error", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})

package/tests/fixtures/matcher.ts

@@ -0,0 +1,62 @@
+import { getSvgFromGraphicsObject, type GraphicsObject } from "graphics-debug"
+import { expect, type MatcherResult } from "bun:test"
+import type { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+
+const getAllElms = (graphicsObject: GraphicsObject) => {
+  return [
+    ...(graphicsObject.lines ?? []),
+    ...(graphicsObject.points ?? []),
+    ...(graphicsObject.rects ?? []),
+    ...(graphicsObject.circles ?? []),
+    ...(graphicsObject.texts ?? []),
+  ]
+}
+
+async function toMatchSolverSnapshot(
+  this: any,
+  received: BaseSolver,
+  testPathOriginal: string,
+  svgName?: string,
+): Promise<MatcherResult> {
+  const graphicsObject = received.visualize()
+
+  const allElms = getAllElms(graphicsObject)
+  const lastStep = allElms.reduce((acc, elm) => {
+    return Math.max(acc, elm.step ?? 0)
+  }, 0)
+
+  graphicsObject.points = graphicsObject.points?.filter(
+    (p) => p.step === lastStep,
+  )
+  graphicsObject.lines = graphicsObject.lines?.filter(
+    (l) => l.step === lastStep,
+  )
+  graphicsObject.rects = graphicsObject.rects?.filter(
+    (r) => r.step === lastStep,
+  )
+  graphicsObject.circles = graphicsObject.circles?.filter(
+    (c) => c.step === lastStep,
+  )
+  graphicsObject.texts = graphicsObject.texts?.filter(
+    (t) => t.step === lastStep,
+  )
+
+  const svg = getSvgFromGraphicsObject(graphicsObject, {
+    backgroundColor: "white",
+  })
+
+  return expect(svg).toMatchSvgSnapshot(testPathOriginal, svgName)
+}
+
+expect.extend({
+  toMatchSolverSnapshot: toMatchSolverSnapshot as any,
+})
+
+declare module "bun:test" {
+  interface Matchers<T = unknown> {
+    toMatchSolverSnapshot(
+      testPath: string,
+      svgName?: string,
+    ): Promise<MatcherResult>
+  }
+}

package/tests/fixtures/preload.ts

@@ -0,0 +1 @@
+import "bun-match-svg"

package/tests/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver01.test.ts

@@ -0,0 +1,13 @@
+import { expect, test } from "bun:test"
+import { SingleNetLabelPlacementSolver } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver"
+import { input } from "site/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver01.page"
+import "tests/fixtures/matcher"
+
+test("SingleNetLabelPlacementSolver01 issue reproduction (should pass)", () => {
+  const solver = new SingleNetLabelPlacementSolver(input as any)
+
+  solver.solve()
+
+  // TODO: Fix the test
+  // expect(solver.solved).toBe(true)
+})

package/tests/svg.test.ts

@@ -0,0 +1,11 @@
+import { expect, test } from "bun:test"
+
+const testSvg = `<svg width="100" height="100" xmlns="http://www.w3.org/2000/svg">                                       
+   <circle cx="50" cy="50" r="40" stroke="black" stroke-width="3" fill="red" />                                            
+ </svg>`
+
+test("svg snapshot example", async () => {
+  // First run will create the snapshot
+  // Subsequent runs will compare against the saved snapshot
+  await expect(testSvg).toMatchSvgSnapshot(import.meta.path)
+})