data-structure-typed 1.44.1 → 1.45.1

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

@@ -1,4 +1,4 @@
-import {AbstractEdge, AbstractGraph, AbstractVertex, VertexKey} from '../../../../src';
+import { AbstractEdge, AbstractGraph, AbstractVertex, VertexKey } from '../../../../src';
 
 class MyVertex<V = any> extends AbstractVertex<V> {
   data?: V;
@@ -22,12 +22,12 @@ class MyEdge<E = any> extends AbstractEdge<E> {
   }
 }
 
-class MyGraph<V = any, E = any, VO extends MyVertex<V> = MyVertex<V>, EO extends MyEdge<E> = MyEdge<E>> extends AbstractGraph<
-  V,
-  E,
-  VO,
-  EO
-> {
+class MyGraph<
+  V = any,
+  E = any,
+  VO extends MyVertex<V> = MyVertex<V>,
+  EO extends MyEdge<E> = MyEdge<E>
+> extends AbstractGraph<V, E, VO, EO> {
   createVertex(key: VertexKey, value?: V): VO {
     return new MyVertex(key, value) as VO;
   }
@@ -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/directed-graph.test.ts

@@ -1,4 +1,4 @@
-import {DirectedEdge, DirectedGraph, DirectedVertex, VertexKey} from '../../../../src';
+import { DirectedEdge, DirectedGraph, DirectedVertex, VertexKey } from '../../../../src';
 
 describe('DirectedGraph Operation Test', () => {
   let graph: DirectedGraph;
@@ -126,12 +126,12 @@ class MyEdge<E = any> extends DirectedEdge<E> {
   }
 }
 
-class MyDirectedGraph<V = any, E = any, VO extends MyVertex<V> = MyVertex<V>, EO extends MyEdge<E> = MyEdge<E>> extends DirectedGraph<
-  V,
-  E,
-  VO,
-  EO
-> {
+class MyDirectedGraph<
+  V = any,
+  E = any,
+  VO extends MyVertex<V> = MyVertex<V>,
+  EO extends MyEdge<E> = MyEdge<E>
+> extends DirectedGraph<V, E, VO, EO> {
   createVertex(key: VertexKey, value: V): VO {
     return new MyVertex(key, value) as VO;
   }
@@ -319,7 +319,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     const fordResult1 = myGraph.bellmanFord(1);
     expect(fordResult1).toBeTruthy();
     expect(fordResult1.hasNegativeCycle).toBeUndefined();
-    const {distMap, preMap, paths, min, minPath} = fordResult1;
+    const { distMap, preMap, paths, min, minPath } = fordResult1;
     expect(distMap).toBeInstanceOf(Map);
     expect(distMap.size).toBe(9);
     expect(distMap.get(vertex1)).toBe(0);
@@ -343,7 +343,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     const floydResult = myGraph.floydWarshall();
     expect(floydResult).toBeTruthy();
     if (floydResult) {
-      const {costs, predecessor} = floydResult;
+      const { costs, predecessor } = floydResult;
       expect(costs).toBeInstanceOf(Array);
       expect(costs.length).toBe(9);
       expect(costs[0]).toEqual([32, 12, 35, 14, 70, Infinity, 61, Infinity, 19]);
@@ -351,9 +351,29 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(costs[2]).toEqual([3, 15, 38, 17, 35, Infinity, 64, Infinity, 22]);
       expect(costs[3]).toEqual([123, 135, 120, 137, 155, Infinity, 47, Infinity, 126]);
       expect(costs[4]).toEqual([133, 145, 130, 147, 165, Infinity, 57, Infinity, 136]);
-      expect(costs[5]).toEqual([Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity]);
+      expect(costs[5]).toEqual([
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity
+      ]);
       expect(costs[6]).toEqual([76, 88, 73, 90, 108, Infinity, 137, Infinity, 79]);
-      expect(costs[7]).toEqual([Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity]);
+      expect(costs[7]).toEqual([
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity
+      ]);
       expect(costs[8]).toEqual([173, 185, 170, 187, 205, Infinity, 97, Infinity, 176]);
 
       expect(predecessor).toBeInstanceOf(Array);
@@ -369,7 +389,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
 
     expect(dijkstraRes12tt).toBeTruthy();
     if (dijkstraRes12tt) {
-      const {distMap, minDist, minPath, paths} = dijkstraRes12tt;
+      const { distMap, minDist, minPath, paths } = dijkstraRes12tt;
       expect(distMap).toBeInstanceOf(Map);
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);
@@ -420,7 +440,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
 
     expect(dijkstraRes1ntt).toBeTruthy();
     if (dijkstraRes1ntt) {
-      const {distMap, minDist, minPath, paths} = dijkstraRes1ntt;
+      const { distMap, minDist, minPath, paths } = dijkstraRes1ntt;
       expect(distMap).toBeInstanceOf(Map);
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);
@@ -482,7 +502,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     const dijkstraWithoutHeapRes1ntt = myGraph.dijkstraWithoutHeap(1, null, true, true);
     expect(dijkstraWithoutHeapRes1ntt).toBeTruthy();
     if (dijkstraWithoutHeapRes1ntt) {
-      const {distMap, minDist, minPath, paths} = dijkstraWithoutHeapRes1ntt;
+      const { distMap, minDist, minPath, paths } = dijkstraWithoutHeapRes1ntt;
       expect(distMap).toBeInstanceOf(Map);
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);

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

@@ -1,4 +1,4 @@
-import {MapEdge, MapGraph, MapVertex} from '../../../../src';
+import { MapEdge, MapGraph, MapVertex } from '../../../../src';
 
 describe('MapGraph Operation Test', () => {
   it('dijkstra shortest path', () => {

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

@@ -1,4 +1,4 @@
-import {DirectedGraph, UndirectedGraph} from '../../../../src';
+import { DirectedGraph, UndirectedGraph } from '../../../../src';
 
 describe('Overall Graph Operation Test', () => {
   it('Overall DirectedGraph Operation Test', () => {

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

@@ -1,4 +1,4 @@
-import {UndirectedEdge, UndirectedGraph, UndirectedVertex} from '../../../../src';
+import { UndirectedEdge, UndirectedGraph, UndirectedVertex } from '../../../../src';
 import saltyVertexes from './salty-vertexes.json';
 import saltyEdges from './salty-edges.json';
 
@@ -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/coordinate-map.test.ts

@@ -1,4 +1,4 @@
-import {CoordinateMap} from '../../../../src';
+import { CoordinateMap } from '../../../../src';
 
 describe('CoordinateMap', () => {
   it('should set and get values correctly', () => {

package/test/unit/data-structures/hash/coordinate-set.test.ts

@@ -1,4 +1,4 @@
-import {CoordinateSet} from '../../../../src';
+import { CoordinateSet } from '../../../../src';
 
 describe('CoordinateSet', () => {
   it('should add and check values correctly', () => {

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

@@ -1,4 +1,5 @@
-import {HashMap} from '../../../../src';
+import { HashMap } from '../../../../src';
+import { getRandomInt, getRandomIntArray } from '../../../utils';
 
 describe('HashMap', () => {
   let hashMap: HashMap<string, number>;
@@ -9,10 +10,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 +59,22 @@ 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 +82,7 @@ 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 +91,142 @@ 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/hash/hash-table.test.ts

@@ -1,4 +1,4 @@
-import {HashTable, HashTableNode} from '../../../../src';
+import { HashTable, HashTableNode } from '../../../../src';
 
 describe('HashNode', () => {
   it('should create a HashNode with key and value', () => {

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

@@ -1,5 +1,5 @@
-import {FibonacciHeap, MaxHeap, MinHeap} from '../../../../src';
-import {logBigOMetricsWrap} from '../../../utils';
+import { FibonacciHeap, MaxHeap, MinHeap } from '../../../../src';
+import { logBigOMetricsWrap } from '../../../utils';
 
 describe('Heap Operation Test', () => {
   it('should numeric heap work well', function () {
@@ -22,34 +22,46 @@ 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});
-    minHeap.add({key: 1, a: 'a1'});
-    minHeap.add({key: 6, a: 'a6'});
-    minHeap.add({key: 2, a: 'a2'});
-    minHeap.add({key: 0, a: 'a0'});
-
-    expect(minHeap.peek()).toEqual({a: 'a0', key: 0});
-    expect(minHeap.toArray().map(item => ({a: item.a}))).toEqual([{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}]);
+    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' });
+    minHeap.add({ key: 0, a: 'a0' });
+
+    expect(minHeap.peek()).toEqual({ a: 'a0', key: 0 });
+    expect(minHeap.toArray().map(item => ({ a: item.a }))).toEqual([
+      { a: 'a0' },
+      { a: 'a1' },
+      { a: 'a2' },
+      { a: 'a6' }
+    ]);
     let i = 0;
-    const expectPolled = [{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}];
+    const expectPolled = [{ a: 'a0' }, { a: 'a1' }, { a: 'a2' }, { a: 'a6' }];
     while (minHeap.size > 0) {
-      expect({a: minHeap.poll()?.a}).toEqual(expectPolled[i]);
+      expect({ a: minHeap.poll()?.a }).toEqual(expectPolled[i]);
       i++;
     }
 
-    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'});
-    maxHeap.add({key: 2, a: 'a2'});
-    maxHeap.add({key: 0, a: 'a0'});
-    maxHeap.add({key: 9, a: 'a9'});
-    expect(maxHeap.peek()).toEqual({a: 'a9', key: 9});
-    expect(maxHeap.toArray().map(item => ({a: item.a}))).toEqual([{a: 'a9'}, {a: 'a2'}, {a: 'a6'}, {a: 'a1'}, {a: 'a0'}, {a: 'a5'}]);
-    const maxExpectPolled = [{a: 'a9'}, {a: 'a6'}, {a: 'a5'}, {a: 'a2'}, {a: 'a1'}, {a: 'a0'}];
+    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' });
+    maxHeap.add({ key: 2, a: 'a2' });
+    maxHeap.add({ key: 0, a: 'a0' });
+    maxHeap.add({ key: 9, a: 'a9' });
+    expect(maxHeap.peek()).toEqual({ a: 'a9', key: 9 });
+    expect(maxHeap.toArray().map(item => ({ a: item.a }))).toEqual([
+      { a: 'a9' },
+      { a: 'a2' },
+      { a: 'a6' },
+      { a: 'a1' },
+      { a: 'a0' },
+      { a: 'a5' }
+    ]);
+    const maxExpectPolled = [{ a: 'a9' }, { a: 'a6' }, { a: 'a5' }, { a: 'a2' }, { a: 'a1' }, { a: 'a0' }];
     let maxI = 0;
     while (maxHeap.size > 0) {
-      expect({a: maxHeap.poll()?.a}).toEqual(maxExpectPolled[maxI]);
+      expect({ a: maxHeap.poll()?.a }).toEqual(maxExpectPolled[maxI]);
       maxI++;
     }
   });
@@ -62,13 +74,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 +89,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 +101,7 @@ describe('FibonacciHeap', () => {
     expect(heap.size).toBe(0);
   });
 
-  test('clear', () => {
+  it('clear', () => {
     heap.push(10);
     heap.push(5);
     heap.clear();
@@ -97,7 +109,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

@@ -1,14 +1,14 @@
-import {Comparator, MaxHeap} from '../../../../src';
+import { Comparator, MaxHeap } from '../../../../src';
 
 describe('MaxHeap', () => {
   const numberComparator: Comparator<number> = (a, b) => b - a;
   let maxHeap: MaxHeap<number>;
 
   beforeEach(() => {
-    maxHeap = new MaxHeap({comparator: numberComparator});
+    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

@@ -1,14 +1,14 @@
-import {Comparator, MinHeap} from '../../../../src';
+import { Comparator, MinHeap } from '../../../../src';
 
 describe('MinHeap', () => {
   const numberComparator: Comparator<number> = (a, b) => a - b;
   let minHeap: MinHeap<number>;
 
   beforeEach(() => {
-    minHeap = new MinHeap({comparator: numberComparator});
+    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

@@ -1,4 +1,4 @@
-import {DoublyLinkedList, DoublyLinkedListNode} from '../../../../src';
+import { DoublyLinkedList, DoublyLinkedListNode } from '../../../../src';
 
 describe('DoublyLinkedListNode', () => {
   it('should DoublyLinkedListNode', () => {
@@ -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();
@@ -370,9 +370,9 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should insert and manipulate objects with numeric properties', () => {
-    const obj1 = {keyA: 10};
-    const obj2 = {keyA: 20};
-    const obj3 = {keyA: 30};
+    const obj1 = { keyA: 10 };
+    const obj2 = { keyA: 20 };
+    const obj3 = { keyA: 30 };
 
     objectList.push(obj1);
     objectList.push(obj2);
@@ -380,7 +380,7 @@ describe('DoublyLinkedList Operation Test', () => {
 
     expect(objectList.toArray()).toEqual([obj1, obj2, obj3]);
 
-    const newObj = {keyA: 25}; // Corrected newObj value
+    const newObj = { keyA: 25 }; // Corrected newObj value
     const insertSuccess = objectList.insertBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);