data-structure-typed 2.4.0 → 2.4.2

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

@@ -1,345 +0,0 @@
-import { BinaryIndexedTree } from '../../../../src';
-// import {isDebugTest} from '../../../config';
-
-// const isDebug = isDebugTest;
-
-describe('BinaryIndexedTree simple', () => {
-  let bit: BinaryIndexedTree;
-
-  beforeEach(() => {
-    //Create a new BinaryIndexedTree instance before each test case
-    bit = new BinaryIndexedTree({
-      frequency: 0,
-      max: 10
-    }); // Modify the value of max as needed
-  });
-
-  it('should initialize correctly', () => {
-    expect(bit.freq).toBe(0);
-    expect(bit.max).toBe(10);
-    expect(bit.freqMap).toEqual({
-      0: 0
-    }); // Modify the initialized record value according to the actual situation
-    // More initialization checks can be added
-  });
-
-  it('should read a single value correctly', () => {
-    // Test the function of reading a single value
-    bit.writeSingle(5, 5); //Write test data
-    expect(bit.readSingle(5)).toBe(5); // Read and verify
-  });
-
-  it('should update a value correctly', () => {
-    // Test the ability to update a single value
-    bit.writeSingle(5, 5); //Write test data
-    bit.update(5, 2); // update value
-    expect(bit.readSingle(5)).toBe(7); // Verify the updated value
-  });
-
-  it('should find lower bound correctly', () => {
-    //Test the function of finding the lower bound
-    bit.writeSingle(2, 10);
-    bit.writeSingle(5, 20);
-    bit.writeSingle(8, 30);
-    expect(bit.lowerBound(15)).toBe(5); // Find and verify the lower bound
-  });
-
-  it('should find upper bound correctly', () => {
-    //Test the function of finding the upper bound
-    bit.writeSingle(2, 10);
-    bit.writeSingle(5, 20);
-    bit.writeSingle(8, 30);
-    expect(bit.upperBound(25)).toBe(5); // Find and verify the upper bound
-  });
-});
-
-describe('BinaryIndexedTree', () => {
-  const frequency = 999;
-  const max = 10;
-  let bit: BinaryIndexedTree;
-
-  beforeEach(function () {
-    bit = new BinaryIndexedTree({
-      frequency,
-      max
-    });
-  });
-  it('should validate the index', function () {
-    expect(() => bit.readSingle(-1)).toThrow('Index out of range');
-    expect(() => bit.readSingle(10)).toThrow('Index out of range');
-  });
-
-  it('should read a single frequency correctly', function () {
-    for (let i = 0; i < max; i++) {
-      expect(bit.readSingle(i)).toBe(frequency);
-    }
-  });
-  it('should validate the index', function () {
-    expect(() => bit.update(-1, 100)).toThrow('Index out of range');
-    expect(() => bit.update(10, 100)).toThrow('Index out of range');
-  });
-  it('should frequency and max', function () {
-    const frequency = 200;
-    const max = 1000;
-    const bit = new BinaryIndexedTree({
-      frequency,
-      max
-    });
-
-    expect(bit.freq).toBe(frequency);
-    expect(bit.max).toBe(max);
-  });
-
-  it('should update the frequency with the given delta', function () {
-    for (let i = 0; i < max; i++) {
-      bit.update(i, i * 2);
-    }
-    for (let i = 0; i < max; i++) {
-      expect(bit.readSingle(i)).toBe(i * 2 + frequency);
-    }
-  });
-  it('should validate the index', function () {
-    expect(() => bit.writeSingle(-1, 100)).toThrow('Index out of range');
-    expect(() => bit.writeSingle(10, 100)).toThrow('Index out of range');
-  });
-
-  it('should writeSingle to be correctly invoked', function () {
-    for (let i = 0; i < max; i++) {
-      bit.writeSingle(i, i * 2);
-    }
-    for (let i = 0; i < max; i++) {
-      expect(bit.readSingle(i)).toBe(i * 2);
-    }
-  });
-
-  it('should read the frequency', function () {
-    for (let c = 0; c <= max; c++) {
-      expect(bit.read(c)).toBe(c * frequency);
-    }
-  });
-
-  const values = [-5, 0, 5, 10, 95, 100, 1000];
-  it('should find the upper-bound index', function () {
-    loopUpperBoundTests(bit, values);
-  });
-
-  it('should find the lower-bound index', function () {
-    loopLowerBoundTests(bit, values);
-  });
-});
-
-describe('designated values', function () {
-  const array = [1, 8, 6, 10, 7, 9, 0, 2, 6, 3];
-  const sumArray = (sum => array.map(value => (sum += value)))(0);
-  let bit: BinaryIndexedTree;
-
-  beforeEach(function () {
-    bit = new BinaryIndexedTree({
-      max: array.length
-    });
-    array.forEach((value, i) => bit.writeSingle(i, value));
-  });
-
-  describe('readSingle', function () {
-    it('should read a single frequency correctly', function () {
-      array.forEach((value, i) => {
-        expect(bit.readSingle(i)).toBe(array[i]);
-      });
-    });
-  });
-
-  describe('update', function () {
-    it('should update the frequency with the given delta', function () {
-      array.forEach((value, i) => bit.update(i, value + i));
-      array.forEach((value, i) => {
-        expect(bit.readSingle(i)).toBe(array[i] * 2 + i);
-      });
-    });
-  });
-
-  describe('writeSingle', function () {
-    it('should write a single frequency correctly', function () {
-      array.forEach((value, i) => bit.writeSingle(i, value + i));
-      array.forEach((value, i) => {
-        expect(bit.readSingle(i)).toBe(array[i] + i);
-      });
-    });
-  });
-
-  describe('read', function () {
-    it('should read the cumulative frequency correctly', function () {
-      expect(bit.read(0)).toBe(0);
-      sumArray.forEach((sum, i) => {
-        expect(bit.read(i + 1)).toBe(sum);
-      });
-    });
-  });
-
-  const values = [-5, 0, 15, 25, 43, 53, 100];
-
-  describe('upperBound', function () {
-    it('should find the upper-bound index', function () {
-      loopUpperBoundTests(bit, values);
-    });
-  });
-
-  describe('lowerBound', function () {
-    it('should find the lower-bound index', function () {
-      loopLowerBoundTests(bit, values);
-    });
-  });
-});
-
-describe('descending sequence', function () {
-  const array = [1, 8, -6, 10, 7, 9, 0, -2, 6, 3];
-  let bit: BinaryIndexedTree;
-
-  beforeEach(function () {
-    bit = new BinaryIndexedTree({
-      max: array.length
-    });
-    array.forEach((value, i) => bit.writeSingle(i, value));
-  });
-
-  it('should have a correct negativeCount property', function () {
-    expect(bit.negativeCount).toBe(2);
-    bit.update(2, 6);
-    expect(bit.negativeCount).toBe(1);
-    bit.update(7, 3);
-    expect(bit.negativeCount).toBe(0);
-    bit.update(8, -7);
-    expect(bit.negativeCount).toBe(1);
-  });
-
-  const values = [-5, 0, 15, 25, 43, 53, 100];
-
-  describe('upperBound', function () {
-    it('should validate the non-descending', function () {
-      expect(() => bit.upperBound(20)).toThrow('Must not be descending');
-      bit.update(2, 12);
-      bit.update(7, 4);
-      loopUpperBoundTests(bit, values);
-    });
-  });
-
-  describe('BinaryIndexedTree lowerBound', function () {
-    it('should validate the non-descending', function () {
-      expect(() => bit.lowerBound(20)).toThrow('Sequence is not non-descending');
-      bit.update(2, 12);
-      bit.update(7, 4);
-      loopLowerBoundTests(bit, values);
-    });
-  });
-});
-
-describe('BinaryIndexedTree additional tests', () => {
-  it('should handle read method correctly', () => {
-    const bit = new BinaryIndexedTree({
-      max: 10
-    });
-    bit.writeSingle(2, 10);
-    bit.writeSingle(5, 20);
-    bit.writeSingle(8, 30);
-    expect(bit.read(5)).toBe(10); // Ensure read method accumulates correctly
-  });
-
-  it('should handle consecutive operations', () => {
-    const bit = new BinaryIndexedTree({
-      max: 10
-    });
-    bit.writeSingle(2, 10);
-    bit.update(2, 5);
-    expect(bit.readSingle(2)).toBe(15);
-    bit.writeSingle(5, 20);
-    expect(bit.readSingle(5)).toBe(20);
-    expect(bit.lowerBound(15)).toBe(2);
-  });
-
-  it('should handle frequent increment updates', () => {
-    const bit = new BinaryIndexedTree({
-      max: 10
-    });
-    for (let i = 0; i < 10; i++) {
-      bit.update(2, 5);
-    }
-    expect(bit.readSingle(2)).toBe(50);
-  });
-
-  it('should handle edge cases', () => {
-    const bit = new BinaryIndexedTree({
-      max: 10
-    });
-    bit.writeSingle(9, 100);
-    expect(bit.readSingle(9)).toBe(100);
-    expect(bit.lowerBound(200)).toBe(10);
-  });
-});
-
-function loopUpperBoundTests(bit: BinaryIndexedTree, values: number[]) {
-  for (const value of values) {
-    const index = bit.upperBound(value);
-    if (index > 0) {
-      expect(bit.read(index)).toBeLessThanOrEqual(value);
-    } else {
-      expect(index).toBe(0);
-    }
-    if (index < bit.max) {
-      expect(bit.read(index + 1)).toBeGreaterThan(value);
-    } else {
-      expect(index).toBe(bit.max);
-    }
-  }
-}
-
-function loopLowerBoundTests(bit: BinaryIndexedTree, values: number[]) {
-  for (const value of values) {
-    const index = bit.lowerBound(value);
-    if (index > 0) {
-      expect(bit.read(index)).toBeLessThan(value);
-    } else {
-      expect(index).toBe(0);
-    }
-    if (index < bit.max) {
-      expect(bit.read(index + 1)).toBeGreaterThanOrEqual(value);
-    } else {
-      expect(index).toBe(bit.max);
-    }
-  }
-}
-
-describe('', () => {
-  class NumArrayDC {
-    protected _tree: BinaryIndexedTree;
-    protected readonly _nums: number[];
-
-    constructor(nums: number[]) {
-      this._nums = nums;
-      this._tree = new BinaryIndexedTree({
-        max: nums.length + 1
-      });
-      for (let i = 0; i < nums.length; i++) {
-        this._tree.update(i + 1, nums[i]);
-      }
-    }
-
-    update(index: number, value: number): void {
-      this._tree.update(index + 1, value - this._nums[index]);
-      this._nums[index] = value;
-    }
-
-    sumRange(left: number, right: number): number {
-      return this._tree.getPrefixSum(right + 1) - this._tree.getPrefixSum(left);
-    }
-  }
-
-  it('', () => {
-    const numArray = new NumArrayDC([1, 3, 5, 8, 2, 9, 4, 5, 8, 1, 3, 2]);
-    expect(numArray.sumRange(0, 8)).toBe(45);
-    expect(numArray.sumRange(0, 2)).toBe(9);
-    numArray.update(1, 2);
-    expect(numArray.sumRange(0, 2)).toBe(8);
-    expect(numArray.sumRange(3, 4)).toBe(10);
-    numArray.update(3, 2);
-    expect(numArray.sumRange(3, 4)).toBe(4);
-  });
-});

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

@@ -1,18 +0,0 @@
-import { BinaryIndexedTree } from '../../../../src';
-
-describe('BinaryIndexedTree remaining branch coverage', () => {
-  it('constructor sets negativeCount=max when frequency < 0 (ternary true arm)', () => {
-    const bit = new BinaryIndexedTree({ max: 10, frequency: -1 });
-    expect(bit.negativeCount).toBe(10);
-  });
-
-  it('read() throws when count is not an integer', () => {
-    const bit = new BinaryIndexedTree({ max: 10 });
-    expect(() => bit.read(1.5)).toThrow('Invalid count');
-  });
-
-  it('index validation throws when index is not an integer', () => {
-    const bit = new BinaryIndexedTree({ max: 10 });
-    expect(() => bit.readSingle(1.2 as any)).toThrow('Invalid index');
-  });
-});

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

@@ -1,56 +0,0 @@
-import { BinaryTree } from '../../../../src';
-
-describe('BinaryTree extra branch coverage', () => {
-  it('isBST(RECURSIVE) evaluates both standard and inverse checks when standard fails (covers isStandardBST || isInverseBST second operand)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-
-    // Manually wire an inverse BST (left > root > right)
-    const root = t.createNode(10, 10);
-    const left = t.createNode(15, 15);
-    const right = t.createNode(5, 5);
-    root.left = left;
-    root.right = right;
-    left.parent = root;
-    right.parent = root;
-
-    // Force as root (avoid BFS insertion semantics)
-    (t as any)._setRoot(root);
-
-    // This shape violates standard BST ordering, so the first check is false, forcing evaluation of the inverse check.
-    expect(t.isBST(root as any, 'RECURSIVE' as any)).toBe(false);
-  });
-
-  it('getPathToRoot with isReverse=false takes the non-reverse branch', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    const root = t.createNode(1, 1);
-    const child = t.createNode(2, 2);
-    root.left = child;
-    child.parent = root;
-    (t as any)._setRoot(root);
-
-    const out = t.getPathToRoot(child as any, (n: any) => n?.key, false);
-    expect(out).toEqual([2, 1]);
-  });
-
-  it('getSuccessor returns undefined when x is not a real node (covers !isRealNode guard)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    expect(t.getSuccessor(null as any)).toBeUndefined();
-  });
-
-  it('_dfs uses default parameters (default args) and returns in-order keys', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    // BinaryTree.set is BFS: insert 2 as left child of 1.
-    t.set(1, 1);
-    t.set(2, 2);
-
-    const out = (t as any)._dfs();
-    // default pattern is IN; with BFS-built tree (1 with left=2), IN traversal is [2, 1]
-    expect(out).toEqual([2, 1]);
-  });
-
-  it('_keyValueNodeOrEntryToNodeAndValue([undefined, v]) returns [undefined, undefined] (covers entry-undefined guard)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    const out = (t as any)._keyValueNodeOrEntryToNodeAndValue([undefined as any, 1] as any);
-    expect(out).toEqual([undefined, undefined]);
-  });
-});

package/test/unit/data-structures/binary-tree/binary-tree.remaining-branches.coverage.test.ts

@@ -1,232 +0,0 @@
-import { BinaryTree } from '../../../../src';
-
-describe('BinaryTree remaining branch coverage', () => {
-  it('set() BFS loop hits `if (!cur) continue` by monkeypatching Queue.shift to return undefined once', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    t.set(1, 1);
-
-    // set() constructs a Queue internally; easiest deterministic way is to patch Queue.prototype.shift.
-    const { Queue } = require('../../../../src');
-    const orig = Queue.prototype.shift;
-    let once = true;
-    Queue.prototype.shift = function () {
-      if (once) {
-        once = false;
-        return undefined;
-      }
-      return orig.apply(this);
-    };
-
-    try {
-      expect(t.set(2, 2)).toBe(true);
-    } finally {
-      Queue.prototype.shift = orig;
-    }
-  });
-
-  it('isBST(ITERATIVE) executes checkBST() default-arg branch (checkMax default false)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    t.set(2, 2);
-    t.set(1, 1);
-    t.set(3, 3);
-
-    expect(t.isBST(t.root as any, 'ITERATIVE' as any)).toBe(true);
-  });
-
-  it('getPathToRoot returns reversed path when isReverse=true', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    const root = t.createNode(1, 1);
-    const child = t.createNode(2, 2);
-    root.left = child;
-    child.parent = root;
-    (t as any)._setRoot(root);
-
-    const out = t.getPathToRoot(child as any, (n: any) => n?.key, true);
-    expect(out).toEqual([1, 2]);
-  });
-
-  it('_dfs(ITERATIVE) hits onlyOne early-return branch when onlyOne=true', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    t.set(1, 1);
-    t.set(2, 2);
-    const out = (t as any)._dfs((n: any) => n?.key, 'IN', true, t.root, 'ITERATIVE', false);
-    expect(out.length).toBe(1);
-  });
-
-  it('_dfs(RECURSIVE) pattern PRE hits onlyOne return (covers line 1998)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    t.set(1, 1);
-    t.set(2, 2);
-    const out = (t as any)._dfs((n: any) => n?.key, 'PRE', true, t.root, 'RECURSIVE', false);
-    expect(out.length).toBe(1);
-  });
-
-  it('_dfs(RECURSIVE) pattern POST hits onlyOne return (covers line 2008)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    t.set(1, 1);
-    t.set(2, 2);
-    const out = (t as any)._dfs((n: any) => n?.key, 'POST', true, t.root, 'RECURSIVE', false);
-    // POST visits children before root, so we may already have processed some nodes before early return.
-    expect(out.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('_dfs(ITERATIVE) can hit `if (cur === undefined) continue` by patching Array.prototype.pop', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    t.set(1, 1);
-
-    const origPop = Array.prototype.pop;
-    let once = true;
-    Array.prototype.pop = function () {
-      if (once) {
-        once = false;
-        return undefined;
-      }
-      // @ts-ignore
-      return origPop.apply(this);
-    };
-
-    try {
-      const out = (t as any)._dfs((n: any) => n?.key, 'IN', false, t.root, 'ITERATIVE', false);
-      expect(out.length).toBeGreaterThan(0);
-    } finally {
-      Array.prototype.pop = origPop;
-    }
-  });
-
-  it('_dfs startNode ensureNode fails returns []', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    t.set(1, 1);
-    const out = (t as any)._dfs((n: any) => n?.key, 'IN', false, null, 'ITERATIVE', false);
-    expect(out).toEqual([]);
-  });
-
-  it('_getIterator default-arg path returns without yielding when root is undefined', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    // direct call to generator
-    const iter = (t as any)._getIterator();
-    const first = iter.next();
-    expect(first.done).toBe(true);
-  });
-
-  it('_getIterator recursive branch visits left and right and yields mapMode values when mapMode=true', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: true });
-    // Build a small tree manually to avoid BFS quirks.
-    const root: any = t.createNode(2, 200);
-    const left: any = t.createNode(1, 100);
-    const right: any = t.createNode(3, 300);
-    root.left = left;
-    root.right = right;
-    left.parent = root;
-    right.parent = root;
-    (t as any)._setRoot(root);
-
-    // Ensure store has node references (node-index store).
-    left.value = 1000;
-    root.value = 2000;
-    right.value = 3000;
-    (t as any)._store.set(1, left);
-    (t as any)._store.set(2, root);
-    (t as any)._store.set(3, right);
-
-    // Force recursive iterator branch.
-    (t as any).iterationType = 'RECURSIVE';
-
-    const got: any[] = [];
-    for (const kv of t) got.push(kv);
-    expect(got).toEqual([
-      [1, 1000],
-      [2, 2000],
-      [3, 3000]
-    ]);
-  });
-
-  it('_getIterator recursive branch yields node.value when mapMode=false (covers else yield)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    const root: any = t.createNode(2, 200);
-    const left: any = t.createNode(1, 100);
-    const right: any = t.createNode(3, 300);
-    root.left = left;
-    root.right = right;
-    left.parent = root;
-    right.parent = root;
-    (t as any)._setRoot(root);
-
-    (t as any).iterationType = 'RECURSIVE';
-
-    const got: any[] = [];
-    for (const kv of t) got.push(kv);
-    expect(got).toEqual([
-      [1, 100],
-      [2, 200],
-      [3, 300]
-    ]);
-  });
-
-  it('_createLike default-arg path can be called with no args', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    const like = (t as any)._createLike();
-    expect(like.size).toBe(0);
-  });
-
-  it('_displayAux: node is undefined and isShowUndefined=true uses "U" leaf rendering (covers U branch)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    const layout = (t as any)._displayAux(undefined, { isShowNull: true, isShowUndefined: true, isShowRedBlackNIL: true });
-    expect(layout[0][0]).toContain('U');
-  });
-
-  it('_displayAux: node is null and isShowNull=true uses "N" leaf rendering (covers N branch)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    const layout = (t as any)._displayAux(null, { isShowNull: true, isShowUndefined: true, isShowRedBlackNIL: true });
-    expect(layout[0][0]).toContain('N');
-  });
-
-  it('_displayAux: node is null and isShowNull=false returns empty layout', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    const layout = (t as any)._displayAux(null, { isShowNull: false, isShowUndefined: true, isShowRedBlackNIL: true });
-    expect(layout[0][0]).toBe('─');
-  });
-
-  it('_displayAux: isNIL(node) shows "S" when isShowRedBlackNIL=true', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false } as any);
-    const NIL = (t as any)._NIL;
-    const layout = (t as any)._displayAux(NIL, { isShowNull: true, isShowUndefined: true, isShowRedBlackNIL: true });
-    expect(layout[0][0]).toContain('S');
-  });
-
-  it('_swapProperties updates value when mapMode=false (covers !this._isMapMode assignments)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    const a: any = t.createNode(1, 10);
-    const b: any = t.createNode(2, 20);
-    (t as any)._swapProperties(a, b);
-    expect(a.key).toBe(2);
-    expect(a.value).toBe(20);
-    expect(b.key).toBe(1);
-    expect(b.value).toBe(10);
-  });
-
-  it('_ensurePredicate for nullish input returns a predicate (covers nullish early return + ternary branch)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    const p = (t as any)._ensurePredicate(undefined);
-    expect(p(null)).toBe(false);
-    // also call with a truthy node to cover the other arm of (node ? false : false)
-    expect(p(t.createNode(1, 1) as any)).toBe(false);
-  });
-
-  it('_ensurePredicate for entry and for key returns false on null node (covers `if (!node) return false`)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false });
-    const pEntry = (t as any)._ensurePredicate([1, 1]);
-    const pKey = (t as any)._ensurePredicate(1);
-    expect(pEntry(null)).toBe(false);
-    expect(pKey(null)).toBe(false);
-  });
-
-  it('_extractKey returns undefined when passing _NIL', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: false } as any);
-    expect((t as any)._extractKey((t as any)._NIL)).toBeUndefined();
-  });
-
-  it('_setValue returns false when value is undefined (covers value===undefined guard)', () => {
-    const t = new BinaryTree<number, number>([], { isMapMode: true });
-    expect((t as any)._setValue(1, undefined)).toBe(false);
-  });
-});