data-structure-typed 1.44.1 → 1.45.0

package/src/utils/utils.ts

@@ -84,3 +84,16 @@ export const getMSB = (value: number): number => {
   }
   return 1 << (31 - Math.clz32(value));
 };
+
+export const rangeCheck = (index: number, min: number, max: number, message = 'Index out of bounds.'): void => {
+  if (index < min || index > max) throw new RangeError(message);
+}
+
+export const throwRangeError = (message = 'The value is off-limits.'): void => {
+  throw new RangeError(message);
+}
+
+export const isObjOrFunc = (input: unknown): input is Record<string, unknown> | ((...args: any[]) => any) => {
+  const inputType = typeof input;
+  return (inputType === 'object' && input !== null) || inputType === 'function';
+}

package/test/config.ts

@@ -1,2 +1,2 @@
 export const isDebugTest: boolean = false;
-export const isCompetitor: boolean = true;
+export const isCompetitor: boolean = false;

package/test/unit/data-structures/binary-tree/avl-tree.test.ts

@@ -219,7 +219,7 @@ describe('AVL Tree Test recursively', () => {
 });
 
 describe('AVLTree APIs test', () => {
-  const avl = new AVLTree<{id: number; text: string}>();
+  const avl = new AVLTree<{ id: number; text: string }>();
   beforeEach(() => {
     avl.clear();
   });
@@ -268,7 +268,7 @@ describe('AVLTree', () => {
   });
 
   describe('BinaryTree APIs test', () => {
-    const avl = new AVLTree<{id: number; text: string}>();
+    const avl = new AVLTree<{ id: number; text: string }>();
     beforeEach(() => {
       avl.clear();
     });

package/test/unit/data-structures/binary-tree/bst.test.ts

@@ -189,7 +189,7 @@ describe('BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
@@ -260,7 +260,7 @@ describe('BST operations test', () => {
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced: BSTNode<{key: number; keyA: number}>[] = [];
+    const bfsNodesAfterBalanced: BSTNode<{ key: number; keyA: number }>[] = [];
     objBST.bfs(node => bfsNodesAfterBalanced.push(node));
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
@@ -385,7 +385,7 @@ describe('BST operations test', () => {
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes: BSTNode<{key: number; keyA: number}>[] = [];
+    const bfsNodes: BSTNode<{ key: number; keyA: number }>[] = [];
     objBST.bfs(node => bfsNodes.push(node));
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);
@@ -580,7 +580,7 @@ describe('BST operations test recursively', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
@@ -652,7 +652,7 @@ describe('BST operations test recursively', () => {
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced: BSTNode<{key: number; keyA: number}>[] = [];
+    const bfsNodesAfterBalanced: BSTNode<{ key: number; keyA: number }>[] = [];
     objBST.bfs(node => bfsNodesAfterBalanced.push(node));
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
@@ -777,7 +777,7 @@ describe('BST operations test recursively', () => {
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes: BSTNode<{key: number; keyA: number}>[] = [];
+    const bfsNodes: BSTNode<{ key: number; keyA: number }>[] = [];
     objBST.bfs(node => bfsNodes.push(node));
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);

package/test/unit/data-structures/binary-tree/overall.test.ts

@@ -29,7 +29,7 @@ describe('Overall BinaryTree Test', () => {
     bfsIDs[0] === 11; // true
     expect(bfsIDs[0]).toBe(11);
 
-    const objBST = new BST<{key: number; keyA: number}>();
+    const objBST = new BST<{ key: number; keyA: number }>();
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
 

package/test/unit/data-structures/binary-tree/rb-tree.test.ts

@@ -13,7 +13,7 @@ describe('RedBlackTree', () => {
   });
 
   describe('add and getNode', () => {
-    test('should add and find a node in the tree', () => {
+    it('should add and find a node in the tree', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -24,7 +24,7 @@ describe('RedBlackTree', () => {
       expect(tree.getNode(15)).toBe(undefined);
     });
 
-    test('should add and find nodes with negative keys', () => {
+    it('should add and find nodes with negative keys', () => {
       tree.add(-10);
       tree.add(-20);
 
@@ -34,7 +34,7 @@ describe('RedBlackTree', () => {
   });
 
   describe('deleteNode', () => {
-    test('should delete a node from the tree', () => {
+    it('should delete a node from the tree', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -43,7 +43,7 @@ describe('RedBlackTree', () => {
       expect(tree.getNode(20)).toBe(undefined);
     });
 
-    test('should handle deleting a non-existent node', () => {
+    it('should handle deleting a non-existent node', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -54,7 +54,7 @@ describe('RedBlackTree', () => {
   });
 
   describe('minimum', () => {
-    test('should find the minimum node in the tree', () => {
+    it('should find the minimum node in the tree', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -65,14 +65,14 @@ describe('RedBlackTree', () => {
       expect(minNode?.key).toBe(3);
     });
 
-    test('should handle an empty tree', () => {
+    it('should handle an empty tree', () => {
       const minNode = tree.getLeftMost(tree.root);
       expect(minNode).toBe(tree.NIL);
     });
   });
 
   describe('getRightMost', () => {
-    test('should find the getRightMost node in the tree', () => {
+    it('should find the getRightMost node in the tree', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -83,14 +83,14 @@ describe('RedBlackTree', () => {
       expect(maxNode?.key).toBe(25);
     });
 
-    test('should handle an empty tree', () => {
+    it('should handle an empty tree', () => {
       const maxNode = tree.getRightMost(tree.root);
       expect(maxNode).toBe(tree.NIL);
     });
   });
 
   describe('getSuccessor', () => {
-    test('should find the getSuccessor of a node', () => {
+    it('should find the getSuccessor of a node', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -103,7 +103,7 @@ describe('RedBlackTree', () => {
       expect(successorNode?.key).toBe(20);
     });
 
-    test('should handle a node with no getSuccessor', () => {
+    it('should handle a node with no getSuccessor', () => {
       tree.add(10);
       tree.add(5);
 
@@ -115,7 +115,7 @@ describe('RedBlackTree', () => {
   });
 
   describe('getPredecessor', () => {
-    test('should find the getPredecessor of a node', () => {
+    it('should find the getPredecessor of a node', () => {
       tree.add(10);
       tree.add(20);
       tree.add(5);
@@ -128,7 +128,7 @@ describe('RedBlackTree', () => {
       expect(predecessorNode?.key).toBe(15);
     });
 
-    test('should handle a node with no getPredecessor', () => {
+    it('should handle a node with no getPredecessor', () => {
       tree.add(10);
       tree.add(20);
 

package/test/unit/data-structures/binary-tree/tree-multimap.test.ts

@@ -207,7 +207,7 @@ describe('TreeMultimap operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultimap = new TreeMultimap<{key: number; keyA: number}>();
+    const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
     objTreeMultimap.add(11, {key: 11, keyA: 11});
     objTreeMultimap.add(3, {key: 3, keyA: 3});
@@ -447,7 +447,7 @@ describe('TreeMultimap operations test recursively', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultimap = new TreeMultimap<{key: number; keyA: number}>();
+    const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
     objTreeMultimap.add(11, {key: 11, keyA: 11});
     objTreeMultimap.add(3, {key: 3, keyA: 3});

package/test/unit/data-structures/graph/abstract-graph.test.ts

@@ -74,7 +74,8 @@ class MyGraph<V = any, E = any, VO extends MyVertex<V> = MyVertex<V>, EO extends
 describe('AbstractGraph Operation Test', () => {
   const myGraph: MyGraph<number, string> = new MyGraph<number, string>();
 
-  beforeEach(() => {});
+  beforeEach(() => {
+  });
   it('should edge cases', function () {
     myGraph.addVertex('A', 1);
     myGraph.addVertex('B', 2);

package/test/unit/data-structures/graph/undirected-graph.test.ts

@@ -150,7 +150,7 @@ describe('UndirectedGraph', () => {
   });
 
   it('should getAllPathsBetween work well in 66 vertexes 97 edges graph', () => {
-    const graph = new UndirectedGraph<{name: string}, number>();
+    const graph = new UndirectedGraph<{ name: string }, number>();
     for (const v of saltyVertexes) {
       graph.addVertex(v.name, v);
     }

package/test/unit/data-structures/hash/hash-map.test.ts

@@ -1,4 +1,6 @@
 import {HashMap} from '../../../../src';
+import {getRandomInt, getRandomIntArray} from "../../../utils";
+
 
 describe('HashMap', () => {
   let hashMap: HashMap<string, number>;
@@ -9,10 +11,10 @@ describe('HashMap', () => {
 
   it('should initialize correctly', () => {
     expect(hashMap.size).toBe(0);
-    expect(hashMap.table.length).toBe(16);
-    expect(hashMap.loadFactor).toBe(0.75);
-    expect(hashMap.capacityMultiplier).toBe(2);
-    expect(hashMap.initialCapacity).toBe(16);
+    // expect(hashMap.table.length).toBe(16);
+    // expect(hashMap.loadFactor).toBe(0.75);
+    // expect(hashMap.capacityMultiplier).toBe(2);
+    // expect(hashMap.initialCapacity).toBe(16);
     expect(hashMap.isEmpty()).toBe(true);
   });
 
@@ -58,26 +60,23 @@ describe('HashMap', () => {
     hashMap.set('two', 2);
     hashMap.set('three', 3);
 
-    const entries = Array.from(hashMap.entries());
-    expect(entries).toEqual(
-      expect.arrayContaining([
-        ['one', 1],
-        ['two', 2],
-        ['three', 3]
-      ])
-    );
+    // const entries = Array.from(hashMap.entries());
+    // expect(entries).toContainEqual(['one', 1]);
+    // expect(entries).toContainEqual(['two', 2]);
+    // expect(entries).toContainEqual(['three', 3]);
   });
 
+
   it('should resize the table when load factor is exceeded', () => {
     // Set a small initial capacity for testing resizing
-    hashMap = new HashMap<string, number>(4, 0.5);
+    hashMap = new HashMap<string, number>();
 
     hashMap.set('one', 1);
     hashMap.set('two', 2);
     hashMap.set('three', 3);
     hashMap.set('four', 4); // This should trigger a resize
 
-    expect(hashMap.table.length).toBe(8);
+    // expect(hashMap.table.length).toBe(8);
     expect(hashMap.get('one')).toBe(1);
     expect(hashMap.get('two')).toBe(2);
     expect(hashMap.get('three')).toBe(3);
@@ -85,11 +84,8 @@ describe('HashMap', () => {
   });
 
   it('should allow using a custom hash function', () => {
-    const customHashFn = () => {
-      // A simple custom hash function that always returns 0
-      return 0;
-    };
-    hashMap = new HashMap<string, number>(16, 0.75, customHashFn);
+
+    hashMap = new HashMap<string, number>();
 
     hashMap.set('one', 1);
     hashMap.set('two', 2);
@@ -98,6 +94,141 @@ describe('HashMap', () => {
     expect(hashMap.get('two')).toBe(2);
     // Since the custom hash function always returns 0, these keys will collide.
     // Make sure they are stored separately.
-    expect(hashMap.table[0].length).toBe(2);
+    // expect(hashMap.table[0].length).toBe(2);
   });
 });
+
+describe('HashMap', () => {
+  let hashMap: HashMap;
+
+  beforeEach(() => {
+    hashMap = new HashMap();
+  });
+
+  it('should create an empty map', () => {
+    expect(hashMap.size).toBe(0);
+  });
+
+  it('should add a key-value pair', () => {
+    hashMap.set('key1', 'value1');
+    expect(hashMap.get('key1')).toBe('value1');
+  });
+
+  it('should handle object keys correctly', () => {
+    const keyObj = {id: 1};
+    hashMap.set(keyObj, 'objectValue');
+    expect(hashMap.get(keyObj)).toBe('objectValue');
+  });
+
+  it('should handle number keys correctly', () => {
+    hashMap.set(999, {a: '999Value'});
+    expect(hashMap.get(999)).toEqual({a: '999Value'});
+  });
+
+  it('should update the value for an existing key', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.set('key1', 'newValue');
+    expect(hashMap.get('key1')).toBe('newValue');
+  });
+
+  it('should return undefined for a non-existent key', () => {
+    expect(hashMap.get('nonExistentKey')).toBeUndefined();
+  });
+
+  it('should remove a key-value pair', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.delete('key1');
+    expect(hashMap.get('key1')).toBeUndefined();
+  });
+
+  it('should clear the map', () => {
+    hashMap.set('key1', 'value1');
+    expect(hashMap.size).toBe(1);
+
+    hashMap.clear();
+    expect(hashMap.size).toBe(0);
+  });
+
+  it('should iterate over values', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.set('key2', 'value2');
+    const values = [];
+    for (const value of hashMap) {
+      values.push(value);
+    }
+    expect(values).toEqual([['key1', 'value1'], ['key2', 'value2']]);
+  });
+
+  // test('should delete element at specific index', () => {
+  //   hashMap.set('key1', 'value1');
+  //   hashMap.set('key2', 'value2');
+  //   hashMap.deleteAt(0);
+  //   expect(hashMap.get('key1')).toBeUndefined();
+  //   expect(hashMap.size).toBe(1);
+  // });
+  function compareHashMaps(hashMap: HashMap<unknown, unknown>, stdMap: Map<unknown, unknown>) {
+    expect(hashMap.size).toEqual(stdMap.size);
+    let index = 0;
+    stdMap.forEach((value, key) => {
+      if (index === 0) {
+        expect(hashMap.front).toEqual([key, value]);
+        expect(hashMap.begin.current[0]).toEqual(key);
+      } else if (index === hashMap.size - 1) {
+        expect(hashMap.back).toEqual([key, value]);
+        expect(hashMap.reverseBegin.current[0]).toEqual(key);
+      } else if (index <= 1000) {
+        expect(hashMap.getAt(index)).toEqual([key, value]);
+      }
+      expect(hashMap.get(key)).toEqual(value);
+      expect(hashMap.getIterator(key).current[1]).toEqual(value);
+      index++;
+    });
+  }
+
+  const stdMap: Map<unknown, unknown> = new Map();
+  const arr: number[] = getRandomIntArray(1000, 1, 10000);
+
+  it('delete test', () => {
+    for (const item of arr) {
+      stdMap.set(item, item);
+      hashMap.set(item, item);
+    }
+    for (const item of arr) {
+      if (Math.random() > 0.6) {
+        expect(hashMap.delete(item)).toEqual(stdMap.delete(item));
+      }
+    }
+    compareHashMaps(hashMap, stdMap);
+
+    for (let i = 0; i < 1000; ++i) {
+      const random = getRandomInt(0, 100);
+      expect(hashMap.delete(random)).toEqual(stdMap.delete(random));
+    }
+    compareHashMaps(hashMap, stdMap);
+  });
+
+  test('should iterate correctly with reverse iterators', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.set('key2', 'value2');
+    const iterator = hashMap.reverseBegin;
+    expect(iterator.next().current).toEqual(['key1', 'value1']);
+
+  });
+
+  test('should return the last element', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.set('key2', 'value2');
+    expect(hashMap.back).toEqual(['key2', 'value2']);
+  });
+
+  test('should return undefined for empty map', () => {
+    expect(hashMap.back).toBeUndefined();
+  });
+
+  test('should get element at specific index', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.set('key2', 'value2');
+    expect(hashMap.getAt(1)).toEqual(['key2', 'value2']);
+  });
+})
+

package/test/unit/data-structures/heap/heap.test.ts

@@ -22,7 +22,7 @@ describe('Heap Operation Test', () => {
   });
 
   it('should object heap work well', function () {
-    const minHeap = new MinHeap<{a: string; key: number}>({comparator: (a, b) => a.key - b.key});
+    const minHeap = new MinHeap<{ a: string; key: number }>({comparator: (a, b) => a.key - b.key});
     minHeap.add({key: 1, a: 'a1'});
     minHeap.add({key: 6, a: 'a6'});
     minHeap.add({key: 2, a: 'a2'});
@@ -37,7 +37,7 @@ describe('Heap Operation Test', () => {
       i++;
     }
 
-    const maxHeap = new MaxHeap<{key: number; a: string}>({comparator: (a, b) => b.key - a.key});
+    const maxHeap = new MaxHeap<{ key: number; a: string }>({comparator: (a, b) => b.key - a.key});
     maxHeap.add({key: 1, a: 'a1'});
     maxHeap.add({key: 6, a: 'a6'});
     maxHeap.add({key: 5, a: 'a5'});
@@ -62,13 +62,13 @@ describe('FibonacciHeap', () => {
     heap = new FibonacciHeap<number>();
   });
 
-  test('push & peek', () => {
+  it('push & peek', () => {
     heap.push(10);
     heap.push(5);
     expect(heap.peek()).toBe(5);
   });
 
-  test('pop', () => {
+  it('pop', () => {
     heap.push(10);
     heap.push(5);
     heap.push(15);
@@ -77,11 +77,11 @@ describe('FibonacciHeap', () => {
     expect(heap.pop()).toBe(15);
   });
 
-  test('pop on an empty heap', () => {
+  it('pop on an empty heap', () => {
     expect(heap.pop()).toBeUndefined();
   });
 
-  test('size', () => {
+  it('size', () => {
     expect(heap.size).toBe(0);
     heap.push(10);
     expect(heap.size).toBe(1);
@@ -89,7 +89,7 @@ describe('FibonacciHeap', () => {
     expect(heap.size).toBe(0);
   });
 
-  test('clear', () => {
+  it('clear', () => {
     heap.push(10);
     heap.push(5);
     heap.clear();
@@ -97,7 +97,7 @@ describe('FibonacciHeap', () => {
     expect(heap.peek()).toBeUndefined();
   });
 
-  test('custom comparator', () => {
+  it('custom comparator', () => {
     const maxHeap = new FibonacciHeap<number>((a, b) => b - a);
     maxHeap.push(10);
     maxHeap.push(5);

package/test/unit/data-structures/heap/max-heap.test.ts

@@ -8,7 +8,7 @@ describe('MaxHeap', () => {
     maxHeap = new MaxHeap({comparator: numberComparator});
   });
 
-  test('add and poll elements in descending order', () => {
+  it('add and poll elements in descending order', () => {
     maxHeap.add(3);
     maxHeap.add(1);
     maxHeap.add(4);
@@ -20,7 +20,7 @@ describe('MaxHeap', () => {
     expect(maxHeap.poll()).toBe(1);
   });
 
-  test('peek at the top element without removing it', () => {
+  it('peek at the top element without removing it', () => {
     maxHeap.add(3);
     maxHeap.add(1);
     maxHeap.add(4);
@@ -30,7 +30,7 @@ describe('MaxHeap', () => {
     expect(maxHeap.size).toBe(4);
   });
 
-  test('sort elements in descending order', () => {
+  it('sort elements in descending order', () => {
     maxHeap.add(3);
     maxHeap.add(1);
     maxHeap.add(4);
@@ -40,7 +40,7 @@ describe('MaxHeap', () => {
     expect(sortedArray).toEqual([4, 3, 2, 1]);
   });
 
-  test('check if the heap is empty', () => {
+  it('check if the heap is empty', () => {
     expect(maxHeap.isEmpty()).toBe(true);
 
     maxHeap.add(5);

package/test/unit/data-structures/heap/min-heap.test.ts

@@ -8,7 +8,7 @@ describe('MinHeap', () => {
     minHeap = new MinHeap({comparator: numberComparator});
   });
 
-  test('add and poll elements in ascending order', () => {
+  it('add and poll elements in ascending order', () => {
     minHeap.add(3);
     minHeap.add(1);
     minHeap.add(4);
@@ -20,7 +20,7 @@ describe('MinHeap', () => {
     expect(minHeap.poll()).toBe(4);
   });
 
-  test('peek at the top element without removing it', () => {
+  it('peek at the top element without removing it', () => {
     minHeap.add(3);
     minHeap.add(1);
     minHeap.add(4);
@@ -30,7 +30,7 @@ describe('MinHeap', () => {
     expect(minHeap.size).toBe(4);
   });
 
-  test('sort elements in ascending order', () => {
+  it('sort elements in ascending order', () => {
     minHeap.add(3);
     minHeap.add(1);
     minHeap.add(4);
@@ -40,7 +40,7 @@ describe('MinHeap', () => {
     expect(sortedArray).toEqual([1, 2, 3, 4]);
   });
 
-  test('check if the heap is empty', () => {
+  it('check if the heap is empty', () => {
     expect(minHeap.isEmpty()).toBe(true);
 
     minHeap.add(5);

package/test/unit/data-structures/linked-list/doubly-linked-list.test.ts

@@ -60,7 +60,7 @@ describe('DoublyLinkedList Operation Test', () => {
 
 describe('DoublyLinkedList Operation Test', () => {
   let list: DoublyLinkedList<number>;
-  let objectList: DoublyLinkedList<{keyA: number}>;
+  let objectList: DoublyLinkedList<{ keyA: number }>;
 
   beforeEach(() => {
     list = new DoublyLinkedList();

package/test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -11,10 +11,10 @@ describe('SinglyLinkedListNode', () => {
 
 describe('SinglyLinkedList Operation Test', () => {
   let list: SinglyLinkedList<number>;
-  let objectList: SinglyLinkedList<{keyA: number}>;
+  let objectList: SinglyLinkedList<{ keyA: number }>;
   beforeEach(() => {
     list = new SinglyLinkedList<number>();
-    objectList = new SinglyLinkedList<{keyA: number}>();
+    objectList = new SinglyLinkedList<{ keyA: number }>();
   });
 
   describe('push', () => {

package/test/unit/data-structures/linked-list/skip-list.test.ts

@@ -65,21 +65,21 @@ describe('SkipList', () => {
     skipList.add(4, 'Four');
   });
 
-  test('getFirst() should return the getFirst element', () => {
+  it('getFirst() should return the getFirst element', () => {
     expect(skipList.getFirst()).toBe('One');
   });
 
-  test('getLast() should return the getLast element', () => {
+  it('getLast() should return the getLast element', () => {
     expect(skipList.getLast()).toBe('Four');
   });
 
-  test('higher(key) should return the getFirst element greater than the given key', () => {
+  it('higher(key) should return the getFirst element greater than the given key', () => {
     expect(skipList.higher(2)).toBe('Three');
     expect(skipList.higher(3)).toBe('Four');
     expect(skipList.higher(4)).toBeUndefined();
   });
 
-  test('lower(key) should return the getLast element less than the given key', () => {
+  it('lower(key) should return the getLast element less than the given key', () => {
     expect(skipList.lower(2)).toBe('One');
     expect(skipList.lower(1)).toBe(null);
   });

package/test/unit/data-structures/priority-queue/max-priority-queue.test.ts

@@ -16,7 +16,7 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should add elements and maintain heap property in a object MaxPriorityQueue', () => {
-    const priorityQueue = new MaxPriorityQueue<{keyA: number}>({comparator: (a, b) => b.keyA - a.keyA});
+    const priorityQueue = new MaxPriorityQueue<{ keyA: number }>({comparator: (a, b) => b.keyA - a.keyA});
     priorityQueue.refill([{keyA: 5}, {keyA: 3}, {keyA: 1}]);
     priorityQueue.add({keyA: 7});
 
@@ -63,7 +63,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an object array', () => {
     const nodes = [{keyA: 5}, {keyA: 3}, {keyA: 7}, {keyA: 1}];
-    const maxPQ = MaxPriorityQueue.heapify<{keyA: number}>({nodes: nodes, comparator: (a, b) => b.keyA - a.keyA});
+    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({nodes: nodes, comparator: (a, b) => b.keyA - a.keyA});
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);