data-structure-typed 2.4.1 → 2.4.3

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

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

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

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

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

@@ -1,30 +0,0 @@
-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([]);
-  });
-});