data-structure-typed 2.2.7 → 2.3.0

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

@@ -3,9 +3,9 @@ import { AVLTree, BST, RedBlackTree, TreeMultiMap } from '../../../../src';
 describe('Overall BinaryTree Test', () => {
   it('should perform various operations on BinaryTree', () => {
     const bst = new BST<number>();
-    bst.add(11);
-    bst.add(3);
-    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
+    bst.set(11);
+    bst.set(3);
+    bst.setMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
     expect(bst.size).toBe(16); // true
     bst.has(6); // true
     expect(bst.has(6)).toBe(true); // true
@@ -24,10 +24,10 @@ describe('Overall BinaryTree Test', () => {
     expect(bfsIDs[0]).toBe(11);
 
     const objBST = new BST<number, { key: number; keyA: number }>();
-    objBST.add([11, { key: 11, keyA: 11 }]);
-    objBST.add([3, { key: 3, keyA: 3 }]);
+    objBST.set([11, { key: 11, keyA: 11 }]);
+    objBST.set([3, { key: 3, keyA: 3 }]);
 
-    objBST.addMany([
+    objBST.setMany([
       [15, { key: 15, keyA: 15 }],
       [1, { key: 1, keyA: 1 }],
       [8, { key: 8, keyA: 8 }],
@@ -47,7 +47,7 @@ describe('Overall BinaryTree Test', () => {
     objBST.delete(11);
 
     const avlTree = new AVLTree();
-    avlTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
+    avlTree.setMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
     avlTree.isAVLBalanced(); // true
     expect(avlTree.isAVLBalanced()).toBe(true); // true
     avlTree.delete(10);
@@ -103,9 +103,9 @@ describe('Overall BinaryTree Test', () => {
       comparator: (a, b) => b - a
     });
     expect(avl.size).toBe(5);
-    avl.add(2);
-    avl.add(5);
-    avl.add(4);
+    avl.set(2);
+    avl.set(5);
+    avl.set(4);
     expect(avl.root?.key).toBe(3);
     expect(avl.root?.left?.key).toBe(7);
     expect(avl.root?.left?.left?.key).toBe(9);
@@ -145,11 +145,11 @@ describe('Overall BinaryTree Test', () => {
       iterationType: 'RECURSIVE'
     });
     expect(tmm.size).toBe(5);
-    tmm.add(2);
-    tmm.add(2);
-    tmm.add(2);
-    tmm.add(5);
-    tmm.add(4);
+    tmm.set(2);
+    tmm.set(2);
+    tmm.set(2);
+    tmm.set(5);
+    tmm.set(4);
     expect(tmm.root?.key).toBe(3);
     expect(tmm.root?.left?.key).toBe(1);
     expect(tmm.root?.left?.left?.key).toBe(NaN);
@@ -190,11 +190,11 @@ describe('Overall BinaryTree Test', () => {
       iterationType: 'RECURSIVE'
     });
     expect(rbTree.size).toBe(5);
-    rbTree.add(2);
-    rbTree.add(2);
-    rbTree.add(2);
-    rbTree.add(5);
-    rbTree.add(4);
+    rbTree.set(2);
+    rbTree.set(2);
+    rbTree.set(2);
+    rbTree.set(5);
+    rbTree.set(4);
     expect(rbTree.root?.key).toBe(3);
     expect(rbTree.root?.left?.key).toBe(1);
     expect(rbTree.root?.left?.left?.key).toBe(NaN);

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

@@ -0,0 +1,66 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree boundary corruption repair coverage', () => {
+  it('min-attach: when header._right is corrupted to NIL, branch mirrors max cache to new min', () => {
+    let tree: RedBlackTree<number, number> = new RedBlackTree<number>();
+    let active = false;
+    let flipped = false;
+    const comparator = (a: number, b: number) => {
+      // Flip once during the boundary pre-check, before the attach happens.
+      if (active && !flipped && tree) {
+        flipped = true;
+        (tree as any)._header._right = tree.NIL;
+      }
+      return a - b;
+    };
+
+    tree = new RedBlackTree<number, number>([], { isMapMode: false, comparator });
+    tree.set(10, 10);
+    tree.set(5, 5);
+    tree.set(15, 15);
+
+    // Boundary insert smaller than current min.
+    active = true;
+    tree.set(1, 1);
+    active = false;
+
+    // Repair branch should have mirrored max cache when header._right was NIL.
+    expect((tree as any)._header._right.key).toBe(1);
+
+    // Restore correct max cache so subsequent tests/users aren't affected.
+    const root = (tree as any)._root;
+    (tree as any)._setMaxCache(tree.isRealNode(root) ? tree.getRightMost((n: any) => n, root) : undefined);
+    expect((tree as any)._header._right.key).toBe(15);
+  });
+
+  it('max-attach: when header._left is corrupted to NIL, branch initializes min cache during max attach', () => {
+    let tree: RedBlackTree<number, number> = new RedBlackTree<number>();;
+    let active = false;
+    let flipped = false;
+    const comparator = (a: number, b: number) => {
+      if (active && !flipped && tree) {
+        flipped = true;
+        (tree as any)._header._left = tree.NIL;
+      }
+      return a - b;
+    };
+
+    tree = new RedBlackTree<number, number>([], { isMapMode: false, comparator });
+    tree.set(10, 10);
+    tree.set(5, 5);
+    tree.set(15, 15);
+
+    // Boundary insert larger than current max.
+    active = true;
+    tree.set(100, 100);
+    active = false;
+
+    // Observe the branch effect before repairing (min cache got initialized).
+    expect((tree as any)._header._left.key).toBe(100);
+
+    // Restore correct min cache.
+    const root = (tree as any)._root;
+    (tree as any)._setMinCache(tree.isRealNode(root) ? tree.getLeftMost((n: any) => n, root) : undefined);
+    expect((tree as any)._header._left.key).toBe(5);
+  });
+});

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

@@ -0,0 +1,18 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree boundary max update coverage', () => {
+  it('mapMode: updating existing max key with defined value hits store.set branch in cMax===0 fast-path', () => {
+    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 a defined value.
+    t.set(15, 'max2');
+
+    expect(t.get(15)).toBe('max2');
+    // Assert store updated (fast-path uses store.set).
+    expect((t as any)._store.get(15)).toBe('max2');
+  });
+});

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

@@ -0,0 +1,53 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree boundary attach null/undefined coverage', () => {
+  it('min boundary attach works when min.left is null', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+    t.set(5, 5);
+
+    const minNode = t.getNode(5)!;
+    // Force the boundary condition to treat left as empty via null.
+    (minNode as any)._left = null;
+
+    t.set(1, 1);
+
+    expect(t.getNode(1)?.parent?.key).toBe(5);
+    expect((t as any)._header._left.key).toBe(1);
+  });
+
+  it('min boundary attach works when min.left is undefined', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+    t.set(5, 5);
+
+    const minNode = t.getNode(5)!;
+    // Force the boundary condition to treat left as empty via undefined.
+    (minNode as any)._left = undefined;
+
+    t.set(1, 1);
+
+    expect(t.getNode(1)?.parent?.key).toBe(5);
+    expect((t as any)._header._left.key).toBe(1);
+  });
+
+  it('max boundary attach works when max.right is null/undefined', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+    t.set(15, 15);
+
+    const maxNode = t.getNode(15)!;
+    // First cover null.
+    (maxNode as any)._right = null;
+    t.set(20, 20);
+    expect(t.getNode(20)?.parent?.key).toBe(15);
+    expect((t as any)._header._right.key).toBe(20);
+
+    // Now cover undefined on the new max.
+    const maxNode2 = t.getNode(20)!;
+    (maxNode2 as any)._right = undefined;
+    t.set(25, 25);
+    expect(t.getNode(25)?.parent?.key).toBe(20);
+    expect((t as any)._header._right.key).toBe(25);
+  });
+});

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

@@ -0,0 +1,25 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree boundary attach stale cache coverage', () => {
+  it('boundary max attach repairs stale min cache when header._left === NIL', () => {
+    const t = new RedBlackTree<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+    t.set(5, 5);
+
+    const NIL = (t as any).NIL;
+
+    // Stale min cache: header._left is NIL, but tree is non-empty.
+    (t as any)._header._left = NIL;
+
+    // Insert new maximum; should take boundary max attach path and hit:
+    // if (header._left === NIL) this._setMinCache(newNode)
+    t.set(20, 20);
+
+    expect((t as any)._header._right.key).toBe(20);
+    expect((t as any)._header._left).not.toBe(NIL);
+
+    // Under stale/corrupted cache conditions, the boundary fast path mirrors min to the inserted node.
+    // (In normal operation header._left would not be NIL when the tree is non-empty.)
+    expect((t as any)._header._left.key).toBe(20);
+  });
+});

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

@@ -0,0 +1,23 @@
+import { RedBlackTree } from '../../../../src';
+
+describe('RedBlackTree boundary update coverage', () => {
+  it('updating existing min/max via boundary cache fast paths does not change size', () => {
+    const t = new RedBlackTree<number, string>([], { isMapMode: false });
+
+    t.set(10, 'a');
+    t.set(5, 'min');
+    t.set(15, 'max');
+
+    const size0 = t.size;
+
+    // Update existing min key: should hit cMin===0 fast-path.
+    expect(t.set(5, 'min2')).toBe(true);
+    expect(t.size).toBe(size0);
+    expect(t.getNode(5)?.value).toBe('min2');
+
+    // Update existing max key: should hit cMax===0 fast-path.
+    expect(t.set(15, 'max2')).toBe(true);
+    expect(t.size).toBe(size0);
+    expect(t.getNode(15)?.value).toBe('max2');
+  });
+});

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

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

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

@@ -0,0 +1,39 @@
+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);
+    // Existing semantics: undefined does not overwrite stored value in mapMode.
+    expect(t.get(1)).toBe('a');
+  });
+});