Updates more tests.

.github/workflows/main.yaml

@@ -8,10 +8,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v4
+      - uses: denoland/setup-deno@v2
         with:
-          package_json_file: package.json
-      - run: pnpm install
-      - run: pnpm --recursive run tsc
-      - run: pnpm --recursive run test
-      - run: pnpm --recursive run build
+          deno-version: v2.x
+      - run: deno test

.vscode/settings.json

@@ -1,6 +1,8 @@
 {
   "cSpell.words": [
     "aryann",
+    "deno",
+    "denoland",
     "immer",
     "Kiwipete",
     "perft",

engine/engine.test.ts

@@ -1,121 +1,116 @@
-import { assert, describe, it } from "vitest";
+import { expect } from "jsr:@std/expect";
 import { Engine } from "./engine.ts";
 
-describe("fen", () => {
+Deno.test("fen", async (t) => {
   const engine = new Engine();
 
-  it("initial state", () => {
-    assert.equal(
-      engine.fen(),
+  await t.step("initial state", () => {
+    expect(engine.fen()).toEqual(
       "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
     );
   });
 
-  it("first move", () => {
+  await t.step("first move", () => {
     engine.move({ type: "normal", from: "e2", to: "e3" });
 
-    assert.equal(
-      engine.fen(),
+    expect(engine.fen()).toEqual(
       "rnbqkbnr/pppppppp/8/8/8/4P3/PPPP1PPP/RNBQKBNR b KQkq - 0 1"
     );
   });
 
-  it("second move", () => {
+  await t.step("second move", () => {
     engine.move({ type: "normal", from: "e7", to: "e6" });
 
-    assert.equal(
-      engine.fen(),
+    expect(engine.fen()).toEqual(
       "rnbqkbnr/pppp1ppp/4p3/8/8/4P3/PPPP1PPP/RNBQKBNR w KQkq - 0 2"
     );
   });
 });
 
-describe("initial moves", () => {
+Deno.test("initial moves", async (t) => {
   const engine = new Engine();
 
-  it("white pawn", () => {
-    assert.deepEqual(engine.possibleMoves("a2"), [
+  await t.step("white pawn", () => {
+    expect(engine.possibleMoves("a2")).toEqual([
       { type: "normal", from: "a2", to: "a3" },
       { type: "normal", from: "a2", to: "a4" },
     ]);
-    assert.deepEqual(engine.possibleMoves("c2"), [
+    expect(engine.possibleMoves("c2")).toEqual([
       { type: "normal", from: "c2", to: "c3" },
       { type: "normal", from: "c2", to: "c4" },
     ]);
-    assert.deepEqual(engine.possibleMoves("d2"), [
+    expect(engine.possibleMoves("d2")).toEqual([
       { type: "normal", from: "d2", to: "d3" },
       { type: "normal", from: "d2", to: "d4" },
     ]);
-    assert.deepEqual(engine.possibleMoves("e2"), [
+    expect(engine.possibleMoves("e2")).toEqual([
       { type: "normal", from: "e2", to: "e3" },
       { type: "normal", from: "e2", to: "e4" },
     ]);
-    assert.deepEqual(engine.possibleMoves("f2"), [
+    expect(engine.possibleMoves("f2")).toEqual([
       { type: "normal", from: "f2", to: "f3" },
       { type: "normal", from: "f2", to: "f4" },
     ]);
-    assert.deepEqual(engine.possibleMoves("g2"), [
+    expect(engine.possibleMoves("g2")).toEqual([
       { type: "normal", from: "g2", to: "g3" },
       { type: "normal", from: "g2", to: "g4" },
     ]);
-    assert.deepEqual(engine.possibleMoves("h2"), [
+    expect(engine.possibleMoves("h2")).toEqual([
       { type: "normal", from: "h2", to: "h3" },
       { type: "normal", from: "h2", to: "h4" },
     ]);
   });
 
-  it("black pawn", () => {
-    assert.deepEqual(engine.possibleMoves("a7"), [
+  await t.step("black pawn", () => {
+    expect(engine.possibleMoves("a7")).toEqual([
       { type: "normal", from: "a7", to: "a6" },
       { type: "normal", from: "a7", to: "a5" },
     ]);
-    assert.deepEqual(engine.possibleMoves("b7"), [
+    expect(engine.possibleMoves("b7")).toEqual([
       { type: "normal", from: "b7", to: "b6" },
       { type: "normal", from: "b7", to: "b5" },
     ]);
-    assert.deepEqual(engine.possibleMoves("c7"), [
+    expect(engine.possibleMoves("c7")).toEqual([
       { type: "normal", from: "c7", to: "c6" },
       { type: "normal", from: "c7", to: "c5" },
     ]);
-    assert.deepEqual(engine.possibleMoves("d7"), [
+    expect(engine.possibleMoves("d7")).toEqual([
       { type: "normal", from: "d7", to: "d6" },
       { type: "normal", from: "d7", to: "d5" },
     ]);
-    assert.deepEqual(engine.possibleMoves("e7"), [
+    expect(engine.possibleMoves("e7")).toEqual([
       { type: "normal", from: "e7", to: "e6" },
       { type: "normal", from: "e7", to: "e5" },
     ]);
-    assert.deepEqual(engine.possibleMoves("f7"), [
+    expect(engine.possibleMoves("f7")).toEqual([
       { type: "normal", from: "f7", to: "f6" },
       { type: "normal", from: "f7", to: "f5" },
     ]);
-    assert.deepEqual(engine.possibleMoves("g7"), [
+    expect(engine.possibleMoves("g7")).toEqual([
       { type: "normal", from: "g7", to: "g6" },
       { type: "normal", from: "g7", to: "g5" },
     ]);
-    assert.deepEqual(engine.possibleMoves("h7"), [
+    expect(engine.possibleMoves("h7")).toEqual([
       { type: "normal", from: "h7", to: "h6" },
       { type: "normal", from: "h7", to: "h5" },
     ]);
   });
 });
 
-describe("capture", () => {
-  it("n captures P", () => {
+Deno.test("capture", async (t) => {
+  await t.step("n captures P", () => {
     const engine = new Engine();
 
     engine.move({ type: "normal", from: "e2", to: "e4" });
     engine.move({ type: "normal", from: "g8", to: "f6" });
     engine.move({ type: "normal", from: "f1", to: "c4" });
-    assert.equal(
-      engine.fen(),
+    expect(engine.fen()).toEqual(
       "rnbqkb1r/pppppppp/5n2/8/2B1P3/8/PPPP1PPP/RNBQK1NR b KQkq - 2 2"
     );
 
     // n captures:
     engine.move({ type: "normal", from: "f6", to: "e4" });
-    assert.equal(
-      engine.fen(),
+    expect(engine.fen()).toEqual(
       "rnbqkb1r/pppppppp/8/8/2B1n3/8/PPPP1PPP/RNBQK1NR w KQkq - 0 3"
     );
   });