data-structure-typed 1.40.0-rc → 1.41.0

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

@@ -1,5 +1,100 @@
+import {AbstractEdge, AbstractGraph, AbstractVertex, VertexKey} from '../../../../src';
+
+class MyVertex<V = any> extends AbstractVertex<V> {
+  data?: V;
+
+  constructor(key: VertexKey, value?: V) {
+    super(key, value);
+    this.data = value;
+  }
+}
+
+class MyEdge<E = any> extends AbstractEdge<E> {
+  data?: E;
+  src: VertexKey;
+  dest: VertexKey;
+
+  constructor(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E) {
+    super(weight, value);
+    this.src = srcOrV1;
+    this.dest = destOrV2;
+    this.data = value;
+  }
+}
+
+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;
+  }
+
+  createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO {
+    return new MyEdge(srcOrV1, destOrV2, weight, value) as EO;
+  }
+
+  deleteEdge(edge: EO): EO | null {
+    return edge;
+  }
+
+  getEdge(srcOrKey: VertexKey, destOrKey: VertexKey): EO | null {
+    return new MyEdge(srcOrKey, destOrKey) as EO;
+  }
+
+  degreeOf(vertexOrKey: VO | VertexKey): number {
+    return 1 ?? Number(vertexOrKey);
+  }
+
+  edgeSet(): EO[] {
+    return [new MyEdge('a', 'b') as EO];
+  }
+
+  edgesOf(vertexOrKey: VO | VertexKey): EO[] {
+    const a = typeof vertexOrKey === 'string' ? vertexOrKey : 'a';
+    return [new MyEdge(a, 'b') as EO];
+  }
+
+  getNeighbors(vertexOrKey: VO | VertexKey): VO[] {
+    const a = typeof vertexOrKey === 'string' ? vertexOrKey : 'a';
+    return [new MyVertex(a, 'b') as VO];
+  }
+
+  getEndsOfEdge(edge: EO): [VO, VO] | null {
+    return edge ? null : null;
+  }
+
+  protected _addEdgeOnly(edge: EO): boolean {
+    return edge ? true : true;
+  }
+}
+
 describe('AbstractGraph Operation Test', () => {
-  it('should xxx', function () {
-    expect(true).toBe(true);
+  const myGraph: MyGraph<number, string> = new MyGraph<number, string>();
+
+  beforeEach(() => {});
+  it('should edge cases', function () {
+    myGraph.addVertex('A', 1);
+    myGraph.addVertex('B', 2);
+    myGraph.addVertex('C', 3);
+    myGraph.addVertex('D', 4);
+
+    const vA = myGraph.getVertex('A');
+    // const vB = myGraph.getVertex('B');
+    // const vC = myGraph.getVertex('C');
+    // const vD = myGraph.getVertex('D');
+
+    const eAB = new MyEdge('A', 'B');
+    // const eBC = new MyEdge('B', 'C');
+    // const eCD = new MyEdge('C', 'D');
+    vA!.key = vA?.key || 1;
+    vA!.value = vA?.value ?? 2;
+
+    eAB!.value = eAB.value;
+    const hs = eAB.hashCode;
+
+    expect(hs.length).toBe(36);
   });
 });

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

@@ -22,25 +22,30 @@ 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 remove edges', () => {
+  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.removeEdge(edge)).toBe(edge);
+    expect(graph.deleteEdge(edge)).toBe(edge);
     expect(graph.hasEdge('A', 'B')).toBe(false);
   });
 
@@ -49,65 +54,103 @@ 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);
   });
 });
 
-class MyVertex<V extends string> extends DirectedVertex<V> {
-  constructor(key: VertexKey, val?: V) {
-    super(key, val);
-    this._data = val;
+class MyVertex<V = any> extends DirectedVertex<V> {
+  constructor(key: VertexKey, value?: V) {
+    super(key, value);
+    this._data = value;
   }
 
-  private _data: string | undefined;
+  protected _data: V | undefined;
 
-  get data(): string | undefined {
+  get data(): V | undefined {
     return this._data;
   }
 
-  set data(value: string | undefined) {
+  set data(value: V | undefined) {
     this._data = value;
   }
 }
 
-class MyEdge<E extends string> extends DirectedEdge<E> {
-  constructor(v1: VertexKey, v2: VertexKey, weight?: number, val?: E) {
-    super(v1, v2, weight, val);
-    this._data = val;
+class MyEdge<E = any> extends DirectedEdge<E> {
+  constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E) {
+    super(v1, v2, weight, value);
+    this._data = value;
   }
 
-  private _data: string | undefined;
+  protected _data: E | undefined;
 
-  get data(): string | undefined {
+  get data(): E | undefined {
     return this._data;
   }
 
-  set data(value: string | undefined) {
+  set data(value: E | undefined) {
     this._data = value;
   }
 }
 
-class MyDirectedGraph<V extends MyVertex<string>, E extends MyEdge<string>> extends DirectedGraph<V, E> {
-  createVertex(key: VertexKey, val: V['val']): V {
-    return new MyVertex(key, val) as V;
+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;
   }
 
-  createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E['val']): E {
-    return new MyEdge(src, dest, weight ?? 1, val) as E;
+  setOutEdgeMap(value: Map<VO, EO[]>) {
+    this._outEdgeMap = value;
   }
 }
 
 describe('Inherit from DirectedGraph and perform operations', () => {
-  let myGraph = new MyDirectedGraph<MyVertex<string>, MyEdge<string>>();
+  let myGraph = new MyDirectedGraph<string, string>();
   beforeEach(() => {
     myGraph = new MyDirectedGraph();
   });
@@ -129,6 +172,8 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     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
@@ -147,7 +192,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     expect(edge1).toBeInstanceOf(MyEdge);
     if (edge1) {
       expect(edge1.data).toBe('val1');
-      expect(edge1?.val).toBe('val1');
+      expect(edge1?.value).toBe('val1');
       expect(edge1).toBeInstanceOf(MyEdge);
       expect(edge1.src).toBe(1);
       expect(edge1).toEqual(edge2);
@@ -164,12 +209,12 @@ describe('Inherit from DirectedGraph and perform operations', () => {
     myGraph.addVertex(2, 'data2');
     myGraph.addEdge(1, 2, 10, 'edge-data1-2');
 
-    const removedEdge = myGraph.removeEdgeSrcToDest(1, 2);
+    const removedEdge = myGraph.deleteEdgeSrcToDest(1, 2);
     const edgeAfterRemoval = myGraph.getEdge(1, 2);
 
     expect(removedEdge).toBeInstanceOf(MyEdge);
     if (removedEdge) {
-      removedEdge && expect(removedEdge.val).toBe('edge-data1-2');
+      removedEdge && expect(removedEdge.value).toBe('edge-data1-2');
       removedEdge && expect(removedEdge.src).toBe(1);
     }
     expect(edgeAfterRemoval).toBeNull();
@@ -204,7 +249,7 @@ describe('Inherit from DirectedGraph and perform operations', () => {
 });
 
 describe('Inherit from DirectedGraph and perform operations test2.', () => {
-  const myGraph = new MyDirectedGraph<MyVertex<string>, MyEdge<string>>();
+  const myGraph = new MyDirectedGraph<string, string>();
 
   it('should test graph operations', () => {
     const vertex1 = new MyVertex(1, 'data1');
@@ -233,7 +278,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     expect(myGraph.getEdge(2, 1)).toBeTruthy();
     expect(myGraph.getEdge(1, '100')).toBeFalsy();
 
-    myGraph.removeEdgeSrcToDest(1, 2);
+    myGraph.deleteEdgeSrcToDest(1, 2);
     expect(myGraph.getEdge(1, 2)).toBeFalsy();
 
     myGraph.addEdge(3, 1, 3, 'edge-data-3-1');

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

@@ -1,20 +1,20 @@
-import {MapGraph, MapVertex} from '../../../../src';
+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.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);
@@ -43,3 +43,84 @@ describe('MapGraph Operation Test', () => {
     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);
+  });
+});

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

@@ -20,7 +20,7 @@ describe('Overall Graph Operation Test', () => {
     expect(graph.hasEdge('A', 'B')).toBe(true); // true
     expect(graph.hasEdge('B', 'A')).toBe(false); // false
 
-    graph.removeEdgeSrcToDest('A', 'B');
+    graph.deleteEdgeSrcToDest('A', 'B');
     graph.hasEdge('A', 'B'); // false
     expect(graph.hasEdge('A', 'B')).toBe(false); // false
 
@@ -38,7 +38,7 @@ describe('Overall Graph Operation Test', () => {
     graph.addVertex('B');
     graph.addVertex('C');
     graph.addVertex('D');
-    graph.removeVertex('C');
+    graph.deleteVertex('C');
     graph.addEdge('A', 'B');
     graph.addEdge('B', 'D');
 

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

@@ -7,6 +7,14 @@ describe('UndirectedGraph Operation Test', () => {
     graph = new UndirectedGraph();
   });
 
+  it('should edge cases', () => {
+    expect(graph.deleteEdge(new UndirectedEdge('c', 'd'))).toBe(null);
+    expect(graph.deleteEdgeBetween('c', 'd')).toBe(null);
+    expect(graph.degreeOf('c')).toBe(0);
+    expect(graph.edgesOf('c').length).toBe(0);
+    expect(graph.getEndsOfEdge(new UndirectedEdge('c', 'd'))).toBe(null);
+  });
+
   it('should add vertices', () => {
     const vertex1 = new UndirectedVertex('A');
     const vertex2 = new UndirectedVertex('B');
@@ -31,7 +39,7 @@ describe('UndirectedGraph Operation Test', () => {
     expect(graph.hasEdge('B', 'A')).toBe(true);
   });
 
-  it('should remove edges', () => {
+  it('should delete edges', () => {
     const vertex1 = new UndirectedVertex('A');
     const vertex2 = new UndirectedVertex('B');
     const edge = new UndirectedEdge('A', 'B');
@@ -40,7 +48,7 @@ describe('UndirectedGraph Operation Test', () => {
     graph.addVertex(vertex2);
     graph.addEdge(edge);
 
-    expect(graph.removeEdge(edge)).toBe(edge);
+    expect(graph.deleteEdge(edge)).toBe(edge);
     expect(graph.hasEdge('A', 'B')).toBe(false);
   });
 
@@ -49,7 +57,7 @@ describe('UndirectedGraph Operation Test', () => {
     graph.addVertex('B');
     graph.addVertex('C');
     graph.addVertex('D');
-    graph.removeVertex('C');
+    graph.deleteVertex('C');
     graph.addEdge('A', 'B');
     graph.addEdge('B', 'D');
 
@@ -57,3 +65,85 @@ describe('UndirectedGraph Operation Test', () => {
     expect(Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.key)).toEqual(['A', 'B', 'D']);
   });
 });
+
+describe('UndirectedGraph', () => {
+  let undirectedGraph: UndirectedGraph<string, string>;
+
+  beforeEach(() => {
+    // Create a new UndirectedGraph instance before each test
+    undirectedGraph = new UndirectedGraph<string, string>();
+  });
+
+  // Test adding vertices to the graph
+  it('should add vertices to the graph', () => {
+    const vertexA = new UndirectedVertex('A', 'Location A');
+    const vertexB = new UndirectedVertex('B', 'Location B');
+
+    undirectedGraph.addVertex(vertexA);
+    undirectedGraph.addVertex(vertexB);
+
+    expect(undirectedGraph.hasVertex('A')).toBe(true);
+    expect(undirectedGraph.hasVertex('B')).toBe(true);
+  });
+
+  // Test adding edges to the graph
+  it('should add edges to the graph', () => {
+    const vertexA = new UndirectedVertex('A', 'Location A');
+    const vertexB = new UndirectedVertex('B', 'Location B');
+    const edgeAB = new UndirectedEdge('A', 'B', 1, 'Edge between A and B');
+
+    undirectedGraph.addVertex(vertexA);
+    undirectedGraph.addVertex(vertexB);
+    undirectedGraph.addEdge(edgeAB);
+
+    expect(undirectedGraph.hasEdge('A', 'B')).toBe(true);
+  });
+
+  // Test getting neighbors of a vertex
+  it('should return the neighbors of a vertex', () => {
+    const vertexA = new UndirectedVertex('A', 'Location A');
+    const vertexB = new UndirectedVertex('B', 'Location B');
+    const vertexC = new UndirectedVertex('C', 'Location C');
+    const edgeAB = new UndirectedEdge('A', 'B', 1, 'Edge between A and B');
+    const edgeBC = new UndirectedEdge('B', 'C', 2, 'Edge between B and C');
+
+    undirectedGraph.addVertex(vertexA);
+    undirectedGraph.addVertex(vertexB);
+    undirectedGraph.addVertex(vertexC);
+    undirectedGraph.addEdge(edgeAB);
+    undirectedGraph.addEdge(edgeBC);
+
+    const neighborsOfA = undirectedGraph.getNeighbors('A');
+    const neighborsOfB = undirectedGraph.getNeighbors('B');
+
+    expect(neighborsOfA).toEqual([vertexB]);
+    expect(neighborsOfB).toEqual([vertexA, vertexC]);
+  });
+
+  // Test degree of a vertex
+  it('should return the degree of a vertex', () => {
+    const vertexA = new UndirectedVertex('A', 'Location A');
+    const vertexB = new UndirectedVertex('B', 'Location B');
+    const vertexC = new UndirectedVertex('C', 'Location C');
+    const edgeAB = new UndirectedEdge('A', 'B', 3, 'Edge between A and B');
+    const edgeBC = new UndirectedEdge('B', 'C', 4, 'Edge between B and C');
+
+    edgeAB.vertices = edgeAB.vertices;
+    expect(undirectedGraph.edges.size).toBe(0);
+    undirectedGraph.addVertex(vertexA);
+    undirectedGraph.addVertex(vertexB);
+    undirectedGraph.addVertex(vertexC);
+    undirectedGraph.addEdge(edgeAB);
+    undirectedGraph.addEdge(edgeBC);
+
+    const degreeOfA = undirectedGraph.degreeOf('A');
+    const degreeOfB = undirectedGraph.degreeOf('B');
+    const degreeOfC = undirectedGraph.degreeOf('C');
+    expect(undirectedGraph.edgeSet().length).toBe(2);
+    expect(undirectedGraph.getEndsOfEdge(edgeBC)?.length).toBe(2);
+
+    expect(degreeOfA).toBe(1);
+    expect(degreeOfB).toBe(2);
+    expect(degreeOfC).toBe(1);
+  });
+});

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

@@ -52,3 +52,23 @@ describe('CoordinateMap', () => {
     expect(retrievedValue).toBe(value);
   });
 });
+
+describe('CoordinateMap', () => {
+  class MyCoordinateMap<V = any> extends CoordinateMap<V> {
+    constructor(joint?: string) {
+      super(joint);
+      this._joint = joint += '-';
+    }
+  }
+
+  const cMap = new MyCoordinateMap<number>('*');
+
+  beforeEach(() => {
+    cMap.set([0, 0], 0);
+    cMap.set([0, 1], 1);
+    cMap.set([1, 1], 11);
+  });
+  it('should joint to be *-', () => {
+    expect(cMap.joint).toBe('*-');
+  });
+});

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

@@ -39,3 +39,28 @@ describe('CoordinateSet', () => {
     expect(hasValue).toBe(true);
   });
 });
+
+describe('MyCoordinateSet', () => {
+  class MyCoordinateSet extends CoordinateSet {
+    constructor(joint?: string) {
+      super(joint);
+      this._joint = joint += '-';
+    }
+  }
+
+  const mySet = new MyCoordinateSet('*');
+
+  beforeEach(() => {
+    mySet.add([0, 0]);
+    mySet.add([0, 1]);
+    mySet.add([1, 1]);
+  });
+  it('should joint to be *-', () => {
+    expect(mySet.joint).toBe('*-');
+  });
+
+  it('should has, delete', () => {
+    mySet.delete([0, 1]);
+    expect(mySet.has([0, 1])).toBe(false);
+  });
+});

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

@@ -28,7 +28,6 @@ describe('HashMap', () => {
 
   it('should handle key collisions', () => {
     // Force a collision by setting two different keys to the same bucket
-    hashMap.hashFn = () => 0; // Override hash function to return the same index
     hashMap.set('key1', 1);
     hashMap.set('key2', 2);
 
@@ -36,11 +35,11 @@ describe('HashMap', () => {
     expect(hashMap.get('key2')).toBe(2);
   });
 
-  it('should remove values', () => {
+  it('should delete values', () => {
     hashMap.set('one', 1);
     hashMap.set('two', 2);
 
-    hashMap.remove('one');
+    hashMap.delete('one');
     expect(hashMap.get('one')).toBeUndefined();
     expect(hashMap.size).toBe(1);
   });