data-structure-typed 2.3.0 → 2.4.0

package/test/unit/data-structures/binary-tree/avl-tree-multi-map.coverage.test.ts

@@ -1,108 +0,0 @@
-import { AVLTreeMultiMap, AVLTreeMultiMapNode } from '../../../../src';
-
-describe('AVLTreeMultiMap coverage', () => {
-  it('AVLTreeMultiMapNode.familyPosition covers ROOT/LEFT/RIGHT/ISOLATED/MAL_NODE', () => {
-    const isolated = new AVLTreeMultiMapNode<number, number>(1, [1]);
-    expect(isolated.familyPosition).toBe('ISOLATED');
-
-    const root = new AVLTreeMultiMapNode<number, number>(10, [10]);
-    const left = new AVLTreeMultiMapNode<number, number>(5, [5]);
-    root.left = left;
-    expect(root.familyPosition).toBe('ROOT');
-    expect(left.familyPosition).toBe('LEFT');
-
-    const right = new AVLTreeMultiMapNode<number, number>(15, [15]);
-    root.right = right;
-    expect(right.familyPosition).toBe('RIGHT');
-
-    // MAL_NODE: parent exists but doesn't reference this node as left/right.
-    const mal = new AVLTreeMultiMapNode<number, number>(99, [99]);
-    mal.parent = root;
-    expect(mal.familyPosition).toBe('MAL_NODE');
-  });
-
-  it('set() covers entry/key overloads, existing key append, and node fast path', () => {
-    const mm = new AVLTreeMultiMap<number, string>();
-
-    // ignore invalid key
-    expect(mm.set([null, ['x']])).toBe(false);
-
-    // key + single value overload
-    expect(mm.set(1, 'a')).toBe(true);
-    expect(mm.set(1, 'b')).toBe(true);
-    expect(mm.get(1)).toEqual(['a', 'b']);
-
-    // entry overload with array bucket
-    expect(mm.set([1, ['c', 'd']])).toBe(true);
-    expect(mm.get(1)).toEqual(['a', 'b', 'c', 'd']);
-
-    // entry overload with value param should wrap value into array
-    // expect(mm.set([1, ['ignored']], 'e')).toBe(true);
-    expect(mm.get(1)).toEqual(['a', 'b', 'c', 'd']);
-
-    // node fast path (use an existing real node from the tree)
-    mm.set(2, 'x');
-    const existingNode = mm.getNode(2);
-    expect(existingNode).toBeTruthy();
-    expect(mm.set(existingNode as any)).toBe(true);
-    expect(mm.get(2)).toEqual(['x']);
-  });
-
-  it('set() covers non-map-mode branch ordering (forced via internal toggle)', () => {
-    const mm = new AVLTreeMultiMap<number, number>();
-
-    // Force the non-map-mode branch to execute for coverage.
-    (mm as any)._isMapMode = false;
-
-    // When values are undefined and key is new, super.set(key, undefined) should create a node;
-    // this should still return true (insert) or false depending on AVLTree semantics.
-    // We mainly want to execute the branch; assert it does not throw.
-    mm.set(10 as any);
-
-    // Setting an existing key with values should append via _setToValues path.
-    expect(mm.set(10, 1)).toBe(true);
-    expect(mm.set([10, [2, 3]])).toBe(true);
-    expect(mm.get(10)).toEqual([1, 2, 3]);
-  });
-
-  it('deleteValue() covers not-found, found, and bucket-empty delete', () => {
-    const mm = new AVLTreeMultiMap<number, string>();
-
-    expect(mm.deleteValue(1, 'x')).toBe(false);
-
-    mm.set(1, 'a');
-    mm.set(1, 'b');
-
-    expect(mm.deleteValue(1, 'nope')).toBe(false);
-
-    expect(mm.deleteValue(1, 'a')).toBe(true);
-    expect(mm.get(1)).toEqual(['b']);
-
-    // deleting last value removes the key
-    expect(mm.deleteValue(1, 'b')).toBe(true);
-    expect(mm.get(1)).toBeUndefined();
-    expect(mm.size).toBe(0);
-  });
-
-  it('perfectlyBalance() returns false on empty and true on non-empty', () => {
-    const empty = new AVLTreeMultiMap<number, number>();
-    expect(empty.perfectlyBalance()).toBe(false);
-
-    const mm = new AVLTreeMultiMap<number, number>();
-    for (const k of [3, 1, 4, 2]) mm.set(k, k);
-    expect(mm.perfectlyBalance('ITERATIVE')).toBe(true);
-    expect(mm.isAVLBalanced()).toBe(true);
-  });
-
-  it('map() returns a MultiMap when mapping to array values', () => {
-    const mm = new AVLTreeMultiMap<number, number>();
-    mm.set(1, 10);
-    mm.set(1, 11);
-    mm.set(2, 20);
-
-    const out = mm.map((values, key) => [key + 1, (values ?? []).map(v => v + 1)]);
-    expect(out).toBeInstanceOf(AVLTreeMultiMap);
-    expect(out.get(2)).toEqual([11, 12]);
-    expect(out.get(3)).toEqual([21]);
-  });
-});

package/test/unit/data-structures/binary-tree/avl-tree-multi-map.more-branches-2.coverage.test.ts

@@ -1,85 +0,0 @@
-import { AVLTreeMultiMap, AVLTreeMultiMapNode } from '../../../../src';
-
-describe('AVLTreeMultiMap additional branch coverage (batch 2)', () => {
-  it('AVLTreeMultiMapNode constructor default value=[] and familyPosition ROOT_LEFT arm', () => {
-    const parent = new AVLTreeMultiMapNode<number, string>(1, ['p']);
-    const left = new AVLTreeMultiMapNode<number, string>(0); // default value arg
-
-    parent.left = left;
-    // give left a child so (left.left||left.right) is truthy
-    left.left = new AVLTreeMultiMapNode<number, string>(-1, ['c']);
-
-    expect(Array.isArray(left.value)).toBe(true);
-    expect(left.value).toEqual([]);
-    expect(left.familyPosition).toBe('ROOT_LEFT');
-  });
-
-  it('set() returns false when existing bucket present but incoming values are undefined (covers values===undefined else branch)', () => {
-    const t = new AVLTreeMultiMap<number, string>();
-    t.set(1, 'a');
-
-    // value undefined + values undefined => no-op
-    expect(t.set(1, undefined as any)).toBe(false);
-    expect(t.get(1)).toEqual(['a']);
-  });
-
-  it('mapMode set(): forces evaluation of _setToValues via _setByNode false (covers _setByNode() || _setToValues() right operand)', () => {
-    const t = new AVLTreeMultiMap<number, string>();
-    t.set(1, 'a');
-
-    const origGet = (t as any).get;
-    const origGetNode = (t as any).getNode;
-
-    // Monkeypatch get() so get(node) returns undefined, but get(key) returns the real array.
-    (t as any).get = function (arg: any) {
-      if (arg && typeof arg === 'object' && 'key' in arg) return undefined;
-      return origGet.call(this, arg);
-    };
-
-    // Force getNode() to return a non-real node so `_setByNode` takes the `else` path:
-    // `return super.set(key, values)` (patched below to return false).
-    (t as any).getNode = () => (t as any)._NIL;
-
-    // Monkeypatch AVLTree.set (the super.set used inside _setByNode) to be a no-op that returns false,
-    // so `_setByNode()` becomes falsy and OR evaluates `_setToValues()`.
-    const avlProto = Object.getPrototypeOf(Object.getPrototypeOf(t));
-    const origSuperSet = avlProto.set;
-    avlProto.set = () => false;
-
-    try {
-      expect(t.set(1, 'b')).toBe(true);
-      expect(origGet.call(t, 1)).toEqual(['a', 'b']);
-    } finally {
-      avlProto.set = origSuperSet;
-      (t as any).get = origGet;
-      (t as any).getNode = origGetNode;
-    }
-  });
-
-  it('_createInstance uses snapshotOptions fallback when _snapshotOptions is missing (covers ?? {} right operand)', () => {
-    const t = new AVLTreeMultiMap<number, string>();
-
-    const orig = (t as any)._snapshotOptions;
-    (t as any)._snapshotOptions = undefined;
-    try {
-      const inst = (t as any)._createInstance();
-      expect(inst).toBeInstanceOf(AVLTreeMultiMap);
-    } finally {
-      (t as any)._snapshotOptions = orig;
-    }
-  });
-
-  it('_createLike default iter=[] and snapshotOptions fallback when _snapshotOptions is missing', () => {
-    const t = new AVLTreeMultiMap<number, string>();
-
-    const orig = (t as any)._snapshotOptions;
-    (t as any)._snapshotOptions = undefined;
-    try {
-      const like = (t as any)._createLike();
-      expect(like).toBeInstanceOf(AVLTreeMultiMap);
-      expect(like.size).toBe(0);
-    } finally {
-      (t as any)._snapshotOptions = orig;
-    }
-  });
-});