data-structure-typed 2.2.7 → 2.3.0

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

@@ -0,0 +1,334 @@
+import { RedBlackTree, RedBlackTreeNode } from '../../../../src';
+
+
+function validateRedBlackTree<K, V>(tree: RedBlackTree<K, V>) {
+  const NIL = tree.NIL as unknown as RedBlackTreeNode<K, V>;
+  const root = tree.root as unknown as RedBlackTreeNode<K, V> | undefined;
+
+  // Empty tree is valid.
+  if (!root || root === NIL) return;
+
+  // Root must be black.
+  expect(root.color).toBe('BLACK');
+
+  const seen = new Set<RedBlackTreeNode<K, V>>();
+
+  const check = (
+    node: RedBlackTreeNode<K, V>,
+    parent: RedBlackTreeNode<K, V> | undefined,
+    min: any,
+    max: any
+  ) => {
+    if (node === NIL) return;
+
+    // Basic structural sanity
+    expect(node).toBeInstanceOf(RedBlackTreeNode);
+    // Some implementations keep root.parent as undefined; tolerate that.
+    if (parent !== undefined) {
+      expect(node.parent === parent || node.parent === undefined).toBe(true);
+    }
+
+    // No cycles
+    expect(seen.has(node)).toBe(false);
+    seen.add(node);
+
+    // BST ordering (strict)
+    if (min !== undefined) expect((node.key as any) > min).toBe(true);
+    if (max !== undefined) expect((node.key as any) < max).toBe(true);
+
+    const left = (node.left ?? NIL) as RedBlackTreeNode<K, V>;
+    const right = (node.right ?? NIL) as RedBlackTreeNode<K, V>;
+
+    // Red property
+    if (node.color === 'RED') {
+      expect(left.color).toBe('BLACK');
+      expect(right.color).toBe('BLACK');
+    }
+
+    check(left, node, min, node.key as any);
+    check(right, node, node.key as any, max);
+  };
+
+  check(root, root.parent, undefined, undefined);
+}
+
+describe('RedBlackTree coverage push (keep @example tests intact)', () => {
+  it('RedBlackTreeNode.familyPosition covers ROOT/LEFT/RIGHT/ISOLATED cases', () => {
+    const isolated = new RedBlackTreeNode<number, number>(1);
+    expect(isolated.familyPosition).toBe('ISOLATED');
+
+    // Root without parent but with a child
+    const root = new RedBlackTreeNode<number, number>(10);
+    const left = new RedBlackTreeNode<number, number>(5);
+    root.left = left;
+    left.parent = root;
+    expect(root.familyPosition).toBe('ROOT');
+
+    // Left child leaf
+    expect(left.familyPosition).toBe('LEFT');
+
+    // Left child that itself has a child -> ROOT_LEFT
+    left.left = new RedBlackTreeNode<number, number>(2);
+    left.left.parent = left;
+    expect(left.familyPosition).toBe('ROOT_LEFT');
+
+    // Right child leaf
+    const right = new RedBlackTreeNode<number, number>(15);
+    root.right = right;
+    right.parent = root;
+    expect(right.familyPosition).toBe('RIGHT');
+
+    // Right child with its own child -> ROOT_RIGHT
+    right.right = new RedBlackTreeNode<number, number>(20);
+    right.right.parent = right;
+    expect(right.familyPosition).toBe('ROOT_RIGHT');
+  });
+
+  it('clear() resets root/header caches and keeps tree usable', () => {
+    const t = new RedBlackTree<number, number>();
+    t.set(2, 2);
+    t.set(1, 1);
+    t.set(3, 3);
+
+    expect(t.size).toBe(3);
+    expect(t.get(2)).toBe(2);
+
+    t.clear();
+
+    expect(t.size).toBe(0);
+    // Internal root is reset to NIL.
+    expect(t.root).toBe(t.NIL);
+    expect(t.get(2)).toBe(undefined);
+
+    // Can insert again after clear
+    t.set(4, 4);
+    expect(t.size).toBe(1);
+    expect(t.get(4)).toBe(4);
+  });
+
+  it('setWithHintNode covers fast-attach + fallback branches (map mode)', () => {
+    // Default is map-mode.
+    const t = new RedBlackTree<number, string>();
+
+    // Seed tree
+    t.set(10, 'a');
+    t.set(20, 'b');
+    t.set(5, 'c');
+
+    const hint10 = t.getNode(10)!;
+
+    // c0 === 0 update branch
+    const same = t.setWithHintNode(10, 'a2', hint10);
+    expect(same).toBe(hint10);
+    expect(t.get(10)).toBe('a2');
+
+    // c0 < 0 and direct attach to hint.left (empty)
+    const n7 = t.setWithHintNode(7, 'v7', hint10);
+    expect(n7?.key).toBe(7);
+    expect(t.get(7)).toBe('v7');
+
+    // c0 > 0 direct attach to hint.right (empty)
+    const n15 = t.setWithHintNode(15, 'v15', hint10);
+    expect(n15?.key).toBe(15);
+    expect(t.get(15)).toBe('v15');
+
+    // Force predecessor/successor branches:
+    // Insert near left side using a "bad" hint so it needs pred logic.
+    const hint20 = t.getNode(20)!;
+    const n17 = t.setWithHintNode(17, 'v17', hint20);
+    expect(n17?.key).toBe(17);
+    expect(t.get(17)).toBe('v17');
+
+    // Insert near right side using a "bad" hint so it needs succ logic.
+    const hint5 = t.getNode(5)!;
+    const n6 = t.setWithHintNode(6, 'v6', hint5);
+    expect(n6?.key).toBe(6);
+    expect(t.get(6)).toBe('v6');
+
+    // value === undefined in map mode should take the _setValue path, not store.set fast path
+    t.setWithHintNode(99, undefined as any, hint20);
+    expect(t.has(99)).toBe(true);
+  });
+
+  it('setWithHintNode covers hint invalid + pred/succ early-fallback branches + set-mode update', () => {
+    // hint invalid => fallback
+    const t = new RedBlackTree<number, string>();
+    t.set(10, 'a');
+    t.set(20, 'b');
+    t.set(5, 'c');
+
+    const other = new RedBlackTree<number, string>();
+    other.set(10, 'x');
+    const foreignHint = other.getNode(10)!;
+
+    // foreign hint should be treated as invalid for this tree; must still insert correctly.
+    const n1 = t.setWithHintNode(1, 'v1', foreignHint as any);
+    expect(n1?.key).toBe(1);
+    expect(t.get(1)).toBe('v1');
+
+    // pred early-fallback: choose hint=10, but key far left so predecessor key >= key
+    const hint10 = t.getNode(10)!;
+    const n0 = t.setWithHintNode(0, 'v0', hint10);
+    expect(n0?.key).toBe(0);
+    expect(t.get(0)).toBe('v0');
+
+    // succ early-fallback: choose hint=10, but key far right so successor key <= key
+    const n30 = t.setWithHintNode(30, 'v30', hint10);
+    expect(n30?.key).toBe(30);
+    expect(t.get(30)).toBe('v30');
+
+    // set-mode update branch (c0===0 but not map-mode)
+    const s = new RedBlackTree<number, string>([], { isMapMode: false });
+    s.set(10, 'a');
+    const h = s.getNode(10)!;
+    expect(h.value).toBe('a');
+    const same = s.setWithHintNode(10, 'b', h);
+    expect(same).toBe(h);
+    expect(s.getNode(10)?.value).toBe('b');
+  });
+
+  it('_setKV map-mode fast-path updates store without changing size', () => {
+    const t = new RedBlackTree<number, string>();
+    t.set(1, 'a');
+    const n1 = t.getNode(1);
+    expect(t.size).toBe(1);
+
+    // nextValue !== undefined and store.has(key) => fast-path
+    t.set(1, 'b');
+    expect(t.size).toBe(1);
+    expect(t.get(1)).toBe('b');
+    expect(t.getNode(1)).toBe(n1);
+
+    // undefined value should still be allowed, but will not take store fast-path
+    t.set(1, undefined as any);
+    expect(t.size).toBe(1);
+    expect(t.has(1)).toBe(true);
+  });
+
+  it('internal helpers: _findNodeByKey/_predecessorOf/_successorOf', () => {
+    const t = new RedBlackTree<number, number>();
+
+    // Empty tree: find returns undefined
+    expect((t as any)._findNodeByKey(1)).toBe(undefined);
+
+    // Build small tree
+    for (const k of [10, 5, 15, 3, 7, 12, 18]) t.set(k, k);
+
+    const n10 = t.getNode(10)!;
+    const n3 = t.getNode(3)!;
+    const n18 = t.getNode(18)!;
+
+    // _findNodeByKey hits <, >, and === branches
+    expect((t as any)._findNodeByKey(7)?.key).toBe(7);
+    expect((t as any)._findNodeByKey(999)).toBe(undefined);
+
+    // predecessor: node with left subtree
+    expect((t as any)._predecessorOf(n10)?.key).toBe(7);
+    // predecessor: minimum has none
+    expect((t as any)._predecessorOf(n3)).toBe(undefined);
+
+    // successor: node with right subtree
+    expect((t as any)._successorOf(n10)?.key).toBe(12);
+    // successor: maximum has none
+    expect((t as any)._successorOf(n18)).toBe(undefined);
+  });
+  const expectContentsMatch = (tree: RedBlackTree<number, number>, present: Set<number>) => {
+    for (let k = 0; k < 500; k++) {
+      expect(tree.has(k)).toBe(present.has(k));
+    }
+  };
+
+  it('random mixed insert/delete sequences keep invariants (exercise fixups/rotations)', () => {
+    // Deterministic pseudo-random generator (LCG) for reproducibility
+    let seed = 123456789;
+    const rand = () => {
+      seed = (1103515245 * seed + 12345) % 0x80000000;
+      return seed;
+    };
+
+    for (let round = 0; round < 20; round++) {
+      const tree = new RedBlackTree<number, number>();
+      const present = new Set<number>();
+
+      // Insert some keys
+      for (let i = 0; i < 200; i++) {
+        const k = rand() % 500;
+        tree.set(k, k);
+        present.add(k);
+      }
+      validateRedBlackTree(tree);
+
+      // Random deletes + reinserts
+      for (let i = 0; i < 400; i++) {
+        const op = rand() % 3;
+        const k = rand() % 500;
+        if (op === 0) {
+          tree.set(k, k);
+          present.add(k);
+        } else {
+          tree.delete(k);
+          present.delete(k);
+        }
+        if (i % 25 === 0) validateRedBlackTree(tree);
+      }
+
+      // Spot-check final contents agree with Set
+      expectContentsMatch(tree, present);
+      validateRedBlackTree(tree);
+    }
+  });
+
+  it('targeted delete sequences (both sides) keep invariants and contents', () => {
+    const run = (keys: number[], deletes: number[]) => {
+      const t = new RedBlackTree<number, number>();
+      const present = new Set<number>();
+      for (const k of keys) {
+        t.set(k, k);
+        present.add(k);
+      }
+      validateRedBlackTree(t);
+      expectContentsMatch(t, present);
+
+      for (const d of deletes) {
+        t.delete(d);
+        present.delete(d);
+        validateRedBlackTree(t);
+        expectContentsMatch(t, present);
+      }
+
+      // Iteration yields sorted keys
+      const remaining = [...t].map(([k]) => k);
+      const sorted = [...remaining].sort((a, b) => a - b);
+      expect(remaining).toEqual(sorted);
+    };
+
+    // A fairly dense keyset; deletes include leaves, internal nodes, and root-ish nodes.
+    const keysA = [20, 10, 30, 5, 15, 25, 40, 1, 7, 12, 17, 22, 27, 35, 50, 6, 8, 11, 13, 16, 18];
+    run(keysA, [1, 7, 8, 10, 12, 15, 16, 17, 20, 22, 25]);
+
+    // Mirror-ish construction (different insertion order), tends to hit opposite-side fixups.
+    const keysB = [30, 20, 40, 10, 25, 35, 50, 5, 15, 22, 27, 33, 37, 45, 55, 1, 7, 12, 17];
+    run(keysB, [55, 50, 45, 40, 37, 35, 33, 30, 27, 25, 22]);
+  });
+
+  it('deletes exercise mirror fixup sides (left/right) with deterministic shape', () => {
+    // Build a tree with enough structure to trigger both sides of _deleteFixup
+    const t = new RedBlackTree<number, number>();
+    const keys = [11, 2, 14, 1, 7, 15, 5, 8, 4, 6, 3, 13, 12, 10, 9];
+    for (const k of keys) t.set(k, k);
+
+    validateRedBlackTree(t);
+
+    // Delete sequence designed to hit different sibling/child color cases.
+    // (The exact rotations may vary, but this tends to traverse many fixup branches.)
+    for (const k of [1, 14, 2, 15, 7, 11, 8, 6, 5]) {
+      t.delete(k);
+      validateRedBlackTree(t);
+    }
+
+    // Remaining keys should still be searchable and ordered
+    const remaining = [...t].map(([k]) => k);
+    const sorted = [...remaining].sort((a, b) => a - b);
+    expect(remaining).toEqual(sorted);
+  });
+});

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

@@ -0,0 +1,68 @@
+import { RedBlackTree, RedBlackTreeNode } from '../../../../src';
+
+function validateRedBlackTree<K, V>(tree: RedBlackTree<K, V>) {
+  const NIL = tree.NIL as unknown as RedBlackTreeNode<K, V>;
+  const root = tree.root as unknown as RedBlackTreeNode<K, V> | undefined;
+  if (!root || root === NIL) return;
+  expect(root.color).toBe('BLACK');
+
+  const seen = new Set<RedBlackTreeNode<K, V>>();
+
+  const check = (node: RedBlackTreeNode<K, V>, min: any, max: any) => {
+    if (node === NIL) return;
+    expect(seen.has(node)).toBe(false);
+    seen.add(node);
+
+    if (min !== undefined) expect((node.key as any) > min).toBe(true);
+    if (max !== undefined) expect((node.key as any) < max).toBe(true);
+
+    const left = (node.left ?? NIL) as RedBlackTreeNode<K, V>;
+    const right = (node.right ?? NIL) as RedBlackTreeNode<K, V>;
+
+    if (node.color === 'RED') {
+      expect(left.color).toBe('BLACK');
+      expect(right.color).toBe('BLACK');
+    }
+
+    check(left, min, node.key as any);
+    check(right, node.key as any, max);
+  };
+
+  check(root, undefined, undefined);
+}
+
+describe('RedBlackTree delete-fixup coverage', () => {
+  it('CLRS-style delete sequence exercises multiple fixup branches', () => {
+    // Classic CLRS insertion set.
+    const t = new RedBlackTree<number, number>();
+    for (const k of [7, 3, 18, 10, 22, 8, 11, 26]) t.set(k, k);
+    validateRedBlackTree(t);
+
+    // Deletes from CLRS examples / common RB delete discussions.
+    for (const k of [18, 11, 3, 10, 22, 26, 8, 7]) {
+      t.delete(k);
+      validateRedBlackTree(t);
+    }
+
+    expect(t.size).toBe(0);
+  });
+
+  it('deleting many black leaves triggers fixup in both left/right sibling orientations', () => {
+    const t = new RedBlackTree<number, number>();
+    // Build a reasonably balanced tree.
+    for (let i = 1; i <= 31; i++) t.set(i, i);
+    validateRedBlackTree(t);
+
+    // Delete odds then evens.
+    for (let i = 1; i <= 31; i += 2) {
+      t.delete(i);
+      validateRedBlackTree(t);
+    }
+    for (let i = 2; i <= 30; i += 2) {
+      t.delete(i);
+      validateRedBlackTree(t);
+    }
+
+    expect(t.size).toBe(0);
+  });
+});

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

@@ -0,0 +1,75 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree delete() successor/transplant branch coverage', () => {
+  it('covers successor.parent === nodeToDelete with real replacementNode (sets replacement.parent = successor)', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+
+    // Build:
+    //      10
+    //     /  \
+    //    5   15
+    //          \
+    //          20
+    for (const k of [10, 5, 15, 20]) t.set(k, k);
+
+    const n20 = t.getNode(20)!;
+    expect(n20.parent?.key).toBe(15);
+
+    t.delete(10);
+
+    // successor should be 15; replacement should be 20 (real), and its parent should be set to successor.
+    expect(t.has(10)).toBe(false);
+    expect(t.has(5)).toBe(true);
+    expect(t.has(15)).toBe(true);
+    expect(t.has(20)).toBe(true);
+
+    expect(t.getNode(20)?.parent?.key).toBe(15);
+  });
+
+  it('covers successor.parent === nodeToDelete with non-real replacementNode (skips replacement.parent assignment)', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+
+    // Build:
+    //      10
+    //     /  \
+    //    5   15
+    // Successor is 15; successor.right is NIL (replacement non-real).
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    const s15 = t.getNode(15)!;
+    // Ensure right is NIL (not null), so replacementNode will be non-real and guard is exercised.
+    s15._right = t.NIL as any;
+
+    t.delete(10);
+
+    expect(t.has(10)).toBe(false);
+    expect(t.has(5)).toBe(true);
+    expect(t.has(15)).toBe(true);
+  });
+
+  it('covers successor.parent !== nodeToDelete branch (transplant successor, then rewire successor.right)', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+
+    // Build right subtree where left-most successor is deeper:
+    //        10
+    //       /  \
+    //      5    20
+    //          /  \
+    //         15  25
+    //        /
+    //       13   (successor of 10)
+    for (const k of [10, 5, 20, 15, 25, 13]) t.set(k, k);
+
+    const s13 = t.getNode(13)!;
+    expect(s13.parent?.key).toBe(15);
+
+    t.delete(10);
+
+    expect(t.has(10)).toBe(false);
+    // successor (13) should now be in the deleted node's position and have right subtree attached.
+    const newRoot = (t as any)._root;
+    expect(newRoot?.key).toBe(13);
+    expect(t.has(20)).toBe(true);
+    expect(t.getNode(20)?.parent?.key).toBe(13);
+  });
+});

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

@@ -0,0 +1,26 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree internal factory coverage', () => {
+  it('_createLike default iterable branch returns empty like-kind', () => {
+    const t = new RedBlackTree<number, number>();
+    t.set(1, 1);
+
+    const like = (t as any)._createLike();
+    expect(like).toBeInstanceOf(RedBlackTree);
+    expect(like.size).toBe(0);
+  });
+
+  it('_createInstance and _setRoot keep header.parent in sync', () => {
+    const t = new RedBlackTree<number, number>();
+
+    const inst = (t as any)._createInstance();
+    const NIL = (inst as any).NIL;
+
+    // new instance should have header.parent pointing at NIL
+    expect((inst as any)._header.parent).toBe(NIL);
+
+    // For coverage: explicitly set root to undefined and ensure header.parent remains NIL.
+    (inst as any)._setRoot(undefined);
+    expect((inst as any)._header.parent).toBe(NIL);
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.hint-cache-compare-update.coverage.test.ts

@@ -0,0 +1,74 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree hint cache maintenance compare-update branches', () => {
+  it('direct attach left: updates min cache via compare(newKey,hMin.key) < 0 when hMin is real', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [50, 10, 100, 60]) t.set(k, k);
+    const hint = t.getNode(60)!;
+
+    // Ensure direct attach path.
+    hint._left = t.NIL as any;
+
+    const oldMin = (t as any)._header._left.key;
+    expect(oldMin).toBe(10);
+
+    t.setWithHintNode(5, 5, hint);
+    expect((t as any)._header._left.key).toBe(5);
+  });
+
+  it('direct attach right: updates max cache via compare(newKey,hMax.key) > 0 when hMax is real', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [50, 10, 100, 40]) t.set(k, k);
+    const hint = t.getNode(40)!;
+
+    // Ensure direct attach path.
+    hint._right = t.NIL as any;
+
+    const oldMax = (t as any)._header._right.key;
+    expect(oldMax).toBe(100);
+
+    t.setWithHintNode(200, 200, hint);
+    expect((t as any)._header._right.key).toBe(200);
+  });
+
+  it('pred.right attach: can update min/max cache via compare checks when inserting a new extreme', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [50, 10, 100, 60]) t.set(k, k);
+    const hint = t.getNode(60)!;
+    const pred = t.getNode(50)!;
+
+    // Force pred.right attach path.
+    pred.parent = hint as any;
+    pred._right = t.NIL as any;
+    hint._left = pred as any;
+
+    t.setWithHintNode(5, 5, hint);
+    expect((t as any)._header._left.key).toBe(5);
+  });
+
+  it('succ.left attach: can update min/max cache via compare checks when inserting a new extreme', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [50, 10, 100, 40]) t.set(k, k);
+    const hint = t.getNode(40)!;
+    const succ = t.getNode(50)!;
+
+    succ.parent = hint as any;
+    succ._left = t.NIL as any;
+    hint._right = succ as any;
+
+    t.setWithHintNode(200, 200, hint);
+    expect((t as any)._header._right.key).toBe(200);
+  });
+
+  it('_insertFixup: breaks when parent is RED but grandparent is missing (gp undefined)', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    const z = (t as any).createNode(1, 1);
+    const p = (t as any).createNode(0, 0);
+    p.color = 'RED';
+    p.parent = undefined;
+    z.parent = p;
+
+    // Should hit `if (!gp) break;` and return without throwing.
+    expect(() => (t as any)._insertFixup(z)).not.toThrow();
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.hint-cache-no-update.coverage.test.ts

@@ -0,0 +1,44 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree setWithHintNode cache-maintenance no-update branches', () => {
+  it('direct attach does not update min/max caches when inserting within existing extremes', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    // Establish extremes.
+    for (const k of [50, 1, 100]) t.set(k, k);
+
+    const hint = t.getNode(50)!;
+    expect((t as any)._header._left.key).toBe(1);
+    expect((t as any)._header._right.key).toBe(100);
+
+    // direct attach left of hint, but key is not new min/max
+    const n40 = t.setWithHintNode(40, 40, hint);
+    expect(n40?.key).toBe(40);
+    expect((t as any)._header._left.key).toBe(1);
+    expect((t as any)._header._right.key).toBe(100);
+
+    // direct attach right of hint, but still within extremes
+    const n60 = t.setWithHintNode(60, 60, hint);
+    expect(n60?.key).toBe(60);
+    expect((t as any)._header._left.key).toBe(1);
+    expect((t as any)._header._right.key).toBe(100);
+  });
+
+  it('pred.right / succ.left attach does not update min/max caches when inserting within existing extremes', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    for (const k of [50, 1, 100, 40, 60]) t.set(k, k);
+    const hint = t.getNode(50)!;
+
+    // pred.right attach: ensure hint.left is real so we take pred path.
+    expect(t.getNode(40)).toBeTruthy();
+    const n45 = t.setWithHintNode(45, 45, hint);
+    expect(n45?.key).toBe(45);
+
+    // succ.left attach: ensure hint.right is real so we take succ path.
+    expect(t.getNode(60)).toBeTruthy();
+    const n55 = t.setWithHintNode(55, 55, hint);
+    expect(n55?.key).toBe(55);
+
+    expect((t as any)._header._left.key).toBe(1);
+    expect((t as any)._header._right.key).toBe(100);
+  });
+});

package/test/unit/data-structures/binary-tree/red-black-tree.hint-cache-nullish.coverage.test.ts

@@ -0,0 +1,61 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree hint cache maintenance with nullish/NIL header caches', () => {
+  it('direct attach left/right: when header caches are NIL, hMin/hMax short-circuit branches initialize caches', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+    const hint = t.getNode(10)!;
+
+    // Corrupt caches to NIL so (hMin===NIL || ...) short-circuits true.
+    (t as any)._header._left = t.NIL;
+    (t as any)._header._right = t.NIL;
+
+    const n5 = t.setWithHintNode(5, 5, hint)!;
+    expect((t as any)._header._left).toBe(n5);
+    expect((t as any)._header._right).toBe(n5);
+
+    // Corrupt again and attach on the other side.
+    (t as any)._header._left = t.NIL;
+    (t as any)._header._right = t.NIL;
+
+    const n15 = t.setWithHintNode(15, 15, hint)!;
+    expect((t as any)._header._left).toBe(n15);
+    expect((t as any)._header._right).toBe(n15);
+
+    // Repair to real extremes to avoid leakage.
+    const root = (t as any)._root;
+    (t as any)._setMinCache(t.isRealNode(root) ? t.getLeftMost((n: any) => n, root) : undefined);
+    (t as any)._setMaxCache(t.isRealNode(root) ? t.getRightMost((n: any) => n, root) : undefined);
+  });
+
+  it('pred.right / succ.left attach: when header caches are NIL, hMin/hMax short-circuit branches initialize caches', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+    const hint = t.getNode(10)!;
+
+    // Create real left/right so we take pred/succ attach paths.
+    t.setWithHintNode(5, 5, hint);
+    t.setWithHintNode(15, 15, hint);
+
+    // pred.right attach, with caches NIL.
+    (t as any)._header._left = t.NIL;
+    (t as any)._header._right = t.NIL;
+
+    const n7 = t.setWithHintNode(7, 7, hint)!;
+    expect((t as any)._header._left).toBe(n7);
+    expect((t as any)._header._right).toBe(n7);
+
+    // succ.left attach, with caches NIL.
+    (t as any)._header._left = t.NIL;
+    (t as any)._header._right = t.NIL;
+
+    const n12 = t.setWithHintNode(12, 12, hint)!;
+    expect((t as any)._header._left).toBe(n12);
+    expect((t as any)._header._right).toBe(n12);
+
+    // Repair to real extremes.
+    const root = (t as any)._root;
+    (t as any)._setMinCache(t.isRealNode(root) ? t.getLeftMost((n: any) => n, root) : undefined);
+    (t as any)._setMaxCache(t.isRealNode(root) ? t.getRightMost((n: any) => n, root) : undefined);
+  });
+});