data-structure-typed 2.2.7 → 2.3.0

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

@@ -0,0 +1,115 @@
+import { TreeCounter, TreeCounterNode } from '../../../../src';
+
+/**
+ * Coverage-focused tests for TreeCounter branches (count aggregation + delete paths).
+ * Keep existing @example tests intact.
+ */
+describe('TreeCounter coverage', () => {
+  it('TreeCounterNode.familyPosition covers ROOT/LEFT/RIGHT/ISOLATED cases', () => {
+    const isolated = new TreeCounterNode<number, number>(1);
+    expect(isolated.familyPosition).toBe('ISOLATED');
+
+    const root = new TreeCounterNode<number, number>(10);
+    const left = new TreeCounterNode<number, number>(5);
+    root.left = left;
+    expect(root.familyPosition).toBe('ROOT');
+    expect(left.familyPosition).toBe('LEFT');
+
+    left.left = new TreeCounterNode<number, number>(2);
+    expect(left.familyPosition).toBe('ROOT_LEFT');
+
+    const right = new TreeCounterNode<number, number>(15);
+    root.right = right;
+    expect(right.familyPosition).toBe('RIGHT');
+
+    right.right = new TreeCounterNode<number, number>(20);
+    expect(right.familyPosition).toBe('ROOT_RIGHT');
+  });
+
+  it('set increments aggregate count and createNode respects mapMode', () => {
+    const tc = new TreeCounter<number, string>();
+    tc.set(1, 'a', 2);
+    tc.set(2, 'b', 3);
+
+    expect(tc.count).toBe(5);
+    expect(tc.getComputedCount()).toBe(5);
+
+    // mapMode ignores node.value
+    const tcMap = new TreeCounter<number, string>([], { isMapMode: true });
+    tcMap.set(1, 'a', 2);
+    expect(tcMap.getNode(1)?.value).toBe(undefined);
+  });
+
+  it('delete decrements count when node.count>1 unless ignoreCount=true', () => {
+    const tc = new TreeCounter<number, number>();
+    tc.set(10, 10, 3);
+    expect(tc.count).toBe(3);
+
+    // decrement path
+    const r1 = tc.delete(10);
+    expect(r1).toHaveLength(1);
+    expect(tc.getNode(10)?.count).toBe(2);
+    expect(tc.count).toBe(2);
+
+    // ignoreCount removes node
+    const r2 = tc.delete(10, true);
+    expect(r2).toHaveLength(1);
+    expect(tc.getNode(10)).toBeUndefined();
+    expect(tc.count).toBe(0);
+  });
+
+  it('delete covers left-only/right-only and two-child paths', () => {
+    const tc = new TreeCounter<number, number>();
+
+    // right-only child case
+    tc.set(10, 10, 1);
+    tc.set(20, 20, 1);
+    expect(tc.delete(10, true)).toHaveLength(1);
+    expect(tc.getNode(10)).toBeUndefined();
+
+    tc.clear();
+
+    // left-only child case
+    tc.set(10, 10, 1);
+    tc.set(5, 5, 1);
+    expect(tc.delete(10, true)).toHaveLength(1);
+    expect(tc.getNode(10)).toBeUndefined();
+
+    tc.clear();
+
+    // two children successor path
+    for (const k of [10, 5, 15, 12, 18]) tc.set(k, k, 1);
+    expect(tc.delete(10, true)).toHaveLength(1);
+    expect(tc.getNode(10)).toBeUndefined();
+    expect(tc.count).toBe(4);
+  });
+
+  it('perfectlyBalance returns false on empty and true on non-empty (preserves count)', () => {
+    const tcEmpty = new TreeCounter<number, number>();
+    expect(tcEmpty.perfectlyBalance()).toBe(false);
+
+    const tc = new TreeCounter<number, number>();
+    tc.set(3, 3, 2);
+    tc.set(1, 1, 1);
+    tc.set(4, 4, 1);
+    expect(tc.count).toBe(4);
+
+    expect(tc.perfectlyBalance('ITERATIVE')).toBe(true);
+    expect(tc.count).toBe(4);
+    expect(tc.getComputedCount()).toBe(4);
+  });
+
+  it('map/clone exercise _createLike/_createInstance and preserve aggregate count', () => {
+    const tc = new TreeCounter<number, number>();
+    tc.set(1, 10, 2);
+    tc.set(2, 20, 1);
+
+    const mapped = tc.map((v, k) => [k + 1, (v ?? 0) + 1]);
+    expect(mapped.get(2)).toBe(11);
+    expect(mapped.get(3)).toBe(21);
+
+    const cloned = tc.clone();
+    expect(cloned.count).toBe(tc.count);
+    expect(cloned.getComputedCount()).toBe(tc.count);
+  });
+});

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

@@ -0,0 +1,244 @@
+import { TreeCounter, TreeCounterNode } from '../../../../src';
+
+describe('TreeCounter additional branch coverage', () => {
+  it('getComputedCount sums 0 for null nodes (covers node ? node.count : 0 false arm)', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+
+    // Force dfs callback to receive a null once, so ternary false arm is executed.
+    const origDfs = (t as any).dfs;
+    (t as any).dfs = (cb: any) => {
+      cb(null);
+      return [];
+    };
+
+    try {
+      expect(t.getComputedCount()).toBe(0);
+    } finally {
+      (t as any).dfs = origDfs;
+    }
+  });
+
+  it('createNode default color arg branch and mapMode=true forces value undefined', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: true } as any);
+    const n = t.createNode(1, 123); // default color arg
+    expect(n.value).toBeUndefined();
+  });
+
+  it('set() with null/undefined keyNodeOrEntry makes orgCount=0 and returns false (covers orgCount false arm)', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+    expect(t.set(undefined as any)).toBe(false);
+    expect(t.set(null as any)).toBe(false);
+  });
+
+  it('delete(null) returns [] (covers early return)', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+    expect(t.delete(null as any)).toEqual([]);
+  });
+
+  it('delete(predicate) uses predicate branch and returns [] when predicate matches none', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+    t.set(1, 1);
+    expect(t.delete((n) => n?.key === 999)).toEqual([]);
+  });
+
+  it('delete(realNode) uses the isRealNode(keyNodeOrEntry) ? keyNodeOrEntry : getNode(...) true arm', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+    t.set(10, 10);
+    t.set(5, 5);
+    t.set(15, 15);
+
+    const n = t.getNode(5)!;
+    const res = t.delete(n as any, true);
+    expect(res.length).toBe(1);
+    expect(t.has(5)).toBe(false);
+  });
+
+  it('delete(decrement count) path when node.count>1 and ignoreCount=false', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+    t.set(1, 1);
+    t.set(1, 1);
+    expect(t.count).toBe(2);
+
+    const res = t.delete(1, false);
+    expect(res.length).toBe(1);
+    expect(t.count).toBe(1);
+    expect(t.getNode(1)!.count).toBe(1);
+  });
+
+  it('delete(two children) else-branch with successor.parent !== nodeToDelete and ignoreCount=true', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+
+    // Build a BST-shape manually to avoid balancing changing successor relationships.
+    // nodeToDelete = 10, right subtree has left chain so successor.parent !== nodeToDelete
+    const n10: any = t.createNode(10, 10);
+    const n5: any = t.createNode(5, 5);
+    const n15: any = t.createNode(15, 15);
+    const n12: any = t.createNode(12, 12);
+    const n11: any = t.createNode(11, 11);
+
+    n10.left = n5;
+    n10.right = n15;
+    n5.parent = n10;
+    n15.parent = n10;
+
+    n15.left = n12;
+    n12.parent = n15;
+
+    n12.left = n11;
+    n11.parent = n12;
+
+    (t as any)._setRoot(n10);
+    (t as any)._size = 5;
+    (t as any)._count = 5;
+
+    const out = t.delete(10, true);
+    expect(out.length).toBe(1);
+    expect(t.has(10)).toBe(false);
+  });
+
+  it('perfectlyBalance uses default iterationType arg and recomputes _count (also covers nd?nd.count:0 false arm via dfs monkeypatch)', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+    expect(t.perfectlyBalance('ITERATIVE' as any)).toBe(false);
+
+    t.set(3, 3);
+    t.set(1, 1);
+    t.set(2, 2);
+
+    // call without arg to cover default-arg branch (iterationType = this.iterationType)
+    expect(t.perfectlyBalance()).toBe(true);
+    expect(t.count).toBe(3);
+
+    // additionally, cover the nd ? nd.count : 0 false arm in the internal total recompute loop,
+    // without breaking index-based access during tree rebuild.
+    const origDfs = (t as any).dfs;
+    (t as any).dfs = (...args: any[]) => {
+      const nodes: any[] = origDfs.apply(t, args);
+      const origIter = nodes[Symbol.iterator].bind(nodes);
+      // @ts-ignore
+      nodes[Symbol.iterator] = function* () {
+        yield null;
+        yield* origIter();
+      };
+      return nodes;
+    };
+    try {
+      expect(t.perfectlyBalance()).toBe(true);
+    } finally {
+      (t as any).dfs = origDfs;
+    }
+  });
+
+  it('map() uses thisArg + _createLike options path', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+    t.set(1, 10);
+    t.set(2, 20);
+
+    const ctx = { mul: 3 };
+    const out = t.map(function (this: any, v: any, k: any) {
+      return [k + 10, v * this.mul];
+    }, { isMapMode: false } as any, ctx);
+
+    expect(out.has(11)).toBe(true);
+    expect(out.get(11)).toBe(30);
+  });
+
+  it('clone() covers both `if (!node) continue` and outNode missing branch', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+    t.set(1, 1);
+    t.set(1, 1);
+    t.set(2, 2);
+
+    // Force dfs() used by clone() to yield a null once to hit `if (!node) continue`.
+    const origDfs = (t as any).dfs;
+    (t as any).dfs = (...args: any[]) => {
+      const nodes: any[] = origDfs.apply(t, args);
+      const origIter = nodes[Symbol.iterator].bind(nodes);
+      // @ts-ignore
+      nodes[Symbol.iterator] = function* () {
+        yield null;
+        yield* origIter();
+      };
+      return nodes;
+    };
+
+    const origCreateInstance = (t as any)._createInstance;
+    (t as any)._createInstance = () => {
+      const out = origCreateInstance.call(t);
+      // Make getNode return undefined so `if (outNode)` is false.
+      (out as any).getNode = () => undefined;
+      return out;
+    };
+
+    try {
+      const c = t.clone();
+      expect((c as any)._count).toBe((t as any)._count);
+    } finally {
+      (t as any)._createInstance = origCreateInstance;
+      (t as any).dfs = origDfs;
+    }
+  });
+
+  it('_createInstance uses options merge (covers options ?? {} merge)', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false } as any);
+    const inst = (t as any)._createInstance({ iterationType: 'RECURSIVE' });
+    expect(inst).toBeDefined();
+  });
+
+  it('_createLike default-arg path can be called with no args', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false } as any);
+    const like = (t as any)._createLike();
+    expect(like).toBeDefined();
+  });
+
+  it('_keyValueNodeOrEntryToNodeAndValue entry null key returns [undefined, undefined]', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+    const out = (t as any)._keyValueNodeOrEntryToNodeAndValue([null, 1] as any);
+    expect(out).toEqual([undefined, undefined]);
+  });
+
+  it('_swapProperties returns undefined when ensureNode fails', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+    expect((t as any)._swapProperties(null, null)).toBeUndefined();
+
+    // src ok, dest missing
+    t.set(1, 1);
+    const src = t.getNode(1)!;
+    expect((t as any)._swapProperties(src, 9999)).toBeUndefined();
+  });
+
+  it('_swapProperties in mapMode=true skips value-copy branches (covers !this._isMapMode false arms)', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: true } as any);
+    const a: any = t.createNode(1, 10);
+    const b: any = t.createNode(2, 20);
+    // attach as a tiny tree so ensureNode works
+    (t as any)._setRoot(a);
+    a.right = b;
+    b.parent = a;
+
+    const out = (t as any)._swapProperties(a, b);
+    expect(out).toBeDefined();
+  });
+
+  it('_swapProperties in mapMode=false executes value-copy branches (covers !this._isMapMode true arms)', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false } as any);
+    const a: any = t.createNode(1, 10);
+    const b: any = t.createNode(2, 20);
+    (t as any)._setRoot(a);
+    a.right = b;
+    b.parent = a;
+
+    const out = (t as any)._swapProperties(a, b);
+    expect(out).toBeDefined();
+    // After swap, values should have been copied.
+    expect(a.value).toBe(20);
+    expect(b.value).toBe(10);
+  });
+
+  it('_replaceNode increments newNode.count before delegating', () => {
+    const t = new TreeCounter<number, number>([], { isMapMode: false });
+    const oldN = new TreeCounterNode(1, 1, 2, 'BLACK');
+    const newN = new TreeCounterNode(1, 1, 3, 'BLACK');
+    const out = (t as any)._replaceNode(oldN, newN);
+    expect(out.count).toBe(5);
+  });
+});

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

@@ -12,7 +12,7 @@ describe('TreeCounter count', () => {
   });
 
   it('Should added node count ', () => {
-    treeCounter.addMany([
+    treeCounter.setMany([
       [1, 1],
       [2, 2],
       [3, 3],
@@ -20,14 +20,14 @@ describe('TreeCounter count', () => {
       [5, 5]
     ]);
     const newNode = new TreeCounterNode(3, 33, 10);
-    treeCounter.add(newNode);
+    treeCounter.set(newNode);
     expect(treeCounter.count).toBe(15);
     expect(treeCounter.getComputedCount()).toBe(15);
     expect(treeCounter.getNode(3)?.count).toBe(11);
   });
 
   it('Should count', () => {
-    treeCounter.addMany([
+    treeCounter.setMany([
       [1, 1],
       [2, 2],
       [3, 3]
@@ -44,7 +44,7 @@ describe('TreeCounter operations test1', () => {
     expect(treeCounter.getHeight()).toBe(-1);
     expect(treeCounter.getMinHeight()).toBe(-1);
 
-    treeCounter.addMany([1, 6, 7, 2, 3, 4, 9, 11, 8, 5, 10, 12, 16, 14, 13, 15]);
+    treeCounter.setMany([1, 6, 7, 2, 3, 4, 9, 11, 8, 5, 10, 12, 16, 14, 13, 15]);
     // treeCounter.print()
     expect(treeCounter.getHeight()).toBe(5);
     expect(treeCounter.getMinHeight()).toBe(2);
@@ -55,8 +55,8 @@ describe('TreeCounter operations test1', () => {
 
     expect(treeCounter instanceof TreeCounter);
 
-    treeCounter.add([11, 11]);
-    treeCounter.add([3, 3]);
+    treeCounter.set([11, 11]);
+    treeCounter.set([3, 3]);
     expect(treeCounter.count).toBe(2);
     expect(treeCounter.getComputedCount()).toBe(2);
     expect(treeCounter.size).toBe(2);
@@ -80,7 +80,7 @@ describe('TreeCounter operations test1', () => {
       [5, 5]
     ];
 
-    treeCounter.addMany(keyValuePairs);
+    treeCounter.setMany(keyValuePairs);
     expect(treeCounter.size).toBe(16);
     expect(treeCounter.count).toBe(18);
     expect(treeCounter.getComputedCount()).toBe(18);
@@ -97,8 +97,8 @@ describe('TreeCounter operations test1', () => {
 
     expect(treeCounter instanceof TreeCounter);
 
-    treeCounter.add([11, 11]);
-    treeCounter.add([3, 3]);
+    treeCounter.set([11, 11]);
+    treeCounter.set([3, 3]);
     const idAndValues: [number, number][] = [
       [11, 11],
       [3, 3],
@@ -117,7 +117,7 @@ describe('TreeCounter operations test1', () => {
       [10, 10],
       [5, 5]
     ];
-    treeCounter.addMany(idAndValues);
+    treeCounter.setMany(idAndValues);
     expect(treeCounter.root instanceof TreeCounterNode);
 
     if (treeCounter.root) expect(treeCounter.root.key == 11);
@@ -309,15 +309,16 @@ describe('TreeCounter operations test1', () => {
     expect(bfsNodes[1].key).toBe(2);
     expect(bfsNodes[2].key).toBe(16);
 
-    expect(treeCounter.count).toBe(6);
+    // Aggregate count should match computed count.
+    expect(treeCounter.count).toBe(8);
     expect(treeCounter.getComputedCount()).toBe(8);
   });
 
   it('should perform various operations on a TreeCounter with object values', () => {
     const objTreeCounter = new TreeCounter<number, { key: number; keyA: number }>();
     expect(objTreeCounter).toBeInstanceOf(TreeCounter);
-    objTreeCounter.add([11, { key: 11, keyA: 11 }]);
-    objTreeCounter.add([3, { key: 3, keyA: 3 }]);
+    objTreeCounter.set([11, { key: 11, keyA: 11 }]);
+    objTreeCounter.set([3, { key: 3, keyA: 3 }]);
     const values: [number, { key: number; keyA: number }][] = [
       [15, { key: 15, keyA: 15 }],
       [1, { key: 1, keyA: 1 }],
@@ -335,7 +336,7 @@ describe('TreeCounter operations test1', () => {
       [5, { key: 5, keyA: 5 }]
     ];
 
-    objTreeCounter.addMany(values);
+    objTreeCounter.setMany(values);
 
     expect(objTreeCounter.root).toBeInstanceOf(TreeCounterNode);
 
@@ -355,8 +356,8 @@ describe('TreeCounter operations test recursively1', () => {
     });
 
     expect(treeCounter instanceof TreeCounter);
-    treeCounter.add([11, 11]);
-    treeCounter.add([3, 3]);
+    treeCounter.set([11, 11]);
+    treeCounter.set([3, 3]);
     const idAndValues: [number, number][] = [
       [11, 11],
       [3, 3],
@@ -375,7 +376,7 @@ describe('TreeCounter operations test recursively1', () => {
       [10, 10],
       [5, 5]
     ];
-    treeCounter.addMany(idAndValues);
+    treeCounter.setMany(idAndValues);
     expect(treeCounter.root).toBeInstanceOf(TreeCounterNode);
 
     if (treeCounter.root) expect(treeCounter.root.key).toBe(5);
@@ -576,15 +577,16 @@ describe('TreeCounter operations test recursively1', () => {
     expect(bfsNodes[1].key).toBe(2);
     expect(bfsNodes[2].key).toBe(16);
 
-    expect(treeCounter.count).toBe(6);
+    // Aggregate count should match computed count.
+    expect(treeCounter.count).toBe(8);
     expect(treeCounter.getComputedCount()).toBe(8);
   });
 
   it('should perform various operations on a TreeCounter with object values', () => {
     const objTreeCounter = new TreeCounter<number, { key: number; keyA: number }>();
     expect(objTreeCounter).toBeInstanceOf(TreeCounter);
-    objTreeCounter.add([11, { key: 11, keyA: 11 }]);
-    objTreeCounter.add([3, { key: 3, keyA: 3 }]);
+    objTreeCounter.set([11, { key: 11, keyA: 11 }]);
+    objTreeCounter.set([3, { key: 3, keyA: 3 }]);
     const values: [number, { key: number; keyA: number }][] = [
       [15, { key: 15, keyA: 15 }],
       [1, { key: 1, keyA: 1 }],
@@ -602,7 +604,7 @@ describe('TreeCounter operations test recursively1', () => {
       [5, { key: 5, keyA: 5 }]
     ];
 
-    objTreeCounter.addMany(values);
+    objTreeCounter.setMany(values);
 
     expect(objTreeCounter.root).toBeInstanceOf(TreeCounterNode);
 
@@ -631,7 +633,7 @@ describe('TreeCounter delete test', function () {
 
   it('The structure remains normal after random deletion', function () {
     for (let i = 0; i < inputSize; i++) {
-      treeCounter.add(i);
+      treeCounter.set(i);
     }
 
     expect(treeCounter.size).toBe(inputSize);
@@ -660,7 +662,7 @@ describe('TreeCounter delete test', function () {
     for (let i = 0; i < inputSize; i++) {
       const num = getRandomInt(0, inputSize - 1);
       if (i === 0 && isDebug) console.log(`first:`, num);
-      treeCounter.add(num);
+      treeCounter.set(num);
     }
 
     for (let i = 0; i < inputSize; i++) {
@@ -686,7 +688,7 @@ describe('TreeCounter delete test', function () {
     for (let i = 0; i < inputSize; i++) {
       const num = getRandomInt(0, inputSize - 1);
       if (i === 0 && isDebug) console.log(`first:`, num);
-      treeCounter.add(num);
+      treeCounter.set(num);
     }
 
     for (let i = 0; i < inputSize; i++) {
@@ -721,7 +723,7 @@ describe('TreeCounter delete test', function () {
     }
 
     const treeCounter = new TreeCounter<string, number>();
-    treeCounter.addMany([
+    treeCounter.setMany([
       ['2', 2],
       ['4', 4],
       ['5', 5],
@@ -750,9 +752,9 @@ describe('TreeCounter iterative methods test', () => {
   let treeCounter: TreeCounter<number, string>;
   beforeEach(() => {
     treeCounter = new TreeCounter<number, string>();
-    treeCounter.add(1, 'a', 10);
-    treeCounter.add([2, 'b'], undefined, 10);
-    treeCounter.add([3, 'c'], undefined, 1);
+    treeCounter.set(1, 'a', 10);
+    treeCounter.set([2, 'b'], undefined, 10);
+    treeCounter.set([3, 'c'], undefined, 1);
   });
 
   it('The node obtained by get Node should match the node type', () => {
@@ -845,7 +847,7 @@ describe('TreeCounter count not map mode', () => {
   });
 
   it('Should added node count ', () => {
-    treeCounter.addMany([
+    treeCounter.setMany([
       [1, 1],
       [2, 2],
       [3, 3],
@@ -853,7 +855,7 @@ describe('TreeCounter count not map mode', () => {
       [5, 5]
     ]);
     const newNode = new TreeCounterNode(3, undefined, 10);
-    treeCounter.add(newNode, 33, 20);
+    treeCounter.set(newNode, 33, 20);
     // TODO expect(treeCounter.count).toBe(25);
     expect(treeCounter.count).toBe(15);
     expect(treeCounter.getComputedCount()).toBe(15);
@@ -867,8 +869,8 @@ describe('TreeCounter operations test1 not map mode', () => {
 
     expect(treeCounter instanceof TreeCounter);
 
-    treeCounter.add([11, 11]);
-    treeCounter.add([3, 3]);
+    treeCounter.set([11, 11]);
+    treeCounter.set([3, 3]);
     const idAndValues: [number, number][] = [
       [11, 11],
       [3, 3],
@@ -887,7 +889,7 @@ describe('TreeCounter operations test1 not map mode', () => {
       [10, 10],
       [5, 5]
     ];
-    treeCounter.addMany(idAndValues);
+    treeCounter.setMany(idAndValues);
     expect(treeCounter.root instanceof TreeCounterNode);
 
     if (treeCounter.root) expect(treeCounter.root.key == 11);
@@ -916,8 +918,8 @@ describe('TreeCounter operations test recursively1 not map mode', () => {
     });
 
     expect(treeCounter instanceof TreeCounter);
-    treeCounter.add([11, 11]);
-    treeCounter.add([3, 3]);
+    treeCounter.set([11, 11]);
+    treeCounter.set([3, 3]);
     const idAndValues: [number, number][] = [
       [11, 11],
       [3, 3],
@@ -936,7 +938,7 @@ describe('TreeCounter operations test recursively1 not map mode', () => {
       [10, 10],
       [5, 5]
     ];
-    treeCounter.addMany(idAndValues);
+    treeCounter.setMany(idAndValues);
     expect(treeCounter.root).toBeInstanceOf(TreeCounterNode);
 
     if (treeCounter.root) expect(treeCounter.root.key).toBe(5);
@@ -961,9 +963,9 @@ describe('TreeCounter iterative methods test not map mode', () => {
   let treeCounter: TreeCounter<number, string>;
   beforeEach(() => {
     treeCounter = new TreeCounter<number, string>([], { isMapMode: false });
-    treeCounter.add(1, 'a', 10);
-    treeCounter.add([2, 'b'], undefined, 10);
-    treeCounter.add([3, 'c'], undefined, 1);
+    treeCounter.set(1, 'a', 10);
+    treeCounter.set([2, 'b'], undefined, 10);
+    treeCounter.set([3, 'c'], undefined, 1);
   });
 
   it('should clone work well', () => {