data-structure-typed 2.2.7 → 2.3.0

package/test/unit/data-structures/binary-tree/bst.more-branches-5.coverage.test.ts

@@ -0,0 +1,40 @@
+import { BST } from '../../../../src';
+
+describe('BST additional reachable branch coverage (batch 5)', () => {
+  it('search(): forces shouldVisitRight key-pruning branch + covers && chain short-circuit variants', () => {
+    const t = new BST<number, number>();
+    t.setMany([
+      [10, 10],
+      [20, 20]
+    ]);
+
+    const originalIsPredicate = (t as any)._isPredicate.bind(t);
+
+    const run = (keyNodeOrEntry: any) => {
+      let calls = 0;
+      (t as any)._isPredicate = (p: any) => {
+        // 1st call (isPred computation) => true, to bypass the fast-path.
+        // After that, behave like the real implementation so _ensurePredicate works
+        // and shouldVisitRight sees "not predicate".
+        calls++;
+        if (calls === 1) return true;
+        return originalIsPredicate(p);
+      };
+
+      try {
+        t.search(keyNodeOrEntry);
+      } finally {
+        (t as any)._isPredicate = originalIsPredicate;
+      }
+    };
+
+    // 1) benchmarkKey === null => hits first short-circuit (benchmarkKey !== null)
+    run([null, 0]);
+
+    // 2) benchmarkKey === undefined => passes first check, fails second
+    run([undefined, 0]);
+
+    // 3) compare(...) < 0 is false => passes both nullish checks
+    run([5, 0]);
+  });
+});

package/test/unit/data-structures/binary-tree/bst.more.coverage.test.ts

@@ -0,0 +1,39 @@
+import { BST, BSTNode, Range } from '../../../../src';
+
+describe('BST additional coverage', () => {
+  it('BSTNode.familyPosition covers MAL_NODE branch', () => {
+    const root = new BSTNode<number, number>(10);
+    const mal = new BSTNode<number, number>(5);
+    mal.parent = root;
+    // parent does not point to mal via left/right
+    expect(mal.familyPosition).toBe('MAL_NODE');
+  });
+
+  it('getNode returns undefined for null/undefined, and handles runtime Range input', () => {
+    const bst = new BST<number, number>();
+    bst.set(2, 2);
+
+    expect(bst.getNode(undefined as any)).toBeUndefined();
+    expect(bst.getNode(null as any)).toBeUndefined();
+
+    const r = new Range<number>(2, 2, true, true);
+    expect(bst.getNode(r as any)?.key).toBe(2);
+  });
+
+  it('getNodes returns [] for null/undefined and ignores entry with null key', () => {
+    const bst = new BST<number, number>([2, 1, 3]);
+
+    expect(bst.getNodes(undefined as any)).toEqual([]);
+    expect(bst.getNodes(null as any)).toEqual([]);
+
+    // entry with null key => targetKey undefined => []
+    expect(bst.getNodes([null as any, 123] as any)).toEqual([]);
+  });
+
+  it('getNodes returns [] when startNode is not a real node', () => {
+    const bst = new BST<number, number>([2, 1, 3]);
+
+    // ensureNode(null) => undefined => []
+    expect(bst.getNodes(2, false, null as any)).toEqual([]);
+  });
+});

package/test/unit/data-structures/binary-tree/bst.node-family.coverage.test.ts

@@ -0,0 +1,29 @@
+import { BSTNode } from '../../../../src';
+
+describe('BSTNode familyPosition coverage', () => {
+  it('covers ISOLATED/ROOT/LEFT/RIGHT/ROOT_LEFT/ROOT_RIGHT and MAL_NODE', () => {
+    const isolated = new BSTNode<number, number>(1);
+    expect(isolated.familyPosition).toBe('ISOLATED');
+
+    const root = new BSTNode<number, number>(10);
+    const left = new BSTNode<number, number>(5);
+    const right = new BSTNode<number, number>(15);
+
+    root.left = left;
+    root.right = right;
+
+    expect(root.familyPosition).toBe('ROOT');
+    expect(left.familyPosition).toBe('LEFT');
+    expect(right.familyPosition).toBe('RIGHT');
+
+    left.left = new BSTNode<number, number>(2);
+    right.right = new BSTNode<number, number>(20);
+
+    expect(left.familyPosition).toBe('ROOT_LEFT');
+    expect(right.familyPosition).toBe('ROOT_RIGHT');
+
+    const mal = new BSTNode<number, number>(999);
+    mal.parent = root;
+    expect(mal.familyPosition).toBe('MAL_NODE');
+  });
+});

package/test/unit/data-structures/binary-tree/bst.range-pruning.coverage.test.ts

@@ -0,0 +1,43 @@
+import { BST, Range } from '../../../../src';
+
+describe('BST range/pruning coverage', () => {
+  it('getNodes(range) covers includeLow/includeHigh pruning branches', () => {
+    const bst = new BST<number, number>();
+    for (const k of [10, 5, 15, 3, 7, 12, 18]) bst.set(k, k);
+
+    // includeLow/includeHigh true
+    const r1 = new Range<number>(7, 12, true, true);
+    expect(bst.getNodes(r1 as any).map(n => n.key)).toEqual([7, 10, 12]);
+
+    // includeLow false (exclude 7)
+    const r2 = new Range<number>(7, 12, false, true);
+    expect(bst.getNodes(r2 as any).map(n => n.key)).toEqual([10, 12]);
+
+    // includeHigh false (exclude 12)
+    const r3 = new Range<number>(7, 12, true, false);
+    expect(bst.getNodes(r3 as any).map(n => n.key)).toEqual([7, 10]);
+
+    // exclude both ends
+    const r4 = new Range<number>(7, 12, false, false);
+    expect(bst.getNodes(r4 as any).map(n => n.key)).toEqual([10]);
+  });
+
+  it('getNodes(predicate) exercises predicate-search shouldVisitLeft/Right fallthrough', () => {
+    const bst = new BST<number, number>();
+    for (const k of [4, 2, 6, 1, 3, 5, 7]) bst.set(k, k);
+
+    // Predicate that matches only leaf nodes, to force traversal and filtering.
+    const nodes = bst.getNodes(node => !bst.isRealNode(node.left) && !bst.isRealNode(node.right));
+    expect(nodes.map(n => n.key).sort((a, b) => a - b)).toEqual([1, 3, 5, 7]);
+
+    // onlyOne=true should early-exit after first match (in-order => 1)
+    const one = bst.getNodes(node => !bst.isRealNode(node.left) && !bst.isRealNode(node.right), true);
+    expect(one).toHaveLength(1);
+    expect(one[0].key).toBe(1);
+  });
+
+  it('rangeSearch overload [low, high] is accepted', () => {
+    const bst = new BST<number, number>([10, 5, 15, 3, 7, 12, 18]);
+    expect(bst.rangeSearch([7, 12])).toEqual([7, 10, 12]);
+  });
+});

package/test/unit/data-structures/binary-tree/bst.search-fastpath.coverage.test.ts

@@ -0,0 +1,30 @@
+import { BST } from '../../../../src';
+
+describe('BST search() fast-path coverage', () => {
+  it('search(node) uses node.key extraction branch and returns callback result', () => {
+    const t = new BST<number, string>([], { isMapMode: false });
+    t.set(10, 'a');
+    t.set(5, 'b');
+    t.set(15, 'c');
+
+    const n5 = t.getNode(5)!;
+    const out = t.search(n5, false, (n: any) => n.value);
+    expect(out).toEqual(['b']);
+  });
+
+  it('search(entry) with null key returns [] (covers entry null-key guard in fast path)', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    const out = t.search([null as any, 1] as any);
+    expect(out).toEqual([]);
+  });
+
+  it('search by key returns [] when startNode ensureNode fails', () => {
+    const t = new BST<number, number>([], { isMapMode: false });
+    for (const k of [10, 5, 15]) t.set(k, k);
+
+    const out = t.search(10 as any, false, (n: any) => n.key, null as any);
+    expect(out).toEqual([]);
+  });
+});