data-structure-typed 1.39.0 → 1.39.1

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

@@ -1,7 +1,8 @@
-import {CP, TreeMultiset, TreeMultisetNode} from '../../../../src';
+import {CP, IterationType, TreeMultiset, TreeMultisetNode} from '../../../../src';
 import {isDebugTest} from '../../../config';
 
 const isDebug = isDebugTest;
+
 describe('TreeMultiset operations test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
     const treeMultiset = new TreeMultiset();
@@ -206,7 +207,7 @@ describe('TreeMultiset operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultiset = new TreeMultiset<{ key: number; keyA: number }>();
+    const objTreeMultiset = new TreeMultiset<{key: number; keyA: number}>();
     expect(objTreeMultiset).toBeInstanceOf(TreeMultiset);
     objTreeMultiset.add(11, {key: 11, keyA: 11});
     objTreeMultiset.add(3, {key: 3, keyA: 3});
@@ -239,196 +240,250 @@ describe('TreeMultiset operations test', () => {
     expect(objTreeMultiset.count).toBe(16);
 
     expect(objTreeMultiset.has(6)).toBe(true);
+  });
+});
 
-    // const node6 = objTreeMultiset.get(6);
-    // expect(node6 && objTreeMultiset.getHeight(node6)).toBe(2);
-    // expect(node6 && objTreeMultiset.getDepth(node6)).toBe(3);
-    //
-    // const nodeId10 = objTreeMultiset.get(10, 'key');
-    // expect(nodeId10?.key).toBe(10);
-    //
-    // const nodeVal9 = objTreeMultiset.get(9, 'key');
-    // expect(nodeVal9?.key).toBe(9);
-    //
-    // const nodesByCount1 = objTreeMultiset.getNodesByCount(1);
-    // expect(nodesByCount1.length).toBe(16);
-    //
-    // const leftMost = objTreeMultiset.getLeftMost();
-    // expect(leftMost?.key).toBe(1);
-    //
-    // const node15 = objTreeMultiset.get(15);
-    // expect(node15?.val).toEqual({key: 15, keyA: 15});
-    // const minNodeBySpecificNode = node15 && objTreeMultiset.getLeftMost(node15);
-    // expect(minNodeBySpecificNode?.key).toBe(12);
-    //
-    // const subTreeSum = node15 && objTreeMultiset.subTreeSum(node15);
-    // expect(subTreeSum).toBe(70);
-    //
-    // const lesserSum = objTreeMultiset.lesserSum(10);
-    // expect(lesserSum).toBe(45);
-    //
-    // expect(node15).toBeInstanceOf(TreeMultisetNode);
-    // if (node15 instanceof TreeMultisetNode) {
-    //     const subTreeAdd = objTreeMultiset.subTreeAddCount(node15, 1);
-    //     expect(subTreeAdd).toBeDefined();
-    // }
-    //
-    // const node11 = objTreeMultiset.get(11);
-    // expect(node11).toBeInstanceOf(TreeMultisetNode);
-    // if (node11 instanceof TreeMultisetNode) {
-    //     const allGreaterNodesAdded = objTreeMultiset.allGreaterNodesAddCount(node11, 2);
-    //     expect(allGreaterNodesAdded).toBeDefined();
-    // }
-    //
-    // const dfsInorderNodes = objTreeMultiset.dfs(node => node, 'in');
-    // expect(dfsInorderNodes[0].key).toBe(1);
-    // expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
-    //
-    // objTreeMultiset.perfectlyBalance();
-    // expect(objTreeMultiset.isPerfectlyBalanced()).toBe(true);
-    //
-    // const bfsNodesAfterBalanced = objTreeMultiset.bfs('node');
-    // expect(bfsNodesAfterBalanced[0].key).toBe(8);
-    // expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
-    //
-    // const removed11 = objTreeMultiset.delete(11, true);
-    // expect(removed11).toBeInstanceOf(Array);
-    // expect(removed11[0]).toBeDefined();
-    // expect(removed11[0].deleted).toBeDefined();
-    //
-    // if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
-    //
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
-    //
-    // expect(node15 && objTreeMultiset.getHeight(node15)).toBe(2);
-    //
-    // const removed1 = objTreeMultiset.delete(1, true);
-    // expect(removed1).toBeInstanceOf(Array);
-    // expect(removed1[0]).toBeDefined();
-    // expect(removed1[0].deleted).toBeDefined();
-    // if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
-    //
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
-    //
-    // expect(objTreeMultiset.getHeight()).toBe(4);
-    //
-    // const removed4 = objTreeMultiset.delete(4, true);
-    // expect(removed4).toBeInstanceOf(Array);
-    // expect(removed4[0]).toBeDefined();
-    // expect(removed4[0].deleted).toBeDefined();
-    // if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
-    // expect(objTreeMultiset.getHeight()).toBe(4);
-    //
-    // const removed10 = objTreeMultiset.delete(10, true);
-    // expect(removed10).toBeInstanceOf(Array);
-    // expect(removed10[0]).toBeDefined();
-    // expect(removed10[0].deleted).toBeDefined();
-    // if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
-    // expect(objTreeMultiset.getHeight()).toBe(4);
-    //
-    // const removed15 = objTreeMultiset.delete(15, true);
-    // expect(removed15).toBeInstanceOf(Array);
-    // expect(removed15[0]).toBeDefined();
-    // expect(removed15[0].deleted).toBeDefined();
-    // if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
-    //
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
-    // expect(objTreeMultiset.getHeight()).toBe(3);
-    //
-    // const removed5 = objTreeMultiset.delete(5, true);
-    // expect(removed5).toBeInstanceOf(Array);
-    // expect(removed5[0]).toBeDefined();
-    // expect(removed5[0].deleted).toBeDefined();
-    // if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
-    //
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
-    // expect(objTreeMultiset.getHeight()).toBe(3);
-    //
-    // const removed13 = objTreeMultiset.delete(13, true);
-    // expect(removed13).toBeInstanceOf(Array);
-    // expect(removed13[0]).toBeDefined();
-    // expect(removed13[0].deleted).toBeDefined();
-    // if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
-    // expect(objTreeMultiset.getHeight()).toBe(3);
-    //
-    // const removed3 = objTreeMultiset.delete(3, true);
-    // expect(removed3).toBeInstanceOf(Array);
-    // expect(removed3[0]).toBeDefined();
-    // expect(removed3[0].deleted).toBeDefined();
-    // if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
-    // expect(objTreeMultiset.getHeight()).toBe(3);
-    //
-    // const removed8 = objTreeMultiset.delete(8, true);
-    // expect(removed8).toBeInstanceOf(Array);
-    // expect(removed8[0]).toBeDefined();
-    // expect(removed8[0].deleted).toBeDefined();
-    // if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(true);
-    // expect(objTreeMultiset.getHeight()).toBe(3);
-    //
-    // const removed6 = objTreeMultiset.delete(6, true);
-    // expect(removed6).toBeInstanceOf(Array);
-    // expect(removed6[0]).toBeDefined();
-    // expect(removed6[0].deleted).toBeDefined();
-    // if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
-    // expect(objTreeMultiset.delete(6, true).length).toBe(0);
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
-    // expect(objTreeMultiset.getHeight()).toBe(3);
-    //
-    // const removed7 = objTreeMultiset.delete(7, true);
-    // expect(removed7).toBeInstanceOf(Array);
-    // expect(removed7[0]).toBeDefined();
-    // expect(removed7[0].deleted).toBeDefined();
-    // if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
-    // expect(objTreeMultiset.getHeight()).toBe(3);
-    //
-    // const removed9 = objTreeMultiset.delete(9, true);
-    // expect(removed9).toBeInstanceOf(Array);
-    // expect(removed9[0]).toBeDefined();
-    // expect(removed9[0].deleted).toBeDefined();
-    // if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
-    // expect(objTreeMultiset.getHeight()).toBe(3);
-    //
-    // const removed14 = objTreeMultiset.delete(14, true);
-    // expect(removed14).toBeInstanceOf(Array);
-    // expect(removed14[0]).toBeDefined();
-    // expect(removed14[0].deleted).toBeDefined();
-    // if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
-    // expect(objTreeMultiset.getHeight()).toBe(2);
-    //
-    //
-    // expect(objTreeMultiset.isAVLBalanced()).toBe(false);
-    //
-    // const bfsIDs = objTreeMultiset.bfs();
-    // expect(bfsIDs[0]).toBe(2);
-    // expect(bfsIDs[1]).toBe(12);
-    // expect(bfsIDs[2]).toBe(16);
-    //
-    // const bfsNodes = objTreeMultiset.bfs('node');
-    // expect(bfsNodes[0].key).toBe(2);
-    // expect(bfsNodes[1].key).toBe(12);
-    // expect(bfsNodes[2].key).toBe(16);
-    //
-    // expect(objTreeMultiset.count).toBe(5);
+describe('TreeMultiset operations test recursively', () => {
+  it('should perform various operations on a Binary Search Tree with numeric values', () => {
+    const treeMultiset = new TreeMultiset({iterationType: IterationType.RECURSIVE});
+
+    expect(treeMultiset instanceof TreeMultiset);
+    treeMultiset.add(11, 11);
+    treeMultiset.add(3, 3);
+    const idAndValues = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    treeMultiset.addMany(idAndValues, idAndValues);
+    expect(treeMultiset.root instanceof TreeMultisetNode);
+
+    if (treeMultiset.root) expect(treeMultiset.root.key == 11);
+
+    expect(treeMultiset.size).toBe(16);
+    expect(treeMultiset.count).toBe(18);
+
+    expect(treeMultiset.has(6));
+
+    expect(treeMultiset.getHeight(6)).toBe(3);
+    expect(treeMultiset.getDepth(6)).toBe(1);
+    const nodeId10 = treeMultiset.get(10);
+    expect(nodeId10?.key).toBe(10);
+
+    const nodeVal9 = treeMultiset.get(9, node => node.val);
+    expect(nodeVal9?.key).toBe(9);
+
+    const nodesByCount1 = treeMultiset.getNodes(1, node => node.count);
+    expect(nodesByCount1.length).toBe(14);
+
+    const nodesByCount2 = treeMultiset.getNodes(2, node => node.count);
+    expect(nodesByCount2.length).toBe(2);
+    const leftMost = treeMultiset.getLeftMost();
+    expect(leftMost?.key).toBe(1);
+
+    const node15 = treeMultiset.get(15);
+    const minNodeBySpecificNode = node15 && treeMultiset.getLeftMost(node15);
+    expect(minNodeBySpecificNode?.key).toBe(12);
+
+    let subTreeSum = 0;
+    node15 && treeMultiset.subTreeTraverse((node: TreeMultisetNode<number>) => (subTreeSum += node.key), 15);
+    expect(subTreeSum).toBe(70);
+    let lesserSum = 0;
+    treeMultiset.lesserOrGreaterTraverse((node: TreeMultisetNode<number>) => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
+
+    expect(node15 instanceof TreeMultisetNode);
+    if (node15 instanceof TreeMultisetNode) {
+      const subTreeAdd = treeMultiset.subTreeTraverse((node: TreeMultisetNode<number>) => (node.count += 1), 15);
+      expect(subTreeAdd);
+    }
+    const node11 = treeMultiset.get(11);
+    expect(node11 instanceof TreeMultisetNode);
+    if (node11 instanceof TreeMultisetNode) {
+      const allGreaterNodesAdded = treeMultiset.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
+      expect(allGreaterNodesAdded);
+    }
+
+    const dfsInorderNodes = treeMultiset.dfs(node => node, 'in');
+    expect(dfsInorderNodes[0].key).toBe(1);
+    expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
+    expect(treeMultiset.isPerfectlyBalanced()).toBe(false);
+
+    treeMultiset.perfectlyBalance();
+
+    expect(treeMultiset.isPerfectlyBalanced()).toBe(true);
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+
+    const bfsNodesAfterBalanced = treeMultiset.bfs(node => node);
+    expect(bfsNodesAfterBalanced[0].key).toBe(8);
+    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
+
+    const removed11 = treeMultiset.delete(11, undefined, true);
+    expect(removed11 instanceof Array);
+    expect(removed11[0]);
+    expect(removed11[0].deleted);
+
+    if (removed11[0].deleted) expect(removed11[0].deleted.key).toBe(11);
+
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+
+    expect(treeMultiset.getHeight(15)).toBe(1);
+
+    const removed1 = treeMultiset.delete(1, undefined, true);
+    expect(removed1 instanceof Array);
+    expect(removed1[0]);
+    expect(removed1[0].deleted);
+    if (removed1[0].deleted) expect(removed1[0].deleted.key).toBe(1);
+
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+
+    expect(treeMultiset.getHeight()).toBe(4);
+
+    const removed4 = treeMultiset.delete(4, undefined, true);
+    expect(removed4 instanceof Array);
+    expect(removed4[0]);
+    expect(removed4[0].deleted);
+    if (removed4[0].deleted) expect(removed4[0].deleted.key).toBe(4);
+
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+    expect(treeMultiset.getHeight()).toBe(4);
+
+    const removed10 = treeMultiset.delete(10, undefined, true);
+    expect(removed10 instanceof Array);
+    expect(removed10[0]);
+    expect(removed10[0].deleted);
+    if (removed10[0].deleted) expect(removed10[0].deleted.key).toBe(10);
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+
+    expect(treeMultiset.getHeight()).toBe(3);
+
+    const removed15 = treeMultiset.delete(15, undefined, true);
+    expect(removed15 instanceof Array);
+    expect(removed15[0]);
+    expect(removed15[0].deleted);
+    if (removed15[0].deleted) expect(removed15[0].deleted.key).toBe(15);
+
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+    expect(treeMultiset.getHeight()).toBe(3);
+
+    const removed5 = treeMultiset.delete(5, undefined, true);
+    expect(removed5 instanceof Array);
+    expect(removed5[0]);
+    expect(removed5[0].deleted);
+    if (removed5[0].deleted) expect(removed5[0].deleted.key).toBe(5);
+
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+    expect(treeMultiset.getHeight()).toBe(3);
+
+    const removed13 = treeMultiset.delete(13, undefined, true);
+    expect(removed13 instanceof Array);
+    expect(removed13[0]);
+    expect(removed13[0].deleted);
+    if (removed13[0].deleted) expect(removed13[0].deleted.key).toBe(13);
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+    expect(treeMultiset.getHeight()).toBe(3);
+
+    const removed3 = treeMultiset.delete(3, undefined, true);
+    expect(removed3 instanceof Array);
+    expect(removed3[0]);
+    expect(removed3[0].deleted);
+    if (removed3[0].deleted) expect(removed3[0].deleted.key).toBe(3);
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+    expect(treeMultiset.getHeight()).toBe(3);
+
+    const removed8 = treeMultiset.delete(8, undefined, true);
+    expect(removed8 instanceof Array);
+    expect(removed8[0]);
+    expect(removed8[0].deleted);
+    if (removed8[0].deleted) expect(removed8[0].deleted.key).toBe(8);
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+    expect(treeMultiset.getHeight()).toBe(3);
+
+    const removed6 = treeMultiset.delete(6, undefined, true);
+    expect(removed6 instanceof Array);
+    expect(removed6[0]);
+    expect(removed6[0].deleted);
+    if (removed6[0].deleted) expect(removed6[0].deleted.key).toBe(6);
+    expect(treeMultiset.delete(6, undefined, true).length).toBe(0);
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+
+    expect(treeMultiset.getHeight()).toBe(2);
+
+    const removed7 = treeMultiset.delete(7, undefined, true);
+    expect(removed7 instanceof Array);
+    expect(removed7[0]);
+    expect(removed7[0].deleted);
+    if (removed7[0].deleted) expect(removed7[0].deleted.key).toBe(7);
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+    expect(treeMultiset.getHeight()).toBe(2);
+
+    const removed9 = treeMultiset.delete(9, undefined, true);
+    expect(removed9 instanceof Array);
+    expect(removed9[0]);
+    expect(removed9[0].deleted);
+    if (removed9[0].deleted) expect(removed9[0].deleted.key).toBe(9);
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+    expect(treeMultiset.getHeight()).toBe(2);
+
+    const removed14 = treeMultiset.delete(14, undefined, true);
+    expect(removed14 instanceof Array);
+    expect(removed14[0]);
+    expect(removed14[0].deleted);
+    if (removed14[0].deleted) expect(removed14[0].deleted.key).toBe(14);
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+    expect(treeMultiset.getHeight()).toBe(1);
+
+    expect(treeMultiset.isAVLBalanced()).toBe(true);
+
+    const bfsIDs = treeMultiset.bfs(node => node.key);
+
+    expect(bfsIDs[0]).toBe(12);
+    expect(bfsIDs[1]).toBe(2);
+    expect(bfsIDs[2]).toBe(16);
+
+    const bfsNodes = treeMultiset.bfs(node => node);
+
+    expect(bfsNodes[0].key).toBe(12);
+    expect(bfsNodes[1].key).toBe(2);
+    expect(bfsNodes[2].key).toBe(16);
+
+    expect(treeMultiset.count).toBe(9);
+  });
+
+  it('should perform various operations on a Binary Search Tree with object values', () => {
+    const objTreeMultiset = new TreeMultiset<{key: number; keyA: number}>();
+    expect(objTreeMultiset).toBeInstanceOf(TreeMultiset);
+    objTreeMultiset.add(11, {key: 11, keyA: 11});
+    objTreeMultiset.add(3, {key: 3, keyA: 3});
+    const values = [
+      {key: 15, keyA: 15},
+      {key: 1, keyA: 1},
+      {key: 8, keyA: 8},
+      {key: 13, keyA: 13},
+      {key: 16, keyA: 16},
+      {key: 2, keyA: 2},
+      {key: 6, keyA: 6},
+      {key: 9, keyA: 9},
+      {key: 12, keyA: 12},
+      {key: 14, keyA: 14},
+      {key: 4, keyA: 4},
+      {key: 7, keyA: 7},
+      {key: 10, keyA: 10},
+      {key: 5, keyA: 5}
+    ];
+
+    objTreeMultiset.addMany(
+      values.map(item => item.key),
+      values
+    );
+
+    expect(objTreeMultiset.root).toBeInstanceOf(TreeMultisetNode);
+
+    if (objTreeMultiset.root) expect(objTreeMultiset.root.key).toBe(11);
+
+    expect(objTreeMultiset.count).toBe(16);
+
+    expect(objTreeMultiset.has(6)).toBe(true);
   });
 });
 
 describe('TreeMultiset Performance test', function () {
-  // const treeMS = new TreeMultiset<TreeMultisetNode<number>>();
-  // const inputSize = [100]; // Adjust input sizes as needed
-  //
-  // // Define a function to calculate the expected O(n log n) time
-  // function expectedTime(n: number): number {
-  //   return n * Math.log(n);
-  // }
-
   const treeMS = new TreeMultiset<TreeMultisetNode<number>>();
   const inputSize = 100000; // Adjust input sizes as needed
 

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

@@ -22,22 +22,27 @@ describe('DirectedGraph Operation Test', () => {
     const vertex1 = new DirectedVertex('A');
     const vertex2 = new DirectedVertex('B');
     const edge = new DirectedEdge('A', 'B');
+    edge.src = edge.src;
+    edge.dest = edge.dest;
 
     graph.addVertex(vertex1);
     graph.addVertex(vertex2);
     graph.addEdge(edge);
 
+    expect(graph.outEdgeMap.size).toBe(1);
+    expect(graph.inEdgeMap.size).toBe(1);
     expect(graph.hasEdge('A', 'B')).toBe(true);
     expect(graph.hasEdge('B', 'A')).toBe(false);
   });
 
   it('should delete edges', () => {
     const vertex1 = new DirectedVertex('A');
-    const vertex2 = new DirectedVertex('B');
+    // const vertex2 = new DirectedVertex('B');
+    graph.createVertex('B');
     const edge = new DirectedEdge('A', 'B');
 
     graph.addVertex(vertex1);
-    graph.addVertex(vertex2);
+    graph.addVertex('B');
     graph.addEdge(edge);
 
     expect(graph.deleteEdge(edge)).toBe(edge);
@@ -49,16 +54,41 @@ describe('DirectedGraph Operation Test', () => {
     const vertexB = new DirectedVertex('B');
     const vertexC = new DirectedVertex('C');
     const edgeAB = new DirectedEdge('A', 'B');
-    const edgeBC = new DirectedEdge('B', 'C');
+    graph.createEdge('B', 'C');
 
     graph.addVertex(vertexA);
     graph.addVertex(vertexB);
     graph.addVertex(vertexC);
     graph.addEdge(edgeAB);
-    graph.addEdge(edgeBC);
+    graph.addEdge('B', 'C');
+
+    expect(graph.getEdgeSrc(edgeAB)).toBe(vertexA);
 
     const topologicalOrder = graph.topologicalSort();
     if (topologicalOrder) expect(topologicalOrder).toEqual(['A', 'B', 'C']);
+
+    graph.deleteEdgesBetween('A', 'B');
+
+    const topologicalOrder1 = graph.topologicalSort();
+    if (topologicalOrder1) expect(topologicalOrder1).toEqual(['B', 'C', 'A']);
+
+    expect(graph.incomingEdgesOf(vertexC)?.length).toBe(1);
+    expect(graph.degreeOf(vertexA)).toBe(0);
+    expect(graph.inDegreeOf(vertexC)).toBe(1);
+    expect(graph.outDegreeOf(vertexC)).toBe(0);
+    expect(graph.edgesOf(vertexC)?.length).toBe(1);
+
+    expect(graph.tarjan(true, true, true, true)?.dfnMap.size).toBe(3);
+    expect(graph.bellmanFord(vertexC, true, true, true)?.paths.length).toBe(3);
+    expect(graph.getMinPathBetween('B', 'C', true)?.length).toBe(2);
+    expect(graph.setEdgeWeight('B', 'C', 100)).toBe(true);
+    expect(graph.getMinCostBetween('B', 'C', true)).toBe(100);
+    expect(graph.getMinCostBetween('B', 'C')).toBe(1);
+    expect(graph.getAllPathsBetween('B', 'C')?.length).toBe(1);
+    expect(graph.deleteVertex(vertexB)).toBe(true);
+    expect(graph.getAllPathsBetween('B', 'C')?.length).toBe(0);
+
+    expect(graph.removeManyVertices([vertexB, vertexC])).toBe(true);
   });
 });
 

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

@@ -1,4 +1,4 @@
-import {MapGraph, MapVertex} from '../../../../src';
+import {MapEdge, MapGraph, MapVertex} from '../../../../src';
 
 describe('MapGraph Operation Test', () => {
   it('dijkstra shortest path', () => {
@@ -43,3 +43,84 @@ describe('MapGraph Operation Test', () => {
     expect(surinToSaanenGoatFarmViaDij?.minDist).toBe(25.2);
   });
 });
+
+describe('MapGraph', () => {
+  let mapGraph: MapGraph;
+
+  beforeEach(() => {
+    // Create a new MapGraph instance before each test
+    mapGraph = new MapGraph([0, 0], [100, 100]);
+  });
+
+  // Test adding vertices to the graph
+  it('should add vertices to the graph', () => {
+    const locationA = new MapVertex('A', 10, 20, 'Location A');
+    const locationB = new MapVertex('B', 30, 40, 'Location B');
+
+    mapGraph.addVertex(locationA);
+    mapGraph.addVertex(locationB);
+
+    expect(mapGraph.hasVertex('A')).toBe(true);
+    expect(mapGraph.hasVertex('B')).toBe(true);
+  });
+
+  // Test adding edges to the graph
+  it('should add edges to the graph', () => {
+    const locationA = new MapVertex('A', 10, 20, 'Location A');
+    const locationB = new MapVertex('B', 30, 40, 'Location B');
+    const edgeAB = new MapEdge('A', 'B', 50, 'Edge from A to B');
+
+    mapGraph.addVertex(locationA);
+    mapGraph.addVertex(locationB);
+    mapGraph.addEdge(edgeAB);
+
+    expect(mapGraph.hasEdge('A', 'B')).toBe(true);
+  });
+
+  // Test getting neighbors of a vertex
+  it('should return the neighbors of a vertex', () => {
+    const locationA = new MapVertex('A', 10, 20, 'Location A');
+    locationA.lat = locationA.lat;
+    locationA.long = locationA.long;
+    const locationB = mapGraph.createVertex('B', 30, 40, 'Location B');
+
+    const locationC = new MapVertex('C', 50, 60, 'Location C');
+    const edgeAB = new MapEdge('A', 'B', 50, 'Edge from A to B');
+    const edgeBC = new MapEdge('B', 'C', 60, 'Edge from B to C');
+
+    mapGraph.origin = mapGraph.origin;
+    mapGraph.bottomRight = mapGraph.bottomRight;
+
+    mapGraph.addVertex(locationA);
+    mapGraph.addVertex(locationB);
+    mapGraph.addVertex(locationC);
+    mapGraph.addEdge(edgeAB);
+    mapGraph.addEdge(edgeBC);
+
+    const neighborsOfA = mapGraph.getNeighbors('A');
+    const neighborsOfB = mapGraph.getNeighbors('B');
+
+    expect(neighborsOfA).toEqual([locationB]);
+    expect(neighborsOfB).toEqual([locationC]);
+  });
+
+  // Test finding the shortest path between locations
+  it('should find the shortest path between two locations', () => {
+    const locationA = new MapVertex('A', 10, 20, 'Location A');
+    const locationB = new MapVertex('B', 30, 40, 'Location B');
+    const locationC = new MapVertex('C', 50, 60, 'Location C');
+    const edgeAB = new MapEdge('A', 'B', 50, 'Edge from A to B');
+    const edgeBC = new MapEdge('B', 'C', 60, 'Edge from B to C');
+
+    mapGraph.addVertex(locationA);
+    mapGraph.addVertex(locationB);
+    mapGraph.addVertex(locationC);
+    mapGraph.addEdge(edgeAB);
+    mapGraph.addEdge(edgeBC);
+
+    const shortestPath = mapGraph.dijkstra('A', 'C');
+
+    expect(shortestPath?.minPath.length).toEqual(0);
+    expect(shortestPath?.distMap.size).toBe(3);
+  });
+});