✅ test: update tests

Author: guanghechen

Diff for: .vscode/settings.json

@@ -21,7 +21,8 @@
     "plusplus",
     "postpublish",
     "prebuild",
-    "totient"
+    "totient",
+    "varepsilon"
   ],
   "files.associations": {
     ".prettierrc": "yaml"

Diff for: _fixtures/leetcode/word-break-ii/data.json

@@ -0,0 +1,14 @@
+[
+  {
+    "input": ["catsanddog", ["cat", "cats", "and", "sand", "dog"]],
+    "answer": ["cat sand dog", "cats and dog"]
+  },
+  {
+    "input": ["pineapplepenapple", ["apple", "pen", "applepen", "pine", "pineapple"]],
+    "answer": ["pine apple pen apple", "pine applepen apple", "pineapple pen apple"]
+  },
+  {
+    "input": ["catsandog", ["cats", "dog", "sand", "and", "cat"]],
+    "answer": []
+  }
+]

Diff for: _fixtures/leetcode/word-search-ii/data.json

@@ -0,0 +1,54 @@
+[
+  {
+    "input": [
+      [
+        ["o", "a", "a", "n"],
+        ["e", "t", "a", "e"],
+        ["i", "h", "k", "r"],
+        ["i", "f", "l", "v"]
+      ],
+      ["oath", "pea", "eat", "rain"]
+    ],
+    "answer": ["oath", "eat"]
+  },
+  {
+    "input": [
+      [
+        ["a", "b"],
+        ["c", "d"]
+      ],
+      ["abcb"]
+    ],
+    "answer": []
+  },
+  {
+    "input": [
+      [
+        ["d", "c", "e", "b", "d", "e", "d", "a"],
+        ["c", "a", "e", "a", "d", "d", "e", "e"],
+        ["a", "c", "e", "d", "b", "c", "c", "b"],
+        ["c", "b", "a", "a", "a", "e", "e", "e"],
+        ["a", "e", "d", "e", "b", "d", "d", "e"],
+        ["a", "a", "d", "c", "e", "a", "d", "e"],
+        ["b", "d", "e", "b", "b", "b", "c", "e"],
+        ["d", "a", "e", "e", "b", "e", "b", "d"],
+        ["b", "b", "c", "a", "b", "b", "b", "a"],
+        ["a", "c", "b", "a", "c", "a", "d", "d"]
+      ],
+      [
+        "ab",
+        "bddbebcba",
+        "ededa",
+        "daebeda",
+        "edecaeabc",
+        "cbeedad",
+        "bcaaecb",
+        "c",
+        "eb",
+        "aadbdbacee",
+        "dcaaba"
+      ]
+    ],
+    "answer": ["ab", "ededa", "daebeda", "c", "eb"]
+  }
+]

Diff for: packages/binary-index-tree/__test__/binary-saerch-tree.spec.ts

@@ -160,9 +160,9 @@ describe('tree1-mod', function () {
 
     for (let q = 0; q < 1000; ++q) {
       const x = Math.max(1, Math.ceil(Math.random() * MAX_N))
-      const value = Math.round(Math.random() * (MOD - 1))
+      const value = Math.round(Math.random() * MOD * 2) - MOD
 
-      A[x - 1] += value
+      A[x - 1] = (((A[x - 1] + value) % MOD) + MOD) % MOD
       bit.add(x, value)
       expect(bit.query(x)).toBe(getSum(x))
     }

Diff for: packages/calculate/__test__/calculate.spec.ts

@@ -1,7 +1,33 @@
-import { bigintCalculate, calculate, decimalCalculate } from '../src'
+import {
+  bigintCalculate,
+  calculate,
+  createCalculate,
+  decimalCalculate,
+  integerOperations,
+} from '../src'
+
+describe('basic', function () {
+  test('custom', function () {
+    const f = createCalculate(integerOperations)
+    expect(f('1+2')).toEqual(3)
+    expect(() => f('1+2.2')).toThrow(/Unrecognized symbol/)
+  })
+})
 
 describe('calculate', function () {
   const data = [
+    {
+      input: '-0',
+      answer: 0,
+    },
+    {
+      input: '+1.3',
+      answer: 1.3,
+    },
+    {
+      input: '0.2',
+      answer: 0.2,
+    },
     {
       input: '-2+1',
       answer: -1,
@@ -72,6 +98,11 @@ describe('calculate', function () {
       }
     })
   }
+
+  test('exceptional', function () {
+    expect(() => decimalCalculate('$0.2')).toThrow(/Not a valid arithmetic expression/)
+    expect(() => decimalCalculate('1.1$0.2')).toThrow(/Not a valid arithmetic expression/)
+  })
 })
 
 describe('integer calculate', function () {

Diff for: packages/calculate/src/calculate.ts

@@ -51,6 +51,7 @@ export function createCalculate<T extends number | bigint>(
       }
 
       // Syntax error.
+      /* istanbul ignore next */
       if (id > 0) {
         throw new SyntaxError('Not a valid arithmetic expression.')
       }
@@ -63,6 +64,7 @@ export function createCalculate<T extends number | bigint>(
       const tokens: ReadonlyArray<number> = sddTable[ssdId]
       const syn0: T = tokens.length > 0 ? execute(tokens[0], ZERO, ZERO) : ZERO
 
+      /* istanbul ignore next */
       switch (ssdId) {
         // 0: A --> BD
         case 0:
@@ -129,6 +131,7 @@ export function createCalculate<T extends number | bigint>(
 
         // Here is not reachable.
         default:
+          /* istanbul ignore next */
           throw new Error('Shit codes!')
       }
     }

Diff for: packages/circular-queue/__test__/circular-queue.spec.ts

@@ -156,4 +156,10 @@ describe('createCircularQueue', function () {
     expect(queue.size()).toBe(2)
     expect(queue.size()).toBe(2)
   })
+
+  test('destroy', function () {
+    const queue = createCircularQueue()
+    queue.init(10)
+    queue.destroy()
+  })
 })

Diff for: packages/circular-queue/src/index.ts

@@ -16,7 +16,7 @@ export interface ICircularQueue<T> {
   /**
    * Free memory.
    */
-  free(): void
+  destroy(): void
   /**
    * Get the front element of the queue.
    */
@@ -78,7 +78,7 @@ export function createCircularQueue<T>(): ICircularQueue<T> {
 
   return {
     init,
-    free,
+    destroy,
     front,
     end,
     dequeue,
@@ -99,7 +99,7 @@ export function createCircularQueue<T>(): ICircularQueue<T> {
     _endIndex = 0
   }
 
-  function free(): void {
+  function destroy(): void {
     _MAX_SIZE = 0
     _size = 0
     _queue.length = 0

Diff for: packages/dlx/__test__/dlx.spec.ts

@@ -1,3 +1,4 @@
+import { createDLX } from '@algorithm.ts/dlx'
 import multipleSudoku3x3 from './fixtures/sudoku9x9/multiple.json'
 import uniqueSudoku3x3 from './fixtures/sudoku9x9/unique.json'
 import { solveSudoku } from './sudoku3x3'
@@ -23,6 +24,26 @@ describe('dlx', function () {
         expect(checkSudoku(solution, 3)).toBe(true)
       }
     })
+
+    test('no solution', function () {
+      const solution: number[][] = new Array(9)
+      for (let r = 0; r < 9; ++r) solution[r] = new Array(9)
+
+      for (const { puzzle, solution: _solution } of uniqueSudoku3x3) {
+        puzzle[0][0] = 2
+        puzzle[0][1] = 2
+        expect(solveSudoku(puzzle, solution)).toBe(false)
+      }
+    })
+  })
+
+  test('destroy', function () {
+    const dlx = createDLX(10)
+
+    dlx.init(10)
+    dlx.destroy()
+
+    expect(dlx.solve()).toEqual(null)
   })
 })
 

Diff for: packages/dlx/src/index.ts

@@ -58,7 +58,7 @@ export function createDLX(MAX_N: number): IDancingLinkX {
   const selectedRowNos: number[] = new Array(MAX_N) // list of row numbers of selected rows
   let countOfSelectedRows: number // the number of selected rows
 
-  const count: number[] = new Array(MAX_N) // lhe number of nodes of a column in the dancing-link
+  const count: number[] = new Array(MAX_N) // the number of nodes of a column in the dancing-link
   const row: number[] = new Array(MAX_N) // the row number of a node in the dancing-link
   const col: number[] = new Array(MAX_N) // the column number of a node in the dancing-link
   const L: number[] = new Array(MAX_N) // left pointer of cross-link list
@@ -91,6 +91,7 @@ export function createDLX(MAX_N: number): IDancingLinkX {
    * @public
    */
   function destroy(): void {
+    sz = 0
     selectedRowNos.length = 0
     count.length = 0
     row.length = 0
@@ -138,6 +139,7 @@ export function createDLX(MAX_N: number): IDancingLinkX {
    * @public
    */
   function solve(): number[] | null {
+    if (sz === 0) return null
     if (!algorithmX(0)) return null
     return selectedRowNos.slice(0, countOfSelectedRows)
   }

Diff for: packages/knuth-shuffle/src/index.ts

@@ -28,6 +28,7 @@ export function knuthShuffle<T = unknown>(
  */
 export function randomInt(n: number): number {
   const x = (Math.random() * n) >> 0
+  /* istanbul ignore next */
   return x === n ? n - 1 : x
 }
 

Diff for: packages/roman/__test__/int2roman.spec.ts

@@ -9,6 +9,10 @@ describe('int2roman', function () {
     expect(results).toMatchSnapshot('1..3999')
   })
 
+  test('custom', function () {
+    expect(int2roman(2137, 'ABCDEF')).toEqual('BBDFFF')
+  })
+
   test('exception', function () {
     expect(() => int2roman(0)).toThrow(/Out of range/)
     expect(() => int2roman(4000)).toThrow(/Out of range/)

Diff for: packages/roman/__test__/roman2int.spec.ts

@@ -8,4 +8,8 @@ describe('roman2int', function () {
       expect(v).toEqual(n)
     }
   })
+
+  test('exception', function () {
+    expect(() => roman2int('ABCD')).toThrow(/Invalid roman number/)
+  })
 })

Diff for: packages/roman/src/roman2int.ts

@@ -32,7 +32,11 @@ export function roman2int(
   const N = roman.length
   let value = 0
   for (let i = 0; i < N; ++i) {
-    const u: number = romanCodeMap[roman[i]] ?? 0
+    const u: number | undefined = romanCodeMap[roman[i]]
+    if (u === undefined) {
+      throw new TypeError(`Invalid roman number: (${roman})`)
+    }
+
     if (i + 1 < N && u < romanCodeMap[roman[i + 1]]) value -= u
     else value += u
   }

Diff for: packages/sudoku/src/creator.ts

@@ -105,6 +105,8 @@ export class SudokuCreator {
       const c = p & 0xffff
       radicalPuzzle[r][c] = -1
     }
+
+    /* istanbul ignore next */
     throw new Error('[createSolution] This is impossible!')
   }
 

Diff for: packages/sudoku/src/util.ts

@@ -57,6 +57,7 @@ export function copySudokuBoard(
  * @param SUDOKU_SIZE_SQRT
  * @returns
  */
+/* istanbul ignore next */
 export function checkSudokuSolution(solution: ISudokuBoard, SUDOKU_SIZE_SQRT: number): boolean {
   const SUDOKU_SIZE: number = SUDOKU_SIZE_SQRT * SUDOKU_SIZE_SQRT
   const nums: number[] = new Array(SUDOKU_SIZE)