data-structure-typed 2.4.0 → 2.4.2

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

@@ -1,49 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree delete cache fallback coverage', () => {
-  it('forces min/max fallback recomputation branches after deleting min/max', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15, 3, 7, 12, 18]) t.set(k, k);
-
-    // Delete current min and max to set willDeleteMin/Max paths.
-    const NIL = (t as any).NIL;
-    const minNode = (t as any)._header._left;
-    const maxNode = (t as any)._header._right;
-    expect(minNode).not.toBe(NIL);
-    expect(maxNode).not.toBe(NIL);
-    const minKey = minNode.key as number;
-    const maxKey = maxNode.key as number;
-
-    // After first delete, corrupt caches so fallback recompute branches run.
-    t.delete(minKey);
-    (t as any)._minNode = undefined;
-
-    // Delete max and also corrupt max cache.
-    t.delete(maxKey);
-    (t as any)._maxNode = undefined;
-
-    // Trigger an additional delete to enter the cache-update block with size>0.
-    t.delete(10);
-
-    // Should still have correct header min/max after recomputation.
-    const keys = [...t].map(([k]) => k).sort((a, b) => a - b);
-    if (keys.length > 0) {
-      expect((t as any)._header._left.key).toBe(keys[0]);
-      expect((t as any)._header._right.key).toBe(keys[keys.length - 1]);
-    }
-  });
-
-  it('size<=0 branch clears min/max caches', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    t.set(1, 1);
-
-    t.delete(1);
-
-    expect(t.size).toBe(0);
-    // expect(t.min).toBeUndefined();
-    // expect(t.max).toBeUndefined();
-    const NIL = (t as any).NIL;
-    expect((t as any)._header._left).toBe(NIL);
-    expect((t as any)._header._right).toBe(NIL);
-  });
-});

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

@@ -1,37 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree cache edge coverage', () => {
-  it('boundary min attach updates max cache when header._right is stale NIL', () => {
-    const t = new RedBlackTree<number, number>();
-    t.set(10, 10);
-
-    // Simulate stale max cache.
-    const NIL = (t as any).NIL;
-    (t as any)._header._right = NIL;
-
-    // Insert smaller than current min; min has no left -> boundary min attach path.
-    t.set(5, 5);
-
-    // After insertion, max cache should not remain NIL.
-    expect((t as any)._header._right).not.toBe(NIL);
-    expect((t as any)._maxNode).toBeDefined();
-    expect((t as any)._header._right).toBe((t as any)._maxNode);
-  });
-
-  it('boundary max attach updates min cache when header._left is stale NIL', () => {
-    const t = new RedBlackTree<number, number>();
-    t.set(10, 10);
-
-    // Simulate stale min cache.
-    const NIL = (t as any).NIL;
-    (t as any)._header._left = NIL;
-
-    // Insert greater than current max; max has no right -> boundary max attach path.
-    t.set(15, 15);
-
-    // After insertion, min cache should not remain NIL.
-    expect((t as any)._header._left).not.toBe(NIL);
-    expect((t as any)._minNode).toBeDefined();
-    expect((t as any)._header._left).toBe((t as any)._minNode);
-  });
-});

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

@@ -1,39 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree stale cache insert coverage', () => {
-  it('stale header min/max caches trigger comparison-based cache repair on insertion', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    t.set(10, 10);
-    t.set(5, 5);
-    t.set(15, 15);
-
-    const n10 = t.getNode(10)!;
-
-    // Corrupt caches to point at an interior node.
-    (t as any)._header._left = n10;
-    (t as any)._header._right = n10;
-
-    // Insert a new min (not a boundary attach, because min cache is stale and minN.left is real).
-    t.set(1, 1);
-    expect((t as any)._header._left.key).toBe(1);
-
-    // Re-corrupt and insert a new max.
-    (t as any)._header._left = n10;
-    (t as any)._header._right = n10;
-
-    t.set(20, 20);
-    expect((t as any)._header._right.key).toBe(20);
-  });
-
-  it('mapMode update with undefined value does not take store-fast-path (no throw)', () => {
-    const t = new RedBlackTree<number, string>([], { isMapMode: true });
-    t.set(1, 'a');
-    expect(t.get(1)).toBe('a');
-
-    // nextValue is undefined => should bypass map-mode store.has fast-path
-    // and go through normal set logic.
-    t.set(1, undefined as any);
-    // node-index mapMode: undefined overwrites.
-    expect(t.get(1)).toBe(undefined);
-  });
-});

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

@@ -1,334 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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);
-  });
-});