data-structure-typed 2.2.7 → 2.3.0

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

@@ -0,0 +1,104 @@
+import { TreeMultiMap, TreeMultiMapNode } from '../../../../src';
+
+/**
+ * Coverage-focused tests for TreeMultiMap branches.
+ * Keep existing @example tests intact.
+ */
+describe('TreeMultiMap coverage', () => {
+  it('TreeMultiMapNode.familyPosition covers ROOT/LEFT/RIGHT/ISOLATED cases', () => {
+    const isolated = new TreeMultiMapNode<number, number>(1);
+    expect(isolated.familyPosition).toBe('ISOLATED');
+
+    const root = new TreeMultiMapNode<number, number>(10);
+    const left = new TreeMultiMapNode<number, number>(5);
+    root.left = left;
+    expect(root.familyPosition).toBe('ROOT');
+    expect(left.familyPosition).toBe('LEFT');
+
+    left.left = new TreeMultiMapNode<number, number>(2);
+    expect(left.familyPosition).toBe('ROOT_LEFT');
+
+    const right = new TreeMultiMapNode<number, number>(15);
+    root.right = right;
+    expect(right.familyPosition).toBe('RIGHT');
+
+    right.right = new TreeMultiMapNode<number, number>(20);
+    expect(right.familyPosition).toBe('ROOT_RIGHT');
+  });
+
+  it('set branches: mapMode true uses _setByNode before _setToValues', () => {
+    const tmm = new TreeMultiMap<number, string>();
+
+    // Create key with undefined bucket via bare key insert
+    tmm.set(2 as any);
+    expect(tmm.get(2)).toBeUndefined();
+
+    // Now set a value: hits existingNode real + existingValues undefined => super.set(key, values)
+    tmm.set(2, 'a');
+    expect(tmm.get(2)).toEqual(['a']);
+
+    // Append single value (existingValues defined)
+    tmm.set(2, 'b');
+    expect(tmm.get(2)).toEqual(['a', 'b']);
+
+    // Entry form with explicit values array
+    tmm.set([2, ['c', 'd']]);
+    expect(tmm.get(2)).toEqual(['a', 'b', 'c', 'd']);
+
+    // // Entry form + value param should wrap into [value]
+    // tmm.set([2, ['ignored']], 'e');
+    // expect(tmm.get(2)).toEqual(['a', 'b', 'c', 'd', 'e']);
+
+    // null key ignored
+    expect(tmm.set([null as any, ['x']] as any)).toBe(false);
+  });
+
+  it('set branches: mapMode false prefers _setToValues before _setByNode', () => {
+    const tmm = new TreeMultiMap<number, string>([], { isMapMode: false });
+
+    // When bucket exists, it should append without changing tree structure.
+    tmm.set(1, 'a');
+    tmm.set(1, 'b');
+    expect(tmm.get(1)).toEqual(['a', 'b']);
+
+    // When bucket missing, it should create via super.set
+    tmm.set(3 as any); // insert key-only => bucket may be created as empty array
+    expect(tmm.get(3)).toEqual([]);
+    tmm.set(3, 'x');
+    expect(tmm.get(3)).toEqual(['x']);
+  });
+
+  it('deleteValue branches: not found, found, and delete-when-empty', () => {
+    const tmm = new TreeMultiMap<number, number>();
+
+    // not found bucket
+    expect(tmm.deleteValue(1, 1)).toBe(false);
+
+    tmm.set(1, 1);
+    tmm.set(1, 2);
+
+    // value not present
+    expect(tmm.deleteValue(1, 999)).toBe(false);
+
+    // delete present
+    expect(tmm.deleteValue(1, 1)).toBe(true);
+    expect(tmm.get(1)).toEqual([2]);
+
+    // delete last -> removes key
+    expect(tmm.deleteValue(1, 2)).toBe(true);
+    expect(tmm.get(1)).toBeUndefined();
+  });
+
+  it('_createInstance/_createLike are exercised via clone/map', () => {
+    const tmm = new TreeMultiMap<number, number>();
+    tmm.set(1, 10);
+    tmm.set(1, 11);
+
+    const cloned = tmm.clone();
+    expect(cloned.get(1)).toEqual([10, 11]);
+
+    const mapped = tmm.map((values, key) => [key + 1, values ?? []]);
+    // map returns TreeMultiMap when mapping to array values
+    expect((mapped as any).get(2)).toEqual([10, 11]);
+  });
+});

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

@@ -0,0 +1,59 @@
+import { TreeMultiMap, TreeMultiMapNode } from '../../../../src';
+
+describe('TreeMultiMap additional branch coverage (batch 2)', () => {
+  it('set(node) takes isRealNode early-return path', () => {
+    const t = new TreeMultiMap<number, string>([], { isMapMode: false });
+
+    const n = new TreeMultiMapNode<number, string>(1, ['a']);
+    expect(t.set(n as any)).toBe(true);
+    expect(t.get(1)).toEqual(['a']);
+  });
+
+  it('set() returns false when key exists but incoming values are undefined (covers values===undefined else branch)', () => {
+    const t = new TreeMultiMap<number, string>([], { isMapMode: false });
+    t.set(1, 'a');
+
+    // value undefined and values undefined => should not append
+    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() rhs)', () => {
+    const t = new TreeMultiMap<number, string>([], { isMapMode: true });
+    t.set(1, 'a');
+
+    // Patch getNode to be non-real so _setByNode uses `super.set(key, values)`.
+    const origGetNode = (t as any).getNode;
+    (t as any).getNode = () => (t as any)._NIL;
+
+    // Patch super.set to return false so _setByNode becomes falsy and OR evaluates _setToValues.
+    const rbProto = Object.getPrototypeOf(Object.getPrototypeOf(t));
+    const origSuperSet = rbProto.set;
+    rbProto.set = () => false;
+
+    try {
+      expect(t.set(1, 'b')).toBe(true);
+      expect(t.get(1)).toEqual(['a', 'b']);
+    } finally {
+      rbProto.set = origSuperSet;
+      (t as any).getNode = origGetNode;
+    }
+  });
+
+  it('_createInstance/_createLike cover snapshotOptions fallback (?? {}) and createLike default iter=[]', () => {
+    const t = new TreeMultiMap<number, string>();
+
+    const orig = (t as any)._snapshotOptions;
+    (t as any)._snapshotOptions = undefined;
+    try {
+      const inst = (t as any)._createInstance();
+      expect(inst).toBeInstanceOf(TreeMultiMap);
+
+      const like = (t as any)._createLike();
+      expect(like).toBeInstanceOf(TreeMultiMap);
+      expect(like.size).toBe(0);
+    } finally {
+      (t as any)._snapshotOptions = orig;
+    }
+  });
+});