data-structure-typed 2.2.8 → 2.3.0

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

@@ -0,0 +1,62 @@
+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/directed-graph.more-branches-2.coverage.test.ts

@@ -0,0 +1,38 @@
+import { DirectedGraph } from '../../../../src';
+
+describe('DirectedGraph remaining branch coverage (batch 2)', () => {
+  it('createEdge falls back to weight=1 when weight and defaultEdgeWeight are both undefined', () => {
+    const g = new DirectedGraph<string, any>();
+    const e = g.createEdge('a', 'b');
+    expect(e.weight).toBe(1);
+  });
+
+  it('deleteEdgeSrcToDest hits "[0] || undefined" fallback when inEdgeMap exists but no matching edge', () => {
+    const g = new DirectedGraph<string, any>();
+    g.addVertex('a');
+    g.addVertex('b');
+    g.addVertex('c');
+
+    // Only add c->b, so b has an inEdge that does not match src=a
+    g.addEdge('c', 'b');
+
+    const removed = (g as any).deleteEdgeSrcToDest('a', 'b');
+    expect(removed).toBeUndefined();
+  });
+
+  it('deleteEdgesBetween skips body when v1 or v2 is falsy (covers if(v1&&v2) false branch)', () => {
+    const g = new DirectedGraph<string, any>();
+    expect(g.deleteEdgesBetween(undefined as any, 'x' as any)).toEqual([]);
+  });
+
+  it('topologicalSort("key") covers mapping else-arm when sorted contains a raw key (not a DirectedVertex)', () => {
+    const g = new DirectedGraph<string, any>();
+    g.addVertex('a');
+
+    // Corrupt vertexMap to include a non-DirectedVertex entry value.
+    (g as any)._vertexMap.set('b', 'b');
+
+    const sorted = g.topologicalSort('key') as any[];
+    expect(sorted).toContain('b');
+  });
+});

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

@@ -0,0 +1,25 @@
+import { DirectedGraph } from '../../../../src';
+
+describe('DirectedGraph remaining branch coverage (batch 3)', () => {
+  it('createEdge uses final fallback weight=1 when defaultEdgeWeight is explicitly undefined', () => {
+    const g = new DirectedGraph<string, any>();
+
+    // Force options.defaultEdgeWeight to be undefined so `weight ?? defaultEdgeWeight ?? 1` uses the final `1`.
+    (g as any).options.defaultEdgeWeight = undefined;
+
+    const e = g.createEdge('a', 'b');
+    expect(e.weight).toBe(1);
+  });
+
+  it('deleteEdgesBetween pushes both directions when both edges exist (covers v2ToV1 truthy branch)', () => {
+    const g = new DirectedGraph<string, any>();
+    g.addVertex('a');
+    g.addVertex('b');
+
+    g.addEdge('a', 'b');
+    g.addEdge('b', 'a');
+
+    const removed = g.deleteEdgesBetween('a', 'b');
+    expect(removed).toHaveLength(2);
+  });
+});

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

@@ -0,0 +1,82 @@
+import { DirectedEdge, DirectedGraph } from '../../../../src';
+
+describe('DirectedGraph additional branch coverage', () => {
+  it('static fromKeys/fromEntries build graphs (and exercises vertexValueInitializer body)', () => {
+    const g1 = DirectedGraph.fromKeys(['a', 'b']);
+    expect(g1.hasVertex('a')).toBe(true);
+    // value initializer behavior may vary; key must exist.
+    expect(g1.getVertex('b')?.key).toBe('b');
+
+    // Force execution of the initializer function body (coverage line ~212).
+    const init = (g1 as any).options?.vertexValueInitializer;
+    if (typeof init === 'function') {
+      expect(init('z')).toBe('z');
+    }
+
+    const g2 = DirectedGraph.fromEntries([
+      ['x', 1],
+      ['y', 2]
+    ]);
+    expect(g2.getVertex('x')?.value).toBe(1);
+    expect(g2.getVertex('y')?.value).toBe(2);
+  });
+
+  it('deleteEdge(srcKey) returns undefined when destVertexKey is not a key', () => {
+    const g = new DirectedGraph<string, number>();
+    g.addVertex('a');
+    g.addVertex('b');
+    g.addEdge('a', 'b');
+
+    expect(g.deleteEdge('a' as any, undefined as any)).toBeUndefined();
+  });
+
+  it('outgoingEdgesOf returns [] when target missing', () => {
+    const g = new DirectedGraph<string, number>();
+    expect(g.outgoingEdgesOf('missing' as any)).toEqual([]);
+  });
+
+  it('getDestinations(undefined) returns []', () => {
+    const g = new DirectedGraph<string, number>();
+    expect(g.getDestinations(undefined)).toEqual([]);
+  });
+
+  it('getEndsOfEdge returns undefined when edge missing, and hits the else-branch when endpoint lookup fails', () => {
+    const g = new DirectedGraph<string, number>();
+    g.addVertex('a');
+    g.addVertex('b');
+
+    const eMissing = new DirectedEdge('a', 'b', 1);
+    expect(g.getEndsOfEdge(eMissing as any)).toBeUndefined();
+
+    // Force hasEdge=true but _getVertex failure to hit the `else { return undefined; }` branch (coverage line ~568).
+    const origHasEdge = (g as any).hasEdge;
+    const origGetVertex = (g as any)._getVertex;
+    (g as any).hasEdge = () => true;
+    (g as any)._getVertex = () => undefined;
+    try {
+      expect(g.getEndsOfEdge(new DirectedEdge('a', 'b', 1) as any)).toBeUndefined();
+    } finally {
+      (g as any).hasEdge = origHasEdge;
+      (g as any)._getVertex = origGetVertex;
+    }
+  });
+
+  it('_addEdge returns false when vertices are missing, and when _getVertex returns undefined', () => {
+    const g = new DirectedGraph<string, number>();
+
+    // Missing vertices => early return false
+    expect((g as any)._addEdge(new DirectedEdge('a', 'b', 1))).toBe(false);
+
+    g.addVertex('a');
+    g.addVertex('b');
+
+    const origGetVertex = (g as any)._getVertex;
+    (g as any)._getVertex = () => undefined;
+    try {
+      // hasVertex() is still true, but srcVertex/destVertex become undefined => else return false
+      expect((g as any)._addEdge(new DirectedEdge('a', 'b', 1))).toBe(false);
+    } finally {
+      (g as any)._getVertex = origGetVertex;
+    }
+  });
+});

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

@@ -0,0 +1,22 @@
+import { MapGraph } from '../../../../src';
+
+describe('MapGraph remaining branch coverage', () => {
+  it('_createInstance falls back to this.originCoord/this.bottomRight when options omit them (?? rhs)', () => {
+    const g = new MapGraph<number, number>([10, 20], [30, 40]);
+
+    // No-arg call hits (options || {}) rhs.
+    const inst = (g as any)._createInstance();
+    expect(inst).toBeInstanceOf(MapGraph);
+
+    // Empty options hits originCoord/bottomRight ?? rhs.
+    const instEmpty = (g as any)._createInstance({});
+    expect(instEmpty).toBeInstanceOf(MapGraph);
+
+    // Verify fallbacks were used.
+    expect((inst as any).originCoord).toEqual([10, 20]);
+    expect((inst as any).bottomRight).toEqual([30, 40]);
+
+    const inst2 = (g as any)._createInstance({ bottomRight: undefined });
+    expect((inst2 as any).bottomRight).toEqual([30, 40]);
+  });
+});

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

@@ -0,0 +1,35 @@
+import { UndirectedGraph } from '../../../../src';
+
+describe('UndirectedGraph remaining branch coverage (batch 2)', () => {
+  it('createEdge uses final fallback weight=1 when defaultEdgeWeight is explicitly undefined', () => {
+    const g = new UndirectedGraph<string, any>();
+    (g as any).options.defaultEdgeWeight = undefined;
+
+    const e = g.createEdge('a', 'b');
+    expect(e.weight).toBe(1);
+  });
+
+  it('getEndsOfEdge hits else-return branch when hasEdge=true but endpoint vertex is missing', () => {
+    const g = new UndirectedGraph<string, any>();
+    g.addVertex('a');
+    g.addVertex('b');
+
+    const edge = g.createEdge('a', 'b');
+
+    const origHasEdge = (g as any).hasEdge;
+    const origGetVertex = (g as any)._getVertex;
+
+    (g as any).hasEdge = () => true;
+    (g as any)._getVertex = (key: any) => {
+      if (key === 'a') return undefined;
+      return origGetVertex.call(g, key);
+    };
+
+    try {
+      expect(g.getEndsOfEdge(edge as any)).toBeUndefined();
+    } finally {
+      (g as any).hasEdge = origHasEdge;
+      (g as any)._getVertex = origGetVertex;
+    }
+  });
+});

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

@@ -0,0 +1,87 @@
+import { UndirectedEdge, UndirectedGraph } from '../../../../src';
+
+describe('UndirectedGraph additional branch coverage', () => {
+  it('createEdge falls back to hard-coded weight=1 when weight and defaultEdgeWeight are both undefined', () => {
+    const g = new UndirectedGraph<string, any>();
+    const e = g.createEdge('a', 'b');
+    expect(e.weight).toBe(1);
+  });
+
+  it('getEdge returns undefined via edgeMap falsy branch when vertices exist but no edgeMap entry', () => {
+    const g = new UndirectedGraph<string, any>();
+    g.addVertex('a');
+    g.addVertex('b');
+
+    // No edge inserted => _edgeMap.get(vertex1) is undefined => edgeMap becomes undefined
+    expect(g.getEdge('a', 'b')).toBeUndefined();
+  });
+
+  it('deleteEdgeBetween executes "|| undefined" fallback when v1Edges exists but no matching edge is found', () => {
+    const g = new UndirectedGraph<string, any>();
+    g.addVertex('a');
+    g.addVertex('b');
+    g.addVertex('c');
+
+    // Create a--c edge so v1Edges exists for a, but there is no a--b edge.
+    g.addEdge('a', 'c');
+
+    expect(g.deleteEdgeBetween('a', 'b')).toBeUndefined();
+  });
+
+  it('deleteEdge(key, missingOtherKey) returns undefined via early return branch', () => {
+    const g = new UndirectedGraph<string, any>();
+    g.addVertex('a');
+    g.addVertex('b');
+    g.addEdge('a', 'b');
+
+    expect(g.deleteEdge('a' as any, undefined as any)).toBeUndefined();
+  });
+
+  it('deleteVertex(vertexInstance) covers non-key input branch', () => {
+    const g = new UndirectedGraph<string, any>();
+    g.addVertex('a');
+
+    const v = g.getVertex('a')!;
+    expect(g.deleteVertex(v as any)).toBe(true);
+    expect(g.hasVertex('a')).toBe(false);
+  });
+
+  it('degreeOf returns 0 via "|| 0" fallback when vertex exists but has no incident edges', () => {
+    const g = new UndirectedGraph<string, any>();
+    g.addVertex('solo');
+    expect(g.degreeOf('solo')).toBe(0);
+  });
+
+  it('getEndsOfEdge returns undefined when hasEdge is true but endpoint lookup fails', () => {
+    const g = new UndirectedGraph<string, any>();
+    g.addVertex('a');
+    g.addVertex('b');
+    g.addEdge('a', 'b');
+
+    const e = g.getEdge('a', 'b')!;
+
+    // Corrupt internal vertex map so hasEdge stays true but _getVertex fails.
+    const vm = (g as any)._vertexMap as Map<any, any>;
+    const saved = vm.get('b');
+    vm.delete('b');
+    try {
+      expect(g.getEndsOfEdge(e as any)).toBeUndefined();
+    } finally {
+      vm.set('b', saved);
+    }
+  });
+
+  it('_addEdge returns false when _getVertex yields undefined for an endpoint (covers endVertex===undefined branch)', () => {
+    const g = new UndirectedGraph<string, any>();
+    g.addVertex('a');
+    g.addVertex('b');
+
+    const origGetVertex = (g as any)._getVertex;
+    (g as any)._getVertex = () => undefined;
+    try {
+      expect((g as any)._addEdge(new UndirectedEdge('a', 'b', 1) as any)).toBe(false);
+    } finally {
+      (g as any)._getVertex = origGetVertex;
+    }
+  });
+});

package/test/unit/data-structures/hash/hash-map.more-branches.coverage.test.ts

@@ -0,0 +1,64 @@
+import { HashMap, LinkedHashMap } from '../../../../src';
+
+describe('HashMap / LinkedHashMap additional branch coverage', () => {
+  it('HashMap.setHashFn returns early when same fn is passed (covers _hashFn===fn branch)', () => {
+    const m = new HashMap<any, any>();
+    const fn = (m as any)._hashFn;
+    expect(m.setHashFn(fn)).toBe(m);
+  });
+
+  it('HashMap._getNoObjKey covers symbol-key path and non-(string/number/symbol) path', () => {
+    const m = new HashMap<any, any>();
+
+    // symbol -> hits (..&&..&& keyType!=='symbol') final operand false arm
+    const s = Symbol('k');
+    m.set(s as any, 1);
+    expect(m.get(s as any)).toBe(1);
+
+    // boolean -> forces _hashFn(key) path
+    m.set(true as any, 2);
+    expect(m.get(true as any)).toBe(2);
+  });
+
+  it('LinkedHashMap.toEntryFn default throws when rawElement is not an entry (covers toEntryFn error)', () => {
+    const m = new LinkedHashMap<number, number, any>();
+    expect(() => (m as any).toEntryFn({ k: 1, v: 2 })).toThrow(/provide `options\.toEntryFn`/i);
+  });
+
+  it('LinkedHashMap set/get/delete branches for weak keys and missing nodes', () => {
+    const m = new LinkedHashMap<object, number>();
+    const obj = {};
+
+    // insert weak key => new node
+    m.set(obj, 1);
+    expect(m.get(obj)).toBe(1);
+
+    // update existing weak key => else-if(node) branch
+    m.set(obj, 2);
+    expect(m.get(obj)).toBe(2);
+
+    // get missing weak key => node ? node.value : undefined false arm
+    expect(m.get({} as any)).toBeUndefined();
+
+    // delete missing weak key => if(!node) return false
+    expect(m.delete({} as any)).toBe(false);
+  });
+
+  it('LinkedHashMap.deleteWhere covers weak-key delete path and noObj delete path and not-found return false', () => {
+    const m = new LinkedHashMap<any, number>();
+    const obj = {};
+    m.set('a', 1);
+    m.set(obj, 2);
+
+    // deleteWhere hits predicate true for weak key => _objMap.delete branch
+    expect(m.deleteWhere((k: any) => typeof k === 'object')).toBe(true);
+    expect(m.has(obj)).toBe(false);
+
+    // deleteWhere hits predicate true for noObj key => delete _noObjMap[hash]
+    expect(m.deleteWhere((k: any) => k === 'a')).toBe(true);
+    expect(m.has('a')).toBe(false);
+
+    // not found
+    expect(m.deleteWhere(() => false)).toBe(false);
+  });
+});

package/test/unit/data-structures/hash/hash-map.toEntryFn-branch.coverage.test.ts

@@ -0,0 +1,9 @@
+import { LinkedHashMap } from '../../../../src';
+
+describe('LinkedHashMap toEntryFn remaining branch coverage', () => {
+  it('default toEntryFn returns tuple when rawElement is an entry (isEntry true branch)', () => {
+    const m = new LinkedHashMap<number, string>();
+    const fn = m.toEntryFn as (raw: any) => [number, string];
+    expect(fn([1, 'a'])).toEqual([1, 'a']);
+  });
+});

package/test/unit/data-structures/heap/heap.misc-branches.coverage.test.ts

@@ -0,0 +1,110 @@
+import { Heap, FibonacciHeap } from '../../../../src';
+
+describe('Heap / FibonacciHeap misc branch coverage', () => {
+  it('Heap.deleteBy covers not-found, idx=0 poll, idx=last pop, idx=middle splice paths', () => {
+    const h = new Heap<number>();
+    h.add(3);
+    h.add(1);
+    h.add(2);
+
+    expect(h.deleteBy(() => false)).toBe(false); // idx stays -1
+
+    // idx === 0
+    expect(h.deleteBy(x => x === h.peek())).toBe(true);
+
+    // ensure at least 2 elems again
+    h.add(4);
+    h.add(5);
+
+    // idx === last
+    const last = (h as any).elements[(h as any).elements.length - 1];
+    expect(h.deleteBy(x => x === last)).toBe(true);
+
+    // idx in middle
+    const mid = (h as any).elements[1];
+    expect(h.deleteBy(x => x === mid)).toBe(true);
+  });
+
+  it('Heap.filter covers thisArg branch and else(i++) branch', () => {
+    const h = new Heap<number>();
+    h.add(1);
+    h.add(2);
+    h.add(3);
+
+    const ctx = { ok: true };
+    const out = h.filter(function (this: any, x: number) {
+      // keep only one element so the else branch runs too
+      return this.ok && x === 2;
+    }, ctx);
+
+    expect(out.toArray()).toEqual([2]);
+  });
+
+  it('Heap.map throws when comparator missing, and uses thisArg branch when provided', () => {
+    const h = new Heap<number>();
+    h.add(1);
+    h.add(2);
+
+    expect(() => h.map(x => ({ x }), {} as any)).toThrow(/requires options\.comparator/i);
+
+    const ctx = { mul: 10 };
+    const mapped = h.map(
+      function (this: any, x: number) {
+        return x * this.mul;
+      },
+      { comparator: (a: number, b: number) => a - b },
+      ctx
+    );
+
+    expect(mapped.peek()).toBe(10);
+  });
+
+  it('Heap.mapSame covers thisArg branch', () => {
+    const h = new Heap<number>();
+    h.add(1);
+    h.add(3);
+
+    const ctx = { add: 7 };
+    const out = h.mapSame(function (this: any, x: number) {
+      return x + this.add;
+    }, ctx);
+
+    expect(out.peek()).toBe(8);
+  });
+
+  it('Heap._createLike default-arg path can be called via (heap as any)._createLike()', () => {
+    const h = new Heap<number>();
+    const like = (h as any)._createLike();
+    expect(like.size).toBe(0);
+  });
+
+  it('FibonacciHeap constructor throws when comparator is not a function', () => {
+    expect(() => new FibonacciHeap<number>(123 as any)).toThrow(/comparator must be a function/i);
+  });
+
+  it('FibonacciHeap.consumeLinkedList(undefined) returns [] (covers !head guard)', () => {
+    const fh = new FibonacciHeap<number>();
+    expect(fh.consumeLinkedList(undefined)).toEqual([]);
+  });
+
+  it('FibonacciHeap.merge covers empty-merge early return, empty-this adopt-root, and non-empty root-merge', () => {
+    const a = new FibonacciHeap<number>();
+    const b = new FibonacciHeap<number>();
+
+    // empty merge early return
+    a.merge(b);
+    expect(a.size).toBe(0);
+
+    // empty-this adopt-root
+    b.add(5);
+    a.merge(b);
+    expect(a.size).toBe(1);
+
+    // non-empty root-merge + min update paths
+    const c = new FibonacciHeap<number>();
+    c.add(1);
+    c.add(10);
+    a.merge(c);
+    expect(a.peek()).toBe(1);
+  });
+});

package/test/unit/data-structures/heap/heap.remaining-branches.coverage.test.ts

@@ -0,0 +1,22 @@
+import { Heap } from '../../../../src';
+
+describe('Heap remaining branch coverage', () => {
+  it('Heap.map with options undefined hits (options ?? {}) path and throws for missing comparator', () => {
+    const h = new Heap<number>();
+    h.add(1);
+    expect(() => (h as any).map((x: number) => x, undefined)).toThrow(/requires options\.comparator/i);
+  });
+
+  it('Heap.mapSame without thisArg hits thisArg===undefined branch', () => {
+    const h = new Heap<number>();
+    h.add(1);
+    h.add(2);
+    const out = h.mapSame(x => x * 2);
+    expect(out.toArray().sort((a, b) => a - b)).toEqual([2, 4]);
+  });
+
+  it('Heap default comparator throws when comparing object types', () => {
+    const h = new Heap<any>();
+    expect(() => (h as any)._DEFAULT_COMPARATOR({}, 1)).toThrow(TypeError);
+  });
+});

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

@@ -0,0 +1,29 @@
+import { MaxHeap } from '../../../../src';
+
+/**
+ * Coverage-focused test for MaxHeap comparator branches.
+ * Keep existing @example tests intact.
+ */
+describe('MaxHeap coverage', () => {
+  it('orders numbers as a max-heap (a<b / a>b / equal branches)', () => {
+    const h = new MaxHeap<number>();
+
+    h.add(2);
+    h.add(1);
+    h.add(3);
+    h.add(3); // equal branch exercised during comparisons
+
+    expect(h.peek()).toBe(3);
+    expect(h.poll()).toBe(3);
+    expect(h.poll()).toBe(3);
+    expect(h.poll()).toBe(2);
+    expect(h.poll()).toBe(1);
+    expect(h.poll()).toBe(undefined);
+  });
+
+  it('throws when comparing object types without custom comparator', () => {
+    const h = new MaxHeap<any>();
+    h.add({ k: 1 });
+    expect(() => h.add({ k: 2 })).toThrow(TypeError);
+  });
+});

package/test/unit/data-structures/linked-list/doubly-linked-list.more-branches.coverage.test.ts

@@ -0,0 +1,72 @@
+import { DoublyLinkedList, DoublyLinkedListNode } from '../../../../src';
+
+describe('DoublyLinkedList additional branch coverage', () => {
+  it('unshiftMany uses toElementFn branch when provided', () => {
+    const l = new DoublyLinkedList<number, { v: number }>([], {
+      toElementFn: r => r.v
+    });
+    expect(l.unshiftMany([{ v: 1 }, { v: 2 }])).toEqual([true, true]);
+    expect(l.toArray()).toEqual([2, 1]);
+  });
+
+  it('getNode(undefined) returns undefined (covers early return)', () => {
+    const l = new DoublyLinkedList<number>();
+    l.pushMany([1, 2]);
+    expect(l.getNode(undefined)).toBeUndefined();
+  });
+
+  it('setAt returns false when node does not exist', () => {
+    const l = new DoublyLinkedList<number>();
+    expect(l.setAt(0, 1)).toBe(false);
+  });
+
+  it('search returns value when predicate matches (covers predicate(current) true branch)', () => {
+    const l = new DoublyLinkedList<number>();
+    l.pushMany([1, 2, 3]);
+    expect(l.search(n => n.value === 2)).toBe(2);
+  });
+
+  it('mapSame covers both thisArg branches', () => {
+    const l = new DoublyLinkedList<number>();
+    l.pushMany([1, 2]);
+
+    // thisArg === undefined arm
+    expect(l.mapSame(v => v + 1).toArray()).toEqual([2, 3]);
+
+    // thisArg provided arm
+    const ctx = { add: 10 };
+    expect(
+      l
+        .mapSame(function (this: any, v: number) {
+          return v + this.add;
+        }, ctx)
+        .toArray()
+    ).toEqual([11, 12]);
+  });
+
+  it('_ensureNode returns the same node when input is a node (covers isNode true branch)', () => {
+    const l = new DoublyLinkedList<number>();
+    l.pushMany([1, 3]);
+
+    const existing = l.getNodeAt(0)!;
+    const newNode = new DoublyLinkedListNode(2);
+
+    // addAfter calls _ensureNode(newElementOrNode)
+    expect(l.addAfter(existing, newNode)).toBe(true);
+    expect(l.toArray()).toEqual([1, 2, 3]);
+  });
+
+  it('_ensurePredicate covers isNode(target) branch via search(node)', () => {
+    const l = new DoublyLinkedList<number>();
+    l.pushMany([1, 2, 3]);
+
+    const target = l.getNodeAt(1)!;
+    expect(l.search(target)).toBe(2);
+  });
+
+  it('_createLike default-arg path can be called with no args', () => {
+    const l = new DoublyLinkedList<number>();
+    const like = (l as any)._createLike();
+    expect(like.length).toBe(0);
+  });
+});