data-structure-typed 2.2.7 → 2.3.0

package/test/unit/data-structures/binary-tree/red-black-tree.predsucc.coverage.test.ts

@@ -0,0 +1,40 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree predecessor/successor coverage', () => {
+  it('covers predecessor/successor: subtree-walk, parent-climb, and undefined edges', () => {
+    const t = new RedBlackTree<number, string>([], { isMapMode: false });
+
+    // Build a tree with nodes that have (and do not have) left/right subtrees.
+    //            20
+    //         /      \
+    //       10        30
+    //     /   \     /   \
+    //    5    15   25   35
+    //        /
+    //       13
+    for (const k of [20, 10, 30, 5, 15, 25, 35, 13]) t.set(k, String(k));
+
+    const n20 = t.getNode(20)!;
+    const n15 = t.getNode(15)!;
+    const n5 = t.getNode(5)!;
+    const n35 = t.getNode(35)!;
+
+    // predecessor: has left subtree -> walk to right-most of left.
+    expect((t as any)._predecessorOf(n15)?.key).toBe(13);
+
+    // predecessor: no left subtree -> climb parents.
+    expect((t as any)._predecessorOf(n20)?.key).toBe(15);
+
+    // predecessor of min -> undefined.
+    expect((t as any)._predecessorOf(n5)).toBeUndefined();
+
+    // successor: has right subtree -> walk to left-most of right.
+    expect((t as any)._successorOf(n20)?.key).toBe(25);
+
+    // successor: no right subtree -> climb parents.
+    expect((t as any)._successorOf(n15)?.key).toBe(20);
+
+    // successor of max -> undefined.
+    expect((t as any)._successorOf(n35)).toBeUndefined();
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.remaining-branches.coverage.test.ts

@@ -0,0 +1,123 @@
+import { RedBlackTree } from '../../../../src';
+
+class RBTTransplantCorruptRoot extends RedBlackTree<number, number> {
+  protected override _transplant(u: any, v: any): void {
+    super._transplant(u, v);
+    // Corrupt _root only (header.parent remains canonical), so delete() fallback cond-expr
+    // `this.isRealNode(this._root) ? ... : undefined` can take the false branch.
+    (this as any)._root = this.NIL;
+  }
+}
+
+describe('RedBlackTree remaining-branch coverage', () => {
+  it('covers hint cache-maintenance binary-expr false paths (no cache update)', () => {
+    // direct attach left: hint.left empty, but extremes exist elsewhere.
+    const t1 = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [50, 1, 100, 60]) t1.set(k, k);
+    const h60 = t1.getNode(60)!;
+
+    // Force hint.left to be empty (but keep global min/max as real).
+    h60._left = t1.NIL as any;
+
+    const min1 = (t1 as any)._header._left.key;
+    const max1 = (t1 as any)._header._right.key;
+
+    t1.setWithHintNode(55, 55, h60);
+    expect((t1 as any)._header._left.key).toBe(min1);
+    expect((t1 as any)._header._right.key).toBe(max1);
+
+    // direct attach right: hint.right empty.
+    const t2 = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [50, 1, 100, 40]) t2.set(k, k);
+    const h40 = t2.getNode(40)!;
+
+    h40._right = t2.NIL as any;
+
+    const min2 = (t2 as any)._header._left.key;
+    const max2 = (t2 as any)._header._right.key;
+
+    t2.setWithHintNode(45, 45, h40);
+    expect((t2 as any)._header._left.key).toBe(min2);
+    expect((t2 as any)._header._right.key).toBe(max2);
+
+    // pred.right attach: force hint.left to be a predecessor whose right slot is empty.
+    const t3 = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [50, 1, 100, 60]) t3.set(k, k);
+    const h60b = t3.getNode(60)!;
+    const pred40 = t3.getNode(50)!; // reuse an existing real node as predecessor anchor
+
+    pred40.parent = h60b as any;
+    pred40._right = t3.NIL as any;
+    h60b._left = pred40 as any;
+
+    const min3 = (t3 as any)._header._left.key;
+    const max3 = (t3 as any)._header._right.key;
+
+    t3.setWithHintNode(55, 55, h60b);
+    expect((t3 as any)._header._left.key).toBe(min3);
+    expect((t3 as any)._header._right.key).toBe(max3);
+
+    // succ.left attach: force hint.right to be a successor whose left slot is empty.
+    const t4 = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [50, 1, 100, 40]) t4.set(k, k);
+    const h40b = t4.getNode(40)!;
+    const succ60 = t4.getNode(50)!; // reuse an existing real node as successor anchor
+
+    succ60.parent = h40b as any;
+    succ60._left = t4.NIL as any;
+    h40b._right = succ60 as any;
+
+    const min4 = (t4 as any)._header._left.key;
+    const max4 = (t4 as any)._header._right.key;
+
+    t4.setWithHintNode(45, 45, h40b);
+    expect((t4 as any)._header._left.key).toBe(min4);
+    expect((t4 as any)._header._right.key).toBe(max4);
+  });
+
+  it('covers _setKVNode boundary max update mapMode branches (defined + undefined)', () => {
+    const t = new RedBlackTree<number, string>(); // mapMode default
+    t.set(10, 'mid');
+    t.set(5, 'min');
+    t.set(15, 'max');
+
+    // defined: should store.set
+    t.set(15, 'max2');
+    expect(t.get(15)).toBe('max2');
+
+    // undefined: should go through _setValue branch, preserving existing value
+    t.set(15, undefined as any);
+    expect(t.get(15)).toBe('max2');
+  });
+
+  it('covers delete(predicate) path and delete(node) ternary branch', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    // delete(predicate)
+    const r1 = t.delete((node) => node?.key === 5);
+    expect(r1.length).toBe(1);
+    expect(t.has(5)).toBe(false);
+
+    // delete(node)
+    const n15 = t.getNode(15)!;
+    const r2 = t.delete(n15);
+    expect(r2.length).toBe(1);
+    expect(t.has(15)).toBe(false);
+  });
+
+  it('covers delete cache fallback cond-expr false branch when _root is corrupted to NIL', () => {
+    const t = new RBTTransplantCorruptRoot([], { isMapMode: false });
+    for (const k of [10, 5, 15, 1, 20]) t.set(k, k);
+
+    // Force fallback recompute block by corrupting min/max nodes.
+    (t as any)._minNode = undefined;
+    (t as any)._maxNode = undefined;
+
+    // Delete a node so size remains >0.
+    t.delete(1);
+
+    // Restore root so subsequent operations/tests aren't affected.
+    (t as any)._root = (t as any)._header.parent;
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.set-inputs.coverage.test.ts

@@ -0,0 +1,64 @@
+import { RedBlackTree, RedBlackTreeNode } from '../../../../src';
+
+class RBTWithBadInsert extends RedBlackTree<number, number> {
+  // Simulate an internal failure where _insert reports CREATED but does not establish a real root.
+  // This is purely to cover the defensive branch in set(node).
+  protected override _insert(_node: RedBlackTreeNode<number, number>): any {
+    // Ensure root stays NIL/undefined
+    (this as any)._setRoot(undefined);
+    return 'CREATED';
+  }
+}
+
+describe('RedBlackTree set() input/defensive branches coverage', () => {
+  it('returns false for nullish key inputs in key/entry paths', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+
+    expect(t.set(null as any)).toBe(false);
+    expect(t.set(undefined as any)).toBe(false);
+
+    // entry with null/undefined key
+    expect(t.set([null as any, 1] as any)).toBe(false);
+    expect(t.set([undefined as any, 1] as any)).toBe(false);
+  });
+
+  it('key-only path delegates to _setKV and supports mapMode fast path', () => {
+    const t = new RedBlackTree<number, number>(); // mapMode default
+
+    // insert
+    expect(t.set(1, 10)).toBe(true);
+    expect(t.get(1)).toBe(10);
+
+    // update should hit _setKV fast-path (store.has)
+    expect(t.set(1, 20)).toBe(true);
+    expect(t.get(1)).toBe(20);
+
+    // update for missing key must fall through to _setKVNode
+    expect(t.set(2, 200)).toBe(true);
+    expect(t.get(2)).toBe(200);
+  });
+
+  it('node insertion path: defensive branch returns false when root is not real after CREATED', () => {
+    const t = new RBTWithBadInsert([], { isMapMode: false });
+    const n = new RedBlackTreeNode<number, number>(1, 1, 'BLACK');
+
+    expect(t.set(n)).toBe(false);
+    expect(t.size).toBe(0);
+  });
+
+  it('node insertion path: UPDATED branch returns true and updates mapMode store via _setValue', () => {
+    const t = new RedBlackTree<number, number>();
+
+    // First insert via node
+    const n1 = new RedBlackTreeNode<number, number>(1, 0 as any, 'BLACK');
+    expect(t.set(n1, 10)).toBe(true);
+    expect(t.get(1)).toBe(10);
+
+    // Second node with same key should trigger UPDATED in _insert -> set() UPDATED branch.
+    const n1b = new RedBlackTreeNode<number, number>(1, 0 as any, 'BLACK');
+    expect(t.set(n1b, 99)).toBe(true);
+
+    // mapMode uses _setValue, so value should reflect newValue.
+    expect(t.get(1)).toBe(99);
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.setkvnode-parent-cache.coverage.test.ts

@@ -0,0 +1,79 @@
+import { RedBlackTree, RedBlackTreeNode } from '../../../../src';
+
+class RBTBadKeyValue extends RedBlackTree<number, number> {
+  // Force set(node) to hit `if (!this.isRealNode(newNode)) return false;`
+  protected override _keyValueNodeOrEntryToNodeAndValue(
+    _keyNodeOrEntry: any,
+    _value?: any
+  ): [RedBlackTreeNode<number, number> | undefined, number | undefined] {
+    return [undefined, undefined];
+  }
+}
+
+describe('RedBlackTree _setKVNode parent==hMin/hMax cache maintenance coverage', () => {
+  it('post-insert cache maintenance: parent===hMax && lastCompared>0 updates max cache when header._right is corrupted to an interior node', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15, 1, 20]) t.set(k, k);
+
+    const n10 = t.getNode(10)!;
+
+    // Corrupt header max cache to an interior node that already has a right subtree,
+    // so boundary max attach fast-path is skipped.
+    (t as any)._header._right = n10;
+
+    // Insert a key that will attach as the right child of 10 in the normal path.
+    // (10.right exists (15), so it will descend; but 13 will attach as left of 15, not 10.
+    // So ensure 10.right is empty for parent===hMax; but that would re-enable boundary.
+    // Instead, force shape: make 10.right NIL temporarily (only for this coverage test).
+    n10._right = t.NIL as any;
+
+    // With corrupted hMax=10 and 10.right NIL, boundary block would try to attach as right of maxN;
+    // but boundary block only runs when cMin>0 with minN=header._left. Keep minN such that cMin<=0 by corrupting min to a larger key.
+    (t as any)._header._left = n10;
+
+    t.set(12, 12);
+
+    // Should have updated max cache to the newly inserted node via parent===hMax branch.
+    expect((t as any)._header._right.key).toBe(12);
+
+    // Repair caches (best-effort).
+    const root = (t as any)._header.parent;
+    (t as any)._root = root;
+    (t as any)._setMinCache(t.getLeftMost((x: any) => x, root));
+    (t as any)._setMaxCache(t.getRightMost((x: any) => x, root));
+  });
+
+  it('post-insert cache maintenance: parent===hMin && lastCompared<0 updates min cache when header._left is corrupted to an interior node', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15, 1, 20]) t.set(k, k);
+
+    const n10 = t.getNode(10)!;
+
+    // Corrupt header min cache to an interior node.
+    (t as any)._header._left = n10;
+    // Ensure boundary min attach is skipped: 10.left is real by default (5), so ok.
+
+    // Insert a key that will attach as the left child of 10 (normal path):
+    // force 10.left to be NIL temporarily to make parent===10.
+    n10._left = t.NIL as any;
+
+    // Also corrupt max so we don't enter max boundary block.
+    (t as any)._header._right = n10;
+
+    t.set(7, 7);
+
+    expect((t as any)._header._left.key).toBe(7);
+
+    // Repair caches.
+    const root = (t as any)._header.parent;
+    (t as any)._root = root;
+    (t as any)._setMinCache(t.getLeftMost((x: any) => x, root));
+    (t as any)._setMaxCache(t.getRightMost((x: any) => x, root));
+  });
+
+  it('set(node) early-return branch: _keyValueNodeOrEntryToNodeAndValue returns undefined node', () => {
+    const t = new RBTBadKeyValue([], { isMapMode: false });
+    const n = new RedBlackTreeNode<number, number>(1, 1, 'BLACK');
+    expect(t.set(n, 1)).toBe(false);
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.setkvnode-remaining.coverage.test.ts

@@ -0,0 +1,44 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree _setKVNode remaining branch coverage', () => {
+  it('normal search loop takes `current.right ?? NIL` with a real right child (covers binary-expr branch)', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    // Build a tree where root has a real right child.
+    t.set(10, 10);
+    t.set(15, 15);
+    t.set(20, 20);
+
+    // Skip boundary fast paths so we go through the normal search loop.
+    (t as any)._header._left = undefined;
+
+    // Insert a key greater than root so traversal takes the right-child branch with a real node.
+    expect(t.set(25, 25)).toBe(true);
+    expect(t.has(25)).toBe(true);
+  });
+
+  it('normal update path (mapMode) hits `_setValue` when nextValue is undefined (covers if/else at update)', () => {
+    const t = new RedBlackTree<number, string>(); // mapMode default
+    t.set(10, 'a');
+    t.set(5, 'b');
+    t.set(15, 'c');
+
+    // Ensure we do NOT take boundary min/max update fast paths.
+    (t as any)._header._left = undefined;
+    (t as any)._header._right = undefined;
+
+    // Update an existing key with undefined => mapMode uses _setValue branch and preserves existing value.
+    t.set(10, undefined as any);
+    expect(t.get(10)).toBe('a');
+  });
+
+  it('boundary max-key update (mapMode) hits `_setValue` branch when nextValue is undefined', () => {
+    const t = new RedBlackTree<number, string>(); // mapMode default
+    t.set(10, 'mid');
+    t.set(5, 'min');
+    t.set(15, 'max');
+
+    // Update existing max key with undefined should take boundary cMax===0 fast-path and go through _setValue.
+    t.set(15, undefined as any);
+    expect(t.get(15)).toBe('max');
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.setkvnode-uncovered.coverage.test.ts

@@ -0,0 +1,74 @@
+import { RedBlackTree } from '../../../../src';
+
+class RBTBadFixup extends RedBlackTree<number, number> {
+  // Simulate an unexpected internal failure so `_setKVNode` hits the defensive `else return undefined`.
+  protected override _insertFixup(_node: any): void {
+    // Blow away root after "fixup".
+    (this as any)._setRoot(undefined);
+  }
+}
+
+describe('RedBlackTree _setKVNode uncovered-branch coverage', () => {
+  it('covers normal-path current=header.parent ?? NIL when header.parent is undefined (starts at NIL)', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+
+    // Force normal path (minN becomes NIL via ??) and start walk from NIL.
+    (t as any)._header._left = undefined;
+    (t as any)._header.parent = undefined;
+
+    expect(t.set(1, 1)).toBe(true);
+    expect(t.getNode(1)?.key).toBe(1);
+  });
+
+  it('covers normal-path `current.left ?? NIL` / `current.right ?? NIL` in the search loop', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+
+    // Skip boundary fast paths so we go through the normal search loop.
+    (t as any)._header._left = undefined;
+
+    // Force missing children so `?? NIL` branches are taken.
+    const root = (t as any)._header.parent;
+    root._left = undefined;
+    root._right = undefined;
+
+    expect(t.set(5, 5)).toBe(true);
+    expect(t.set(15, 15)).toBe(true);
+
+    expect(t.has(5)).toBe(true);
+    expect(t.has(15)).toBe(true);
+  });
+
+  it('covers boundary max-path reading `header._right ?? NIL` when header._right is undefined (safe comparator)', () => {
+    // Comparator that tolerates undefined keys from NIL.
+    const comparator = (a: number, b: any) => {
+      if (b === undefined || b === null) return -1; // ensures cMax < 0 so we do not attach/update under NIL
+      return a - b;
+    };
+
+    const t = new RedBlackTree<number, number>([], { isMapMode: false, comparator });
+    t.set(10, 10);
+    t.set(5, 5); // establish min
+
+    // Corrupt max cache only; boundary block should read `header._right ?? NIL`.
+    (t as any)._header._right = undefined;
+
+    // Key > min so we enter the max boundary block, but safe comparator prevents NIL-attach.
+    expect(t.set(8, 8)).toBe(true);
+    expect(t.has(8)).toBe(true);
+
+    // Repair max cache so we don't leak corruption.
+    const root = (t as any)._root;
+    (t as any)._setMaxCache(t.isRealNode(root) ? t.getRightMost((n: any) => n, root) : undefined);
+  });
+
+  it('covers defensive `return undefined` after fixup when root is not real (set returns false)', () => {
+    const t = new RBTBadFixup([], { isMapMode: false });
+
+    // Force normal path (avoid boundary attach) so we reach the fixup block.
+    (t as any)._header._left = undefined;
+
+    expect(t.set(1, 1)).toBe(false);
+    expect(t.size).toBe(0);
+  });
+});