data-structure-typed 1.41.6 → 1.41.7

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

@@ -0,0 +1,564 @@
+import {DirectedEdge, DirectedGraph, DirectedVertex, VertexKey} from '../../../../src';
+
+describe('DirectedGraph Operation Test', () => {
+  let graph: DirectedGraph;
+
+  beforeEach(() => {
+    graph = new DirectedGraph();
+  });
+
+  it('should add vertices', () => {
+    const vertex1 = new DirectedVertex('A');
+    const vertex2 = new DirectedVertex('B');
+
+    graph.addVertex(vertex1);
+    graph.addVertex(vertex2);
+
+    expect(graph.hasVertex(vertex1)).toBe(true);
+    expect(graph.hasVertex(vertex2)).toBe(true);
+  });
+
+  it('should add edges', () => {
+    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');
+    graph.createVertex('B');
+    const edge = new DirectedEdge('A', 'B');
+
+    graph.addVertex(vertex1);
+    graph.addVertex('B');
+    graph.addEdge(edge);
+
+    expect(graph.deleteEdge(edge)).toBe(edge);
+    expect(graph.hasEdge('A', 'B')).toBe(false);
+  });
+
+  it('should perform topological sort', () => {
+    const vertexA = new DirectedVertex('A');
+    const vertexB = new DirectedVertex('B');
+    const vertexC = new DirectedVertex('C');
+    const edgeAB = new DirectedEdge('A', 'B');
+    graph.createEdge('B', 'C');
+
+    graph.addVertex(vertexA);
+    graph.addVertex(vertexB);
+    graph.addVertex(vertexC);
+    graph.addEdge(edgeAB);
+    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);
+  });
+});
+
+class MyVertex<V = any> extends DirectedVertex<V> {
+  constructor(key: VertexKey, value?: V) {
+    super(key, value);
+    this._data = value;
+  }
+
+  protected _data: V | undefined;
+
+  get data(): V | undefined {
+    return this._data;
+  }
+
+  set data(value: V | undefined) {
+    this._data = value;
+  }
+}
+
+class MyEdge<E = any> extends DirectedEdge<E> {
+  constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E) {
+    super(v1, v2, weight, value);
+    this._data = value;
+  }
+
+  protected _data: E | undefined;
+
+  get data(): E | undefined {
+    return this._data;
+  }
+
+  set data(value: E | undefined) {
+    this._data = value;
+  }
+}
+
+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;
+  }
+
+  createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO {
+    return new MyEdge(src, dest, weight ?? 1, value) as EO;
+  }
+
+  setInEdgeMap(value: Map<VO, EO[]>) {
+    this._inEdgeMap = value;
+  }
+
+  setOutEdgeMap(value: Map<VO, EO[]>) {
+    this._outEdgeMap = value;
+  }
+}
+
+describe('Inherit from DirectedGraph and perform operations', () => {
+  let myGraph = new MyDirectedGraph<string, string>();
+  beforeEach(() => {
+    myGraph = new MyDirectedGraph();
+  });
+
+  it('Add vertices', () => {
+    myGraph.addVertex(1, 'data1');
+    myGraph.addVertex(2, 'data2');
+    myGraph.addVertex(3, 'data3');
+    myGraph.addVertex(4, 'data4');
+    myGraph.addVertex(5, 'data5');
+    myGraph.addVertex(new MyVertex(6, 'data6'));
+    myGraph.addVertex(new MyVertex(7, 'data7'));
+    myGraph.addVertex(new MyVertex(8, 'data8'));
+    myGraph.addVertex(new MyVertex(9, 'data9'));
+  });
+
+  it('Add edges', () => {
+    myGraph.addVertex(1, 'data1');
+    myGraph.addVertex(2, 'data2');
+    myGraph.addEdge(1, 2, 10, 'edge-data1-2');
+    myGraph.addEdge(new MyEdge(2, 1, 20, 'edge-data2-1'));
+    myGraph.setInEdgeMap(myGraph.inEdgeMap);
+    myGraph.setOutEdgeMap(myGraph.outEdgeMap);
+
+    expect(myGraph.edgeSet().length).toBe(2);
+    // TODO
+    expect(myGraph.getEdge(1, 2)).toBeInstanceOf(MyEdge);
+    expect(myGraph.getEdge(2, 1)).toBeInstanceOf(MyEdge);
+  });
+
+  it('Get edge', () => {
+    myGraph.addVertex(1, 'val1');
+    myGraph.addVertex(2, 'val1');
+    myGraph.addEdge(1, 2, 1, 'val1');
+    const edge1 = myGraph.getEdge(1, 2);
+    const edge2 = myGraph.getEdge(myGraph.getVertex(1), myGraph.getVertex(2));
+    const edge3 = myGraph.getEdge(1, '100');
+    // edge1.data has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
+    expect(edge1).toBeInstanceOf(MyEdge);
+    if (edge1) {
+      expect(edge1.data).toBe('val1');
+      expect(edge1?.value).toBe('val1');
+      expect(edge1).toBeInstanceOf(MyEdge);
+      expect(edge1.src).toBe(1);
+      expect(edge1).toEqual(edge2);
+      expect(edge3).toBeNull();
+    }
+  });
+
+  it('Edge set and vertex set', () => {
+    expect(true).toBeTruthy();
+  });
+
+  it('Remove edge between vertices', () => {
+    myGraph.addVertex(1, 'data1');
+    myGraph.addVertex(2, 'data2');
+    myGraph.addEdge(1, 2, 10, 'edge-data1-2');
+
+    const removedEdge = myGraph.deleteEdgeSrcToDest(1, 2);
+    const edgeAfterRemoval = myGraph.getEdge(1, 2);
+
+    expect(removedEdge).toBeInstanceOf(MyEdge);
+    if (removedEdge) {
+      removedEdge && expect(removedEdge.value).toBe('edge-data1-2');
+      removedEdge && expect(removedEdge.src).toBe(1);
+    }
+    expect(edgeAfterRemoval).toBeNull();
+  });
+
+  it('Topological sort', () => {
+    const sorted = myGraph.topologicalSort();
+
+    expect(sorted).toBeInstanceOf(Array);
+    if (sorted && sorted.length > 0) {
+      expect(sorted.length).toBe(9);
+      if (sorted[0] instanceof MyVertex) expect(sorted[0].data).toBe('data9');
+      sorted[3] instanceof MyVertex && expect(sorted[3].data).toBe('data6');
+      sorted[8] instanceof MyVertex && expect(sorted[8].key).toBe(1);
+    }
+  });
+
+  it('Minimum path between vertices', () => {
+    myGraph.addVertex(new MyVertex(1, 'data1'));
+    myGraph.addVertex(new MyVertex(2, 'data2'));
+    myGraph.addEdge(new MyEdge(1, 2, 10, 'edge-data1-2'));
+  });
+
+  it('All paths between vertices', () => {
+    // Add vertices and edges as needed for this test
+    myGraph.addVertex(new MyVertex(1, 'data1'));
+    myGraph.addVertex(new MyVertex(2, 'data2'));
+    myGraph.addEdge(new MyEdge(1, 2, 10, 'edge-data1-2'));
+
+    // Add expect statements here to verify the allPaths
+  });
+});
+
+describe('Inherit from DirectedGraph and perform operations test2.', () => {
+  const myGraph = new MyDirectedGraph<string, string>();
+
+  it('should test graph operations', () => {
+    const vertex1 = new MyVertex(1, 'data1');
+    const vertex2 = new MyVertex(2, 'data2');
+    const vertex3 = new MyVertex(3, 'data3');
+    const vertex4 = new MyVertex(4, 'data4');
+    const vertex5 = new MyVertex(5, 'data5');
+    const vertex6 = new MyVertex(6, 'data6');
+    const vertex7 = new MyVertex(7, 'data7');
+    const vertex8 = new MyVertex(8, 'data8');
+    const vertex9 = new MyVertex(9, 'data9');
+    myGraph.addVertex(vertex1);
+    myGraph.addVertex(vertex2);
+    myGraph.addVertex(vertex3);
+    myGraph.addVertex(vertex4);
+    myGraph.addVertex(vertex5);
+    myGraph.addVertex(vertex6);
+    myGraph.addVertex(vertex7);
+    myGraph.addVertex(vertex8);
+    myGraph.addVertex(vertex9);
+
+    myGraph.addEdge(new MyEdge(1, 2, 10, 'edge-data1-2'));
+    myGraph.addEdge(new MyEdge(2, 1, 20, 'edge-data2-1'));
+
+    expect(myGraph.getEdge(1, 2)).toBeTruthy();
+    expect(myGraph.getEdge(2, 1)).toBeTruthy();
+    expect(myGraph.getEdge(1, '100')).toBeFalsy();
+
+    myGraph.deleteEdgeSrcToDest(1, 2);
+    expect(myGraph.getEdge(1, 2)).toBeFalsy();
+
+    myGraph.addEdge(3, 1, 3, 'edge-data-3-1');
+
+    myGraph.addEdge(1, 9, 19, 'edge-data1-9');
+
+    myGraph.addEdge(9, 7, 97, 'edge-data9-7');
+
+    myGraph.addEdge(7, 9, 79, 'edge-data7-9');
+
+    myGraph.addEdge(1, 4, 14, 'edge-data1-4');
+
+    myGraph.addEdge(4, 7, 47, 'edge-data4-7');
+
+    myGraph.addEdge(1, 2, 12, 'edge-data1-2');
+
+    myGraph.addEdge(2, 3, 23, 'edge-data2-3');
+
+    myGraph.addEdge(3, 5, 35, 'edge-data3-5');
+
+    myGraph.addEdge(5, 7, 57, 'edge-data5-7');
+
+    myGraph.addEdge(new MyEdge(7, 3, 73, 'edge-data7-3'));
+    const topologicalSorted = myGraph.topologicalSort();
+    expect(topologicalSorted).toBeNull();
+
+    const minPath1to7 = myGraph.getMinPathBetween(1, 7);
+
+    expect(minPath1to7).toBeInstanceOf(Array);
+    if (minPath1to7 && minPath1to7.length > 0) {
+      expect(minPath1to7).toHaveLength(3);
+      expect(minPath1to7[0]).toBeInstanceOf(MyVertex);
+      expect(minPath1to7[0].key).toBe(1);
+      expect(minPath1to7[1].key).toBe(9);
+      expect(minPath1to7[2].key).toBe(7);
+    }
+
+    const fordResult1 = myGraph.bellmanFord(1);
+    expect(fordResult1).toBeTruthy();
+    expect(fordResult1.hasNegativeCycle).toBeUndefined();
+    const {distMap, preMap, paths, min, minPath} = fordResult1;
+    expect(distMap).toBeInstanceOf(Map);
+    expect(distMap.size).toBe(9);
+    expect(distMap.get(vertex1)).toBe(0);
+    expect(distMap.get(vertex2)).toBe(12);
+    expect(distMap.get(vertex3)).toBe(35);
+    expect(distMap.get(vertex4)).toBe(14);
+    expect(distMap.get(vertex5)).toBe(70);
+    expect(distMap.get(vertex6)).toBe(Infinity);
+    expect(distMap.get(vertex7)).toBe(61);
+    expect(distMap.get(vertex8)).toBe(Infinity);
+    expect(distMap.get(vertex9)).toBe(19);
+
+    expect(preMap).toBeInstanceOf(Map);
+    expect(preMap.size).toBe(0);
+
+    expect(paths).toBeInstanceOf(Array);
+    expect(paths.length).toBe(0);
+    expect(min).toBe(Infinity);
+    expect(minPath).toBeInstanceOf(Array);
+
+    const floydResult = myGraph.floyd();
+    expect(floydResult).toBeTruthy();
+    if (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]);
+      expect(costs[1]).toEqual([20, 32, 23, 34, 58, Infinity, 81, Infinity, 39]);
+      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[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[8]).toEqual([173, 185, 170, 187, 205, Infinity, 97, Infinity, 176]);
+
+      expect(predecessor).toBeInstanceOf(Array);
+      expect(predecessor.length).toBe(9);
+      expect(predecessor[0]).toEqual([vertex2, null, vertex2, null, vertex3, null, vertex4, null, null]);
+      expect(predecessor[1]).toEqual([null, vertex1, null, vertex1, vertex3, null, vertex4, null, vertex1]);
+      expect(predecessor[5]).toEqual([null, null, null, null, null, null, null, null, null]);
+      expect(predecessor[7]).toEqual([null, null, null, null, null, null, null, null, null]);
+      expect(predecessor[8]).toEqual([vertex7, vertex7, vertex7, vertex7, vertex7, null, null, null, vertex7]);
+    }
+
+    const dijkstraRes12tt = myGraph.dijkstra(1, 2, true, true);
+
+    expect(dijkstraRes12tt).toBeTruthy();
+    if (dijkstraRes12tt) {
+      const {distMap, minDist, minPath, paths} = dijkstraRes12tt;
+      expect(distMap).toBeInstanceOf(Map);
+      expect(distMap.size).toBe(9);
+      expect(distMap.get(vertex1)).toBe(0);
+      expect(distMap.get(vertex2)).toBe(12);
+      expect(distMap.get(vertex3)).toBe(Infinity);
+      expect(distMap.get(vertex4)).toBe(14);
+      expect(distMap.get(vertex5)).toBe(Infinity);
+      expect(distMap.get(vertex6)).toBe(Infinity);
+      expect(distMap.get(vertex7)).toBe(Infinity);
+      expect(distMap.get(vertex8)).toBe(Infinity);
+      expect(distMap.get(vertex9)).toBe(19);
+
+      expect(minDist).toBe(12);
+      expect(minPath).toBeInstanceOf(Array);
+      expect(minPath.length).toBe(2);
+      expect(minPath[0]).toBe(vertex1);
+      expect(minPath[1]).toBe(vertex2);
+
+      expect(paths).toBeInstanceOf(Array);
+      expect(paths.length).toBe(9);
+      expect(paths[0]).toBeInstanceOf(Array);
+      expect(paths[0][0]).toBe(vertex1);
+
+      expect(paths[1]).toBeInstanceOf(Array);
+      expect(paths[1][0]).toBe(vertex1);
+      expect(paths[1][1]).toBe(vertex2);
+
+      expect(paths[2]).toBeInstanceOf(Array);
+      expect(paths[2][0]).toBe(vertex3);
+      expect(paths[3]).toBeInstanceOf(Array);
+      expect(paths[3][0]).toBe(vertex1);
+      expect(paths[3][1]).toBe(vertex4);
+      expect(paths[4]).toBeInstanceOf(Array);
+      expect(paths[4][0]).toBe(vertex5);
+
+      expect(paths[5]).toBeInstanceOf(Array);
+      expect(paths[5][0]).toBe(vertex6);
+      expect(paths[6]).toBeInstanceOf(Array);
+      expect(paths[6][0]).toBe(vertex7);
+      expect(paths[7]).toBeInstanceOf(Array);
+      expect(paths[7][0]).toBe(vertex8);
+      expect(paths[8]).toBeInstanceOf(Array);
+      expect(paths[8][0]).toBe(vertex1);
+      expect(paths[8][1]).toBe(vertex9);
+    }
+
+    const dijkstraRes1ntt = myGraph.dijkstra(1, null, true, true);
+
+    expect(dijkstraRes1ntt).toBeTruthy();
+    if (dijkstraRes1ntt) {
+      const {distMap, minDist, minPath, paths} = dijkstraRes1ntt;
+      expect(distMap).toBeInstanceOf(Map);
+      expect(distMap.size).toBe(9);
+      expect(distMap.get(vertex1)).toBe(0);
+      expect(distMap.get(vertex2)).toBe(12);
+      expect(distMap.get(vertex3)).toBe(35);
+      expect(distMap.get(vertex4)).toBe(14);
+      expect(distMap.get(vertex5)).toBe(70);
+      expect(distMap.get(vertex6)).toBe(Infinity);
+      expect(distMap.get(vertex7)).toBe(61);
+      expect(distMap.get(vertex8)).toBe(Infinity);
+      expect(distMap.get(vertex9)).toBe(19);
+
+      expect(minDist).toBe(12);
+      expect(minPath).toBeInstanceOf(Array);
+      expect(minPath.length).toBe(2);
+      expect(minPath[0]).toBe(vertex1);
+      expect(minPath[1]).toBe(vertex2);
+
+      expect(paths).toBeInstanceOf(Array);
+      expect(paths.length).toBe(9);
+      expect(paths[0]).toBeInstanceOf(Array);
+      expect(paths[0][0]).toBe(vertex1);
+
+      expect(paths[1]).toBeInstanceOf(Array);
+      expect(paths[1][0]).toBe(vertex1);
+      expect(paths[1][1]).toBe(vertex2);
+
+      expect(paths[2]).toBeInstanceOf(Array);
+      expect(paths[2][0]).toBe(vertex1);
+      expect(paths[2][1]).toBe(vertex2);
+      expect(paths[2][2]).toBe(vertex3);
+
+      expect(paths[3]).toBeInstanceOf(Array);
+      expect(paths[3][0]).toBe(vertex1);
+      expect(paths[3][1]).toBe(vertex4);
+
+      expect(paths[4]).toBeInstanceOf(Array);
+      expect(paths[4][0]).toBe(vertex1);
+      expect(paths[4][1]).toBe(vertex2);
+      expect(paths[4][2]).toBe(vertex3);
+      expect(paths[4][3]).toBe(vertex5);
+
+      expect(paths[5]).toBeInstanceOf(Array);
+      expect(paths[5][0]).toBe(vertex6);
+
+      expect(paths[6]).toBeInstanceOf(Array);
+      expect(paths[6][0]).toBe(vertex1);
+      expect(paths[6][1]).toBe(vertex4);
+      expect(paths[6][2]).toBe(vertex7);
+
+      expect(paths[7]).toBeInstanceOf(Array);
+      expect(paths[7][0]).toBe(vertex8);
+
+      expect(paths[8]).toBeInstanceOf(Array);
+      expect(paths[8][0]).toBe(vertex1);
+      expect(paths[8][1]).toBe(vertex9);
+    }
+
+    const dijkstraWithoutHeapRes1ntt = myGraph.dijkstraWithoutHeap(1, null, true, true);
+    expect(dijkstraWithoutHeapRes1ntt).toBeTruthy();
+    if (dijkstraWithoutHeapRes1ntt) {
+      const {distMap, minDist, minPath, paths} = dijkstraWithoutHeapRes1ntt;
+      expect(distMap).toBeInstanceOf(Map);
+      expect(distMap.size).toBe(9);
+      expect(distMap.get(vertex1)).toBe(0);
+      expect(distMap.get(vertex2)).toBe(12);
+      expect(distMap.get(vertex3)).toBe(35);
+      expect(distMap.get(vertex4)).toBe(14);
+      expect(distMap.get(vertex5)).toBe(70);
+      expect(distMap.get(vertex6)).toBe(Infinity);
+      expect(distMap.get(vertex7)).toBe(61);
+      expect(distMap.get(vertex8)).toBe(Infinity);
+      expect(distMap.get(vertex9)).toBe(19);
+
+      expect(minDist).toBe(12);
+      expect(minPath).toBeInstanceOf(Array);
+      expect(minPath.length).toBe(2);
+      expect(minPath[0]).toBe(vertex1);
+      expect(minPath[1]).toBe(vertex2);
+
+      expect(paths).toBeInstanceOf(Array);
+      expect(paths.length).toBe(9);
+      expect(paths[0]).toBeInstanceOf(Array);
+      expect(paths[0][0]).toBe(vertex1);
+
+      expect(paths[1]).toBeInstanceOf(Array);
+      expect(paths[1][0]).toBe(vertex1);
+      expect(paths[1][1]).toBe(vertex2);
+
+      expect(paths[2]).toBeInstanceOf(Array);
+      expect(paths[2][0]).toBe(vertex1);
+      expect(paths[2][1]).toBe(vertex2);
+      expect(paths[2][2]).toBe(vertex3);
+
+      expect(paths[3]).toBeInstanceOf(Array);
+      expect(paths[3][0]).toBe(vertex1);
+      expect(paths[3][1]).toBe(vertex4);
+
+      expect(paths[4]).toBeInstanceOf(Array);
+      expect(paths[4][0]).toBe(vertex1);
+      expect(paths[4][1]).toBe(vertex2);
+      expect(paths[4][2]).toBe(vertex3);
+      expect(paths[4][3]).toBe(vertex5);
+
+      expect(paths[5]).toBeInstanceOf(Array);
+      expect(paths[5][0]).toBe(vertex6);
+
+      expect(paths[6]).toBeInstanceOf(Array);
+      expect(paths[6][0]).toBe(vertex1);
+      expect(paths[6][1]).toBe(vertex4);
+      expect(paths[6][2]).toBe(vertex7);
+
+      expect(paths[7]).toBeInstanceOf(Array);
+      expect(paths[7][0]).toBe(vertex8);
+
+      expect(paths[8]).toBeInstanceOf(Array);
+      expect(paths[8][0]).toBe(vertex1);
+      expect(paths[8][1]).toBe(vertex9);
+    }
+  });
+});

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

@@ -0,0 +1,126 @@
+import {MapEdge, MapGraph, MapVertex} from '../../../../src';
+
+describe('MapGraph Operation Test', () => {
+  it('dijkstra shortest path', () => {
+    const mapGraph = new MapGraph([5.500338, 100.173665]);
+
+    mapGraph.addVertex(new MapVertex('Surin', '', 5.466724, 100.274805));
+    mapGraph.addVertex(new MapVertex('Batu Feringgi Beach', '', 5.475141, 100.27667));
+    mapGraph.addVertex(new MapVertex('Lotus', '', 5.459044, 100.308767));
+    mapGraph.addVertex(new MapVertex('The Breeza', '', 5.454197, 100.307859));
+    mapGraph.addVertex(new MapVertex('Hard Rock Hotel', '', 5.46785, 100.241876));
+    mapGraph.addVertex(new MapVertex('Mira', '', 5.456749, 100.28665));
+    mapGraph.addVertex(new MapVertex('Penang Bible Church', '', 5.428683, 100.314825));
+    mapGraph.addVertex(new MapVertex('Queensbay', '', 5.33276, 100.306651));
+    mapGraph.addVertex(new MapVertex('Saanen Goat Farm', '', 5.405738, 100.207699));
+    mapGraph.addVertex(new MapVertex('Trinity Auto', '', 5.401126, 100.303739));
+    mapGraph.addVertex(new MapVertex('Penang Airport', '', 5.293185, 100.265772));
+    mapGraph.addEdge('Surin', 'Lotus', 4.7);
+    mapGraph.addEdge('Lotus', 'The Breeza', 1);
+    mapGraph.addEdge('Batu Feringgi Beach', 'Hard Rock Hotel', 5.2);
+    mapGraph.addEdge('Surin', 'Mira', 2.8);
+    mapGraph.addEdge('Mira', 'Penang Bible Church', 7.0);
+    mapGraph.addEdge('Lotus', 'Penang Bible Church', 5.7);
+    mapGraph.addEdge('Penang Bible Church', 'Queensbay', 13.9);
+    mapGraph.addEdge('Hard Rock Hotel', 'Saanen Goat Farm', 18.5);
+    mapGraph.addEdge('The Breeza', 'Trinity Auto', 9.1);
+    mapGraph.addEdge('Trinity Auto', 'Saanen Goat Farm', 26.3);
+    mapGraph.addEdge('The Breeza', 'Penang Airport', 24.8);
+    mapGraph.addEdge('Penang Airport', 'Saanen Goat Farm', 21.2);
+    const expected1 = ['Surin', 'Lotus', 'The Breeza', 'Trinity Auto', 'Saanen Goat Farm'];
+
+    const minPathBetween = mapGraph.getMinPathBetween('Surin', 'Saanen Goat Farm');
+    expect(minPathBetween?.map(v => v.key)).toEqual(expected1);
+    const surinToSaanenGoatFarmDij = mapGraph.dijkstra('Surin', 'Saanen Goat Farm', true, true);
+    expect(surinToSaanenGoatFarmDij?.minPath.map(v => v.key)).toEqual(expected1);
+    expect(surinToSaanenGoatFarmDij?.minDist).toBe(41.1);
+    mapGraph.addEdge('Surin', 'Batu Feringgi Beach', 1.5);
+    const expected2 = ['Surin', 'Batu Feringgi Beach', 'Hard Rock Hotel', 'Saanen Goat Farm'];
+    const minPathBetweenViaBFB = mapGraph.getMinPathBetween('Surin', 'Saanen Goat Farm', true);
+    expect(minPathBetweenViaBFB?.map(v => v.key)).toEqual(expected2);
+    const surinToSaanenGoatFarmViaDij = mapGraph.dijkstra('Surin', 'Saanen Goat Farm', true, true);
+    expect(surinToSaanenGoatFarmViaDij?.minPath.map(v => v.key)).toEqual(expected2);
+    expect(surinToSaanenGoatFarmViaDij?.minDist).toBe(25.2);
+  });
+});
+
+describe('MapGraph', () => {
+  let mapGraph: MapGraph<string, string>;
+
+  beforeEach(() => {
+    // Create a new MapGraph instance before each test
+    mapGraph = new MapGraph<string, string>([0, 0], [100, 100]);
+  });
+
+  // Test adding vertices to the graph
+  it('should add vertices to the graph', () => {
+    const locationA = new MapVertex('A', 'Location A', 10, 20);
+    const locationB = new MapVertex('B', 'Location B', 30, 40);
+
+    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', 'Location A', 10, 20);
+    const locationB = new MapVertex('B', 'Location B', 30, 40);
+    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', 'Location A', 10, 20);
+    locationA.lat = locationA.lat;
+    locationA.long = locationA.long;
+    const locationB = mapGraph.createVertex('B', 'Location B', 30, 40);
+
+    const locationC = new MapVertex('C', 'Location C', 50, 60);
+    const edgeAB = new MapEdge('A', 'B', 50, 'Edge from A to B');
+    const edgeBC = new MapEdge('B', 'C', 60, 'Edge from B to C');
+
+    expect(mapGraph.origin).toEqual([0, 0]);
+    expect(mapGraph.bottomRight).toEqual([100, 100]);
+
+    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', 'Location A', 10, 20);
+    const locationB = new MapVertex('B', 'Location B', 30, 40);
+    const locationC = new MapVertex('C', 'Location C', 50, 60);
+    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);
+  });
+});