data-structure-typed 2.4.1 → 2.4.3

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

@@ -1,231 +0,0 @@
-import { TreeSet } from '../../../../src';
-
-describe('TreeSet (RedBlackTree-backed, no node exposure)', () => {
-  test('basic operations: add/has/delete/size/isEmpty/clear', () => {
-    const s = new TreeSet<number>();
-    expect(s.isEmpty()).toBe(true);
-    expect(s.size).toBe(0);
-
-    expect(s.add(2)).toBe(s);
-    expect(s.add(1)).toBe(s);
-    expect(s.add(3)).toBe(s);
-    expect(s.size).toBe(3);
-    expect(s.isEmpty()).toBe(false);
-
-    expect(s.has(2)).toBe(true);
-    expect(s.has(999)).toBe(false);
-
-    expect(s.delete(2)).toBe(true);
-    expect(s.delete(2)).toBe(false);
-    expect(s.size).toBe(2);
-
-    s.clear();
-    expect(s.size).toBe(0);
-    expect(s.isEmpty()).toBe(true);
-  });
-
-  test('iteration: keys/values/entries and ordering', () => {
-    const s = new TreeSet<number>([3, 1, 2, 2]);
-    expect([...s]).toEqual([1, 2, 3]);
-    expect([...s.keys()]).toEqual([1, 2, 3]);
-    expect([...s.values()]).toEqual([1, 2, 3]);
-    expect([...s.entries()]).toEqual([
-      [1, 1],
-      [2, 2],
-      [3, 3]
-    ]);
-
-    const seen: number[] = [];
-    const ctx = { ok: true };
-    s.forEach(function (this: typeof ctx, v) {
-      expect(this).toBe(ctx);
-      seen.push(v);
-    }, ctx);
-    expect(seen).toEqual([1, 2, 3]);
-  });
-
-  test('default comparator: NaN throws (even on empty tree)', () => {
-    const s = new TreeSet<number>();
-    expect(() => s.add(Number.NaN)).toThrow(TypeError);
-    expect(() => s.has(Number.NaN)).toThrow(TypeError);
-    expect(() => s.delete(Number.NaN)).toThrow(TypeError);
-    expect(() => s.ceiling(Number.NaN)).toThrow(TypeError);
-  });
-
-  test('constructor throws when encountering invalid keys under default comparator', () => {
-    expect(() => new TreeSet<number>([1, Number.NaN, 2])).toThrow(TypeError);
-
-    const bad = new Date('not-a-date');
-    expect(() => new TreeSet<Date>([bad])).toThrow(TypeError);
-
-    type Obj = { n: number };
-    expect(() => new TreeSet<Obj>([{ n: 1 }])).toThrow(TypeError);
-  });
-
-  test('default comparator: -0 and 0 are the same key', () => {
-    const s = new TreeSet<number>();
-    s.add(-0);
-    expect(s.size).toBe(1);
-    expect(s.has(0)).toBe(true);
-    expect(s.has(-0)).toBe(true);
-
-    s.add(0);
-    expect(s.size).toBe(1);
-  });
-
-  test('default comparator: Date supported; invalid Date throws', () => {
-    const d1 = new Date('2020-01-01T00:00:00.000Z');
-    const d2 = new Date('2021-01-01T00:00:00.000Z');
-    const s = new TreeSet<Date>([d2, d1]);
-    expect([...s]).toEqual([d1, d2]);
-
-    const bad = new Date('not-a-date');
-    const s2 = new TreeSet<Date>();
-    expect(() => s2.add(bad)).toThrow(TypeError);
-  });
-
-  test('default comparator: string key ordering is supported', () => {
-    const s = new TreeSet<string>(['b', 'a', 'c']);
-    expect([...s]).toEqual(['a', 'b', 'c']);
-    expect(s.higher('b')).toBe('c');
-  });
-
-  test('default comparator: non-primitive/non-Date requires custom comparator', () => {
-    type Obj = { n: number };
-    const o1: Obj = { n: 1 };
-
-    expect(() => new TreeSet<Obj>([o1])).toThrow(TypeError);
-
-    const byN = (a: Obj, b: Obj) => a.n - b.n;
-    const s = new TreeSet<Obj>([o1, { n: 2 }], { comparator: byN });
-    expect(s.size).toBe(2);
-  });
-
-  test('createDefaultComparator throws for unsupported key types', () => {
-    const cmp = TreeSet.createDefaultComparator<object>();
-    expect(() => cmp({} as unknown as object, {} as unknown as object)).toThrow(TypeError);
-  });
-
-  test('navigable operations: first/last/pollFirst/pollLast', () => {
-    const s = new TreeSet<number>();
-    expect(s.first()).toBe(undefined);
-    expect(s.last()).toBe(undefined);
-    expect(s.pollFirst()).toBe(undefined);
-    expect(s.pollLast()).toBe(undefined);
-
-    s.add(2).add(1).add(3);
-    expect(s.first()).toBe(1);
-    expect(s.last()).toBe(3);
-
-    expect(s.pollFirst()).toBe(1);
-    expect([...s]).toEqual([2, 3]);
-
-    expect(s.pollLast()).toBe(3);
-    expect([...s]).toEqual([2]);
-  });
-
-  test('navigable operations: ceiling/floor/higher/lower', () => {
-    const s = new TreeSet<number>([1, 3, 5]);
-
-    expect(s.ceiling(0)).toBe(1);
-    expect(s.ceiling(1)).toBe(1);
-    expect(s.ceiling(2)).toBe(3);
-    expect(s.ceiling(6)).toBe(undefined);
-
-    expect(s.floor(0)).toBe(undefined);
-    expect(s.floor(1)).toBe(1);
-    expect(s.floor(2)).toBe(1);
-    expect(s.floor(6)).toBe(5);
-
-    expect(s.higher(1)).toBe(3);
-    expect(s.higher(5)).toBe(undefined);
-
-    expect(s.lower(1)).toBe(undefined);
-    expect(s.lower(5)).toBe(3);
-  });
-
-  test('rangeSearch supports inclusive/exclusive bounds', () => {
-    const s = new TreeSet<number>([1, 2, 3, 4, 5]);
-
-    expect(s.rangeSearch([2, 4])).toEqual([2, 3, 4]);
-    expect(s.rangeSearch([2, 4], { lowInclusive: true, highInclusive: false })).toEqual([2, 3]);
-    expect(s.rangeSearch([2, 4], { lowInclusive: false, highInclusive: true })).toEqual([3, 4]);
-    expect(s.rangeSearch([2, 4], { lowInclusive: false, highInclusive: false })).toEqual([3]);
-  });
-
-  test('map/filter/reduce/every/some/find/toArray/print', () => {
-    const s = new TreeSet<number>([3, 1, 2]);
-
-    expect(s.map(v => v * 2).toArray()).toEqual([2, 4, 6]);
-
-    const ctx = { mul: 3 };
-    expect(
-      s.map(function (this: typeof ctx, v) {
-        return v * this.mul;
-      }, {}, ctx).toArray()
-    ).toEqual([3, 6, 9]);
-
-    expect(s.filter(v => v % 2 === 1).toArray()).toEqual([1, 3]);
-    expect(s.reduce((acc, v) => acc + v, 0)).toBe(6);
-
-    expect(s.every(v => v > 0)).toBe(true);
-    expect(s.every(v => v > 2)).toBe(false);
-
-    expect(s.some(v => v === 2)).toBe(true);
-    expect(s.some(v => v === 999)).toBe(false);
-
-    expect(s.find(v => v >= 2)).toBe(2);
-    expect(s.find(v => v >= 999)).toBe(undefined);
-
-    expect(s.toArray()).toEqual([1, 2, 3]);
-
-    const spy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
-    s.print();
-    expect(spy).toHaveBeenCalled();
-    spy.mockRestore();
-  });
-
-  test('toElementFn: construct from raw objects', () => {
-    interface User {
-      id: number;
-      name: string;
-    }
-
-    const users: User[] = [
-      { id: 3, name: 'Charlie' },
-      { id: 1, name: 'Alice' },
-      { id: 2, name: 'Bob' }
-    ];
-
-    const s = new TreeSet<number, User>(users, {
-      toElementFn: u => u.id
-    });
-
-    expect(s.size).toBe(3);
-    expect([...s]).toEqual([1, 2, 3]); // sorted
-    expect(s.has(1)).toBe(true);
-    expect(s.has(2)).toBe(true);
-    expect(s.has(3)).toBe(true);
-    expect(s.has(4)).toBe(false);
-  });
-
-  test('toElementFn: with duplicates (deduplication)', () => {
-    interface Item {
-      category: string;
-      name: string;
-    }
-
-    const items: Item[] = [
-      { category: 'fruit', name: 'apple' },
-      { category: 'vegetable', name: 'carrot' },
-      { category: 'fruit', name: 'banana' } // duplicate category
-    ];
-
-    const s = new TreeSet<string, Item>(items, {
-      toElementFn: item => item.category
-    });
-
-    expect(s.size).toBe(2); // deduplicated
-    expect([...s]).toEqual(['fruit', 'vegetable']);
-  });
-});

package/test/unit/data-structures/graph/abstract-graph.more-branches-2.coverage.test.ts

@@ -1,40 +0,0 @@
-import { DirectedGraph } from '../../../../src';
-
-describe('AbstractGraph additional branch coverage (2)', () => {
-  it('getMinCostBetween(unweighted) returns undefined when either vertex missing', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    expect(g.getMinCostBetween('A', 'MISSING' as any, false)).toBeUndefined();
-  });
-
-  it('getMinPathBetween(weighted, DFS) returns undefined when no paths exist (covers allPaths[-1] || undefined)', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('C');
-    // no edges => no paths
-    const out = g.getMinPathBetween('A', 'C', true, true);
-    expect(out).toBeUndefined();
-  });
-
-  it('getMinPathBetween(weighted, Dijkstra) returns [] when src missing (covers ?.minPath ?? [])', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-    g.addEdge('A', 'B', 1);
-
-    const out = g.getMinPathBetween('MISSING' as any, 'B', true, false);
-    expect(out).toEqual([]);
-  });
-
-  it('dijkstraWithoutHeap returns undefined when src missing', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    expect(g.dijkstraWithoutHeap('MISSING' as any)).toBeUndefined();
-  });
-
-  it('dijkstra returns undefined when src missing', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    expect(g.dijkstra('MISSING' as any)).toBeUndefined();
-  });
-});

package/test/unit/data-structures/graph/abstract-graph.more-branches-3.coverage.test.ts

@@ -1,65 +0,0 @@
-import { DirectedGraph } from '../../../../src';
-
-describe('AbstractGraph additional branch coverage (3)', () => {
-  it('getMinPathBetween(unweighted) returns [] when either vertex missing (covers guard)', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    expect(g.getMinPathBetween('A', 'MISSING' as any, false)).toEqual([]);
-  });
-
-  it('getMinPathBetween(weighted, DFS) returns a real min path when multiple paths exist (covers allPaths[minIndex])', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-    g.addVertex('C');
-
-    // two paths A->C (weight 5) and A->B->C (weight 3)
-    g.addEdge('A', 'C', 5);
-    g.addEdge('A', 'B', 1);
-    g.addEdge('B', 'C', 2);
-
-    const out = g.getMinPathBetween('A', 'C', true, true)!;
-    expect(out.map(v => v.key)).toEqual(['A', 'B', 'C']);
-  });
-
-  it('getMinPathBetween(weighted, Dijkstra) returns minPath when dijkstra returns it (covers ?.minPath ?? [] left side)', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-    g.addVertex('C');
-
-    g.addEdge('A', 'C', 5);
-    g.addEdge('A', 'B', 1);
-    g.addEdge('B', 'C', 2);
-
-    const out = g.getMinPathBetween('A', 'C', true, false)!;
-    expect(out.map(v => v.key)).toEqual(['A', 'B', 'C']);
-  });
-
-  it('bellmanFord returns early when src missing and scanNegativeCycle true (covers hasNegativeCycle init + early return)', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-
-    const res = g.bellmanFord('MISSING' as any, true, true, true);
-    expect(res.hasNegativeCycle).toBe(false);
-    expect(res.distMap.size).toBe(0);
-  });
-
-  it('bellmanFord with getMin+genPath builds minPath and leaves hasNegativeCycle false when sWeight is 0 (covers branches at 752/754/771/784)', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-    g.addVertex('C');
-
-    g.addEdge('A', 'B', 1);
-    g.addEdge('B', 'C', 1);
-
-    const res = g.bellmanFord('A', true, true, true);
-
-    // min path should end at the closest reachable vertex (B)
-    expect(res.min).toBe(1);
-    expect(res.minPath.map(v => v.key)).toEqual(['A', 'B']);
-    expect(res.hasNegativeCycle).toBe(false);
-    expect(res.paths.length).toBe(3);
-  });
-});

package/test/unit/data-structures/graph/abstract-graph.more-branches-4.coverage.test.ts

@@ -1,98 +0,0 @@
-import { DirectedGraph, DirectedVertex } from '../../../../src';
-
-describe('AbstractGraph additional branch coverage (4)', () => {
-  it('dijkstraWithoutHeap early-stop at dest=src covers getMinDist/genPaths branches and `|| MAX_SAFE_INTEGER` fallback when dist=0', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-
-    const res = g.dijkstraWithoutHeap('A', 'A', true, true)!;
-    // when dest=src, distMap.get(dest)=0, so code uses `0 || MAX_SAFE_INTEGER`
-    expect(res.minDist).toBe(Number.MAX_SAFE_INTEGER);
-    expect(res.paths.length).toBe(2);
-  });
-
-  it('dijkstra early-stop at dest=src covers getMinDist branch and `|| MAX_SAFE_INTEGER` fallback when dist=0', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-
-    const res = g.dijkstra('A', 'A', true, false)!;
-    expect(res.minDist).toBe(Number.MAX_SAFE_INTEGER);
-  });
-
-  it('bellmanFord negative-cycle scan takes the truthy sWeight branch and sets hasNegativeCycle=true', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-
-    // Make B reachable with sWeight=1, then include a self-edge with negative weight.
-    g.addEdge('A', 'B', 1);
-    g.addEdge('B', 'B', -2);
-
-    const res = g.bellmanFord('A', true, false, false);
-    expect(res.hasNegativeCycle).toBe(true);
-  });
-
-  it('getCycles includes 2-cycle only when isInclude2Cycle=true (covers length condition branches)', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-
-    g.addEdge('A', 'B', 1);
-    g.addEdge('B', 'A', 1);
-
-    const no2 = g.getCycles(false);
-    expect(no2.length).toBe(0);
-
-    const yes2 = g.getCycles(true);
-    expect(yes2.length).toBeGreaterThan(0);
-  });
-
-  it('filter pushes entries when predicate returns true (covers filter if-body)', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A', 1 as any);
-    g.addVertex('B', 2 as any);
-
-    const out = g.filter((value: any) => value === 2);
-    expect(out.hasVertex('B')).toBe(true);
-    expect(out.hasVertex('A')).toBe(false);
-  });
-
-  it('_createInstance uses provided options.graph branch, and _createLike uses iter branch', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-
-    const inst = (g as any)._createInstance({ graph: { foo: 123 } });
-    expect((inst as any)._options.foo).toBe(123);
-
-    const like = (g as any)._createLike([
-      ['X', 1],
-      ['Y', 2]
-    ]);
-    expect(like.hasVertex('X')).toBe(true);
-    expect(like.hasVertex('Y')).toBe(true);
-  });
-
-  it('_createLike handles missing hasVertex() by taking the false branch of conditional hasA/hasB', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-    g.addEdge('A', 'B', 1);
-
-    // Shadow hasVertex so the internal `g.hasVertex ? g.hasVertex(...) : false` takes the false branch.
-    const inst = (g as any)._createInstance();
-    (inst as any).hasVertex = undefined;
-
-    const like = (g as any)._createLike(undefined, undefined);
-    // Should still be a graph instance; we only care about exercising the branch.
-    expect(like).toBeDefined();
-  });
-
-  it('_addVertex returns false when vertex already exists (covers hasVertex(newVertex) true branch)', () => {
-    const g = new DirectedGraph();
-    const v = new DirectedVertex('A');
-    (g as any)._addVertex(v);
-    expect((g as any)._addVertex(v)).toBe(false);
-  });
-});

package/test/unit/data-structures/graph/abstract-graph.more-branches-5.coverage.test.ts

@@ -1,51 +0,0 @@
-import { DirectedGraph } from '../../../../src';
-
-describe('AbstractGraph additional branch coverage (5)', () => {
-  it('_createLike continues when getEndsOfEdge returns undefined (covers !ends continue)', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-    g.addEdge('A', 'B', 1);
-
-    const orig = g.getEndsOfEdge.bind(g);
-    let once = true;
-    (g as any).getEndsOfEdge = (edge: any) => {
-      if (once) {
-        once = false;
-        return undefined;
-      }
-      return orig(edge);
-    };
-
-    const out = (g as any)._createLike();
-    expect(out.hasVertex('A')).toBe(true);
-    expect(out.hasVertex('B')).toBe(true);
-  });
-
-  it('_createLike takes the false arm of `(g as any).hasVertex ? ... : false` (covers cond-expr false branches)', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-    g.addEdge('A', 'B', 1);
-
-    const origCreateInstance = (g as any)._createInstance;
-    (g as any)._createInstance = (options?: any) => {
-      const inst = origCreateInstance.call(g, options);
-      // Shadow hasVertex so the conditional expression uses the false arm.
-      // Also override _addVertex so addVertex() doesn't crash when hasVertex is missing.
-      (inst as any).hasVertex = undefined;
-      (inst as any)._addVertex = (v: any) => {
-        (inst as any)._vertexMap.set(v.key, v);
-        return true;
-      };
-      return inst;
-    };
-
-    try {
-      const out = (g as any)._createLike();
-      expect(out).toBeDefined();
-    } finally {
-      (g as any)._createInstance = origCreateInstance;
-    }
-  });
-});

package/test/unit/data-structures/graph/abstract-graph.more-branches.coverage.test.ts

@@ -1,62 +0,0 @@
-import { DirectedGraph, DirectedVertex, AbstractVertex } from '../../../../src';
-
-describe('AbstractGraph extra branch coverage via DirectedGraph', () => {
-  it('getVertex(missingKey) returns undefined (covers `|| undefined` branch)', () => {
-    const g = new DirectedGraph();
-    expect(g.getVertex('MISSING' as any)).toBeUndefined();
-  });
-
-  it('addEdge(srcKey,destKey) returns false when either vertex is missing', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    expect(g.addEdge('A', 'B' as any)).toBe(false);
-  });
-
-  it('addEdge(srcVertex,destVertex) converts AbstractVertex endpoints to keys', () => {
-    const g = new DirectedGraph();
-    const a = new DirectedVertex('A');
-    const b = new DirectedVertex('B');
-    g.addVertex(a);
-    g.addVertex(b);
-
-    // goes through addEdge(srcOrEdge, dest) branch where dest is AbstractVertex
-    expect(g.addEdge(a as unknown as AbstractVertex<any>, b as unknown as AbstractVertex<any>, 2)).toBe(true);
-    expect(g.hasEdge('A', 'B')).toBe(true);
-  });
-
-  it('addEdge throws when dest is not a Vertex or vertex key', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    expect(() => g.addEdge('A' as any, { bad: true } as any)).toThrow(/dest must be a Vertex or vertex key/i);
-  });
-
-  it('setEdgeWeight returns false when edge does not exist', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-    expect(g.setEdgeWeight('A', 'B', 123)).toBe(false);
-  });
-
-  it('dijkstraWithoutHeap uses default args and also covers early-stop (dest + getMinDist + genPaths)', () => {
-    const g = new DirectedGraph();
-    g.addVertex('A');
-    g.addVertex('B');
-    g.addVertex('C');
-
-    g.addEdge('A', 'B', 1);
-    g.addEdge('B', 'C', 2);
-
-    // default args: dest undefined, getMinDist/genPaths false
-    const base = g.dijkstraWithoutHeap('A');
-    expect(base).toBeDefined();
-
-    const res = g.dijkstraWithoutHeap('A', 'C', true, true);
-    // Implementation detail: DirectedGraph may normalize weights; here we only assert it computed a finite minDist.
-    expect(typeof res?.minDist).toBe('number');
-    expect(Number.isFinite(res!.minDist)).toBe(true);
-    // genPaths=true should generate a path for each vertex
-    expect(res?.paths.length).toBe(3);
-    // minPath should be some path ending at the destination when implementation chooses to store it.
-    expect(Array.isArray(res?.minPath)).toBe(true);
-  });
-});

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

@@ -1,117 +0,0 @@
-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 | undefined {
-    return edge;
-  }
-
-  getEdge(srcOrKey: VertexKey, destOrKey: VertexKey): EO | undefined {
-    return new MyEdge(srcOrKey, destOrKey) as EO;
-  }
-
-  degreeOf(vertexOrKey: VO | VertexKey): number {
-    return 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] | undefined {
-    return edge ? undefined : undefined;
-  }
-
-  deleteVertex(vertexOrKey: VertexKey | VO): boolean {
-    let vertexKey: VertexKey;
-    if (this.isVertexKey(vertexOrKey)) {
-      vertexKey = vertexOrKey;
-    } else {
-      vertexKey = vertexOrKey.key;
-    }
-    this._vertexMap.delete(vertexKey);
-    return true;
-  }
-
-  isEmpty(): boolean {
-    return true;
-  }
-
-  clear(): void {}
-
-  protected _addEdge(edge: EO): boolean {
-    return edge ? true : true;
-  }
-}
-
-describe('AbstractGraph Operation Test', () => {
-  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);
-  });
-});