data-structure-typed 1.52.4 → 1.52.5

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

@@ -1,9 +1,37 @@
 import { BinaryTreeNode, BST, BSTNode } from '../../../../src';
-import { isDebugTest } from '../../../config';
+import { isDebugTest, SYSTEM_MAX_CALL_STACK, isTestStackOverflow } from '../../../config';
 
 const isDebug = isDebugTest;
 
 describe('BST operations test', () => {
+  it('should add undefined and null', () => {
+    const bst = new BST<number, string>();
+    const isAddUndefined = bst.add(undefined);
+    expect(isAddUndefined).toBe(false);
+    expect(bst.get(undefined)).toBe(undefined);
+    const isAddNull = bst.add(null);
+    expect(isAddNull).toBe(false);
+    expect(bst.get(null)).toBe(undefined);
+    const isAdd0 = bst.add(0, '0');
+    expect(isAdd0).toBe(true);
+    expect(bst.get(0)).toBe('0');
+  });
+  it('should addMany undefined and null', () => {
+    const bst = new BST<number, string>();
+    const addManyWithUndefined = bst.addMany([1, undefined, 3]);
+    // TODO
+    // expect(addManyWithUndefined).toEqual([true, false, true]);
+    expect(addManyWithUndefined).toEqual([true, true]);
+    expect(bst.get(undefined)).toBe(undefined);
+    const addManyWithNull = bst.addMany([1, null, 3, 4]);
+    // TODO
+    // expect(addManyWithNull).toEqual([false, false, false, true]);
+    expect(addManyWithNull).toEqual([true, true, true]);
+    expect(bst.get(null)).toBe(undefined);
+    const node0 = bst.add(0, '0');
+    expect(node0).toBe(true);
+    expect(bst.get(0)).toBe('0');
+  });
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
     const bst = new BST<number, number>();
     expect(bst).toBeInstanceOf(BST);
@@ -45,12 +73,12 @@ describe('BST operations test', () => {
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = bst.getLeftMost();
-    expect(leftMost?.key).toBe(1);
+    expect(leftMost).toBe(1);
 
     expect(bst.isBST()).toBe(true);
 
     const node15 = bst.getNode(15);
-    const minNodeBySpecificNode = node15 && bst.getLeftMost(node15);
+    const minNodeBySpecificNode = node15 && bst.getLeftMost(node => node, node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
@@ -249,14 +277,14 @@ describe('BST operations test', () => {
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = objBST.getLeftMost();
-    expect(leftMost?.key).toBe(1);
+    expect(leftMost).toBe(1);
 
     const node15 = objBST.getNode(15);
     expect(node15?.value).toEqual({
       name: 'Alice',
       age: 15
     });
-    const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
+    const minNodeBySpecificNode = node15 && objBST.getLeftMost(node => node, node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
@@ -410,6 +438,24 @@ describe('BST operations test', () => {
     expect(bfsNodes[1].key).toBe(12);
     expect(bfsNodes[2].key).toBe(16);
   });
+
+  it('should keyValueOrEntryOrRawElementToNode', () => {
+    const bst = new BST<number>();
+    const node0 = bst.keyValueOrEntryOrRawElementToNode(0);
+    expect(node0).toEqual({
+      _left: undefined,
+      _right: undefined,
+      key: 0,
+      parent: undefined,
+      value: undefined
+    });
+
+    const nodeUndefined = bst.keyValueOrEntryOrRawElementToNode(undefined);
+    expect(nodeUndefined).toBe(undefined);
+
+    const nodeNull = bst.keyValueOrEntryOrRawElementToNode(null);
+    expect(nodeNull).toBe(undefined);
+  });
 });
 
 describe('BST operations test recursively', () => {
@@ -442,10 +488,10 @@ describe('BST operations test recursively', () => {
     expect(nodeVal9?.key).toBe(undefined);
 
     const leftMost = bst.getLeftMost();
-    expect(leftMost?.key).toBe(1);
+    expect(leftMost).toBe(1);
 
     const node15 = bst.getNode(15);
-    const minNodeBySpecificNode = node15 && bst.getLeftMost(node15);
+    const minNodeBySpecificNode = node15 && bst.getLeftMost(node => node, node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
@@ -645,14 +691,14 @@ describe('BST operations test recursively', () => {
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = objBST.getLeftMost();
-    expect(leftMost?.key).toBe(1);
+    expect(leftMost).toBe(1);
 
     const node15 = objBST.getNode(15);
     expect(node15?.value).toEqual({
       key: 15,
       keyA: 15
     });
-    const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
+    const minNodeBySpecificNode = node15 && objBST.getLeftMost(node => node, node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
@@ -870,16 +916,43 @@ describe('BST operations test recursively', () => {
     cloned.delete('5');
     expect(cloned.size).toBe(0);
   });
+
+  if (isTestStackOverflow) {
+    it('should getLeftMost', () => {
+      const bst = new BST<number>([], { comparator: (a, b) => b - a });
+      for (let i = 1; i <= SYSTEM_MAX_CALL_STACK; i++) bst.add(i);
+
+      expect(() => {
+        const leftMost = bst.getLeftMost(node => node, bst.root, 'RECURSIVE');
+        expect(leftMost?.key).toEqual(SYSTEM_MAX_CALL_STACK);
+      }).toThrow('Maximum call stack size exceeded');
+
+      const leftMost = bst.getLeftMost(node => node, bst.root, 'ITERATIVE');
+      expect(leftMost?.key).toEqual(SYSTEM_MAX_CALL_STACK);
+    });
+
+    it('should getRightMost', () => {
+      const bst = new BST<number>();
+      for (let i = 1; i <= SYSTEM_MAX_CALL_STACK; i++) bst.add(i);
+
+      expect(() => {
+        const rightMost = bst.getRightMost(node => node, bst.root, 'RECURSIVE');
+        expect(rightMost?.key).toEqual(SYSTEM_MAX_CALL_STACK);
+      }).toThrow('Maximum call stack size exceeded');
+      const rightMost = bst.getRightMost(node => node, bst.root, 'ITERATIVE');
+      expect(rightMost?.key).toEqual(SYSTEM_MAX_CALL_STACK);
+    });
+  }
 });
 
 describe('BST isBST', function () {
-  test('isBST', () => {
+  it('isBST', () => {
     const bst = new BST<number, number>();
     bst.addMany([1, 2, 3, 9, 8, 5, 6, 7, 4]);
     expect(bst.isBST()).toBe(true);
   });
 
-  test('isBST when variant is Max', () => {
+  it('isBST when variant is Max', () => {
     const bst = new BST<number, number>([1, 2, 3, 9, 8, 5, 6, 7, 4], {
       comparator: (a, b) => b - a
     });
@@ -956,18 +1029,24 @@ describe('BST iterative methods test', () => {
   let bst: BST<number, string>;
   beforeEach(() => {
     bst = new BST();
-    bst.add([1, 'a']);
-    bst.add([2, 'b']);
-    bst.add([3, 'c']);
+    bst.addMany(
+      [
+        [1, 'a'],
+        [2, 'b'],
+        [3, 'c']
+      ],
+      [],
+      false
+    );
   });
 
-  test('The node obtained by get Node should match the node type', () => {
+  it('The node obtained by get Node should match the node type', () => {
     const node3 = bst.getNode(3);
     expect(node3).toBeInstanceOf(BinaryTreeNode);
     expect(node3).toBeInstanceOf(BSTNode);
   });
 
-  test('forEach should iterate over all elements', () => {
+  it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
     bst.forEach((value, key) => {
       mockCallback(value, key);
@@ -979,7 +1058,7 @@ describe('BST iterative methods test', () => {
     expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
   });
 
-  test('filter should return a new tree with filtered elements', () => {
+  it('filter should return a new tree with filtered elements', () => {
     const filteredTree = bst.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
@@ -988,7 +1067,7 @@ describe('BST iterative methods test', () => {
     ]);
   });
 
-  test('map should return a new tree with modified elements', () => {
+  it('map should return a new tree with modified elements', () => {
     const mappedTree = bst.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([
@@ -998,12 +1077,12 @@ describe('BST iterative methods test', () => {
     ]);
   });
 
-  test('reduce should accumulate values', () => {
+  it('reduce should accumulate values', () => {
     const sum = bst.reduce((acc, value, key) => acc + key, 0);
     expect(sum).toBe(6);
   });
 
-  test('[Symbol.iterator] should provide an iterator', () => {
+  it('[Symbol.iterator] should provide an iterator', () => {
     const entries = [];
     for (const entry of bst) {
       entries.push(entry);
@@ -1017,19 +1096,84 @@ describe('BST iterative methods test', () => {
     ]);
   });
 
-  test('should clone work well', () => {
+  it('should clone work well', () => {
     const cloned = bst.clone();
     expect(cloned.root?.left).toBe(undefined);
     expect(cloned.root?.right?.value).toBe('b');
   });
 
-  test('should keys', () => {
+  it('should keys', () => {
     const keys = bst.keys();
     expect([...keys]).toEqual([1, 2, 3]);
   });
 
-  test('should values', () => {
+  it('should values', () => {
     const values = bst.values();
     expect([...values]).toEqual(['a', 'b', 'c']);
   });
+
+  it('should leaves', () => {
+    const leaves = bst.leaves();
+    expect(leaves).toEqual([3]);
+  });
+
+  it('should collapsed, unbalanced, balanced bst leaves', () => {
+    const collapsedToLinkedList = new BST();
+    collapsedToLinkedList.addMany(
+      [
+        [1, 'a'],
+        [2, 'b'],
+        [3, 'c'],
+        [4, 'd'],
+        [5, 'e'],
+        [6, 'f'],
+        [7, 'g'],
+        [8, 'h'],
+        [9, 'i']
+      ],
+      [],
+      false
+    );
+
+    expect(collapsedToLinkedList.leaves()).toEqual([9]);
+
+    const unbalanced = new BST();
+    unbalanced.addMany(
+      [
+        [2, 'b'],
+        [1, 'a'],
+        [3, 'c'],
+        [4, 'd'],
+        [5, 'e'],
+        [6, 'f'],
+        [7, 'g'],
+        [8, 'h'],
+        [9, 'i']
+      ],
+      [],
+      false
+    );
+
+    expect(unbalanced.leaves()).toEqual([1, 9]);
+
+    const balanced = new BST();
+    balanced.addMany(
+      [
+        [2, 'b'],
+        [1, 'a'],
+        [3, 'c'],
+        [4, 'd'],
+        [5, 'e'],
+        [6, 'f'],
+        [7, 'g'],
+        [8, 'h'],
+        [9, 'i']
+      ],
+      [],
+      true
+    );
+
+    expect(balanced.leaves()).toEqual([1, 6, 4, 9]);
+    expect(balanced.leaves(node => node?.value)).toEqual(['a', 'f', 'd', 'i']);
+  });
 });

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

@@ -18,7 +18,7 @@ describe('Overall BinaryTree Test', () => {
     expect(bst.getDepth(6)).toBe(3); // true
     const leftMost = bst.getLeftMost();
     leftMost?.key === 1; // true
-    expect(leftMost?.key).toBe(1);
+    expect(leftMost).toBe(1);
     bst.delete(6);
     bst.getNode(6); // undefined
     expect(bst.getNode(6)).toBe(undefined);

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

@@ -68,13 +68,13 @@ describe('RedBlackTree 1', () => {
       rbTree.add(15);
       rbTree.add(3);
 
-      const minNode = rbTree.getLeftMost(rbTree.root);
+      const minNode = rbTree.getLeftMost(node => node, rbTree.root);
       expect(minNode?.key).toBe(3);
     });
 
     it('should handle an empty rbTree', () => {
-      const minNode = rbTree.getLeftMost(rbTree.root);
-      expect(minNode).toBe(rbTree.NIL);
+      const minNode = rbTree.getLeftMost(node => node, rbTree.root);
+      expect(minNode).toBe(undefined);
     });
   });
 
@@ -86,13 +86,13 @@ describe('RedBlackTree 1', () => {
       rbTree.add(15);
       rbTree.add(25);
 
-      const maxNode = rbTree.getRightMost(rbTree.root);
+      const maxNode = rbTree.getRightMost(node => node, rbTree.root);
       expect(maxNode?.key).toBe(25);
     });
 
     it('should handle an empty rbTree', () => {
-      const maxNode = rbTree.getRightMost(rbTree.root);
-      expect(maxNode).toBe(rbTree.NIL);
+      const maxNode = rbTree.getRightMost(node => node, rbTree.root);
+      expect(maxNode).toBe(undefined);
     });
   });
 
@@ -433,7 +433,7 @@ describe('RedBlackTree 2', () => {
     rbTree.add(15);
 
     const nodeLM = rbTree.getLeftMost();
-    expect(nodeLM?.key).toBe(1);
+    expect(nodeLM).toBe(1);
 
     const node50 = rbTree.getNode(50);
     expect(node50?.key).toBe(50);
@@ -619,14 +619,14 @@ describe('RedBlackTree 2', () => {
       rbTree.add([3, 'c']);
     });
 
-    test('The node obtained by get Node should match the node type', () => {
+    it('The node obtained by get Node should match the node type', () => {
       const node3 = rbTree.getNode(3);
       expect(node3).toBeInstanceOf(BinaryTreeNode);
       expect(node3).toBeInstanceOf(BSTNode);
       expect(node3).toBeInstanceOf(RedBlackTreeNode);
     });
 
-    test('forEach should iterate over all elements', () => {
+    it('forEach should iterate over all elements', () => {
       const mockCallback = jest.fn();
       rbTree.forEach((value, key) => {
         mockCallback(value, key);
@@ -638,7 +638,7 @@ describe('RedBlackTree 2', () => {
       expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
     });
 
-    test('filter should return a new rbTree with filtered elements', () => {
+    it('filter should return a new rbTree with filtered elements', () => {
       const filteredTree = rbTree.filter((value, key) => key > 1);
       expect(filteredTree.size).toBe(2);
       expect([...filteredTree]).toEqual([
@@ -647,7 +647,7 @@ describe('RedBlackTree 2', () => {
       ]);
     });
 
-    test('map should return a new rbTree with modified elements', () => {
+    it('map should return a new rbTree with modified elements', () => {
       const mappedTree = rbTree.map((value, key) => (key * 2).toString());
       expect(mappedTree.size).toBe(3);
       expect([...mappedTree]).toEqual([
@@ -657,12 +657,12 @@ describe('RedBlackTree 2', () => {
       ]);
     });
 
-    test('reduce should accumulate values', () => {
+    it('reduce should accumulate values', () => {
       const sum = rbTree.reduce((acc, value, key) => acc + key, 0);
       expect(sum).toBe(6);
     });
 
-    test('[Symbol.iterator] should provide an iterator', () => {
+    it('[Symbol.iterator] should provide an iterator', () => {
       const entries = [];
       for (const entry of rbTree) {
         entries.push(entry);
@@ -677,3 +677,126 @@ describe('RedBlackTree 2', () => {
     });
   });
 });
+
+describe('RedBlackTree - _deleteFixup', () => {
+  let tree: RedBlackTree<number, number>;
+
+  beforeEach(() => {
+    tree = new RedBlackTree();
+  });
+
+  it('should handle deleting a red leaf node', () => {
+    tree.add(10, 10);
+    tree.add(5, 5); // Red leaf
+    tree.add(20, 20);
+
+    expect(tree.delete(5)).toHaveLength(1); // Delete red leaf
+    expect(tree.root?.left).toBe(tree.NIL); // Left child should be NIL
+  });
+
+  it('should handle deleting a black leaf node', () => {
+    tree.add(10, 10);
+    tree.add(5, 5); // Black node
+    tree.add(20, 20);
+    tree.add(1, 1); // Black leaf node
+
+    expect(tree.delete(1)).toHaveLength(1); // Delete black leaf
+    expect(tree.root?.left?.left).toBe(tree.NIL);
+  });
+
+  it('should handle deleting black node with red sibling', () => {
+    tree.add(10, 10);
+    tree.add(5, 5); // Black node
+    tree.add(20, 20); // Red sibling
+    tree.add(25, 25); // Force the sibling to be red
+
+    expect(tree.delete(5)).toHaveLength(1); // Delete black node
+    expect(tree.root?.right?.color).toBe('BLACK'); // Ensure sibling color is black after fixup
+  });
+
+  it('should handle deleting black node with black sibling', () => {
+    tree.add(10, 10);
+    tree.add(5, 5); // Black node
+    tree.add(20, 20); // Black sibling
+
+    expect(tree.delete(5)).toHaveLength(1); // Delete black node
+    expect(tree.root?.left).toBe(tree.NIL);
+  });
+
+  it('should handle deleting the root node', () => {
+    tree.add(10, 10); // Root node
+    tree.add(5, 5);
+    tree.add(20, 20);
+
+    expect(tree.delete(10)).toHaveLength(1); // Delete root node
+    expect(tree.root?.key).toBe(20); // New root should be 20
+  });
+
+  it('should handle complex case with multiple rotations', () => {
+    tree.add(10, 10);
+    tree.add(5, 5);
+    tree.add(15, 15);
+    tree.add(12, 12);
+    tree.add(18, 18);
+    tree.add(16, 16);
+
+    // Delete a node that will cause rotations and color changes
+    expect(tree.delete(5)).toHaveLength(1);
+
+    // Verify the color and structure after fixup
+    expect(tree.root?.color).toBe('BLACK');
+    expect(tree.root?.left).toBe(tree.NIL);
+    expect(tree.root?.right?.left?.color).toBe('BLACK');
+  });
+
+  it('should handle complex delete fixup scenarios', () => {
+    const tree = new RedBlackTree<number, number>();
+
+    // Build a tree that will require complex fixup
+    tree.add(20, 20);
+    tree.add(10, 10);
+    tree.add(30, 30);
+    tree.add(5, 5);
+    tree.add(15, 15);
+    tree.add(25, 25);
+    tree.add(35, 35);
+    tree.add(2, 2);
+    tree.add(8, 8);
+
+    // This deletion should trigger a complex fixup
+    tree.delete(2);
+    // tree.print(tree.root, { isShowNull: true, isShowRedBlackNIL: true, isShowUndefined: false });
+
+    expect(tree.isLeaf(2)).toBe(false);
+    expect(tree.isLeaf(8)).toBe(true);
+    expect(tree.isLeaf(15)).toBe(true);
+    expect(tree.isLeaf(25)).toBe(true);
+    expect(tree.isLeaf(35)).toBe(true);
+    expect(tree.isLeaf(20)).toBe(false);
+    expect(tree.isLeaf(30)).toBe(false);
+    // Verify tree structure and colors after fixup
+    expect(tree.root?.color).toBe('BLACK');
+    expect(tree.root?.key).toBe(20);
+    expect(tree.root?.left?.color).toBe('RED');
+    expect(tree.root?.left?.key).toBe(10);
+    expect(tree.root?.right?.color).toBe('BLACK');
+    expect(tree.root?.right?.key).toBe(30);
+    expect(tree.root?.left?.left?.color).toBe('BLACK');
+    expect(tree.root?.left?.left?.key).toBe(5);
+    expect(tree.root?.left?.right?.color).toBe('BLACK');
+    expect(tree.root?.left?.right?.key).toBe(15);
+    expect(tree.leaves(node => (node === null ? '' : `${node.key} ${node.color}`), tree.root, 'RECURSIVE')).toEqual([
+      '8 RED',
+      '15 BLACK',
+      '25 RED',
+      '35 RED'
+    ]);
+    expect(tree.listLevels(node => (node === tree.NIL ? 'NIL' : `${node.key} ${node.color}`))).toEqual([
+      ['20 BLACK'],
+      ['10 RED', '30 BLACK'],
+      ['5 BLACK', '15 BLACK', '25 RED', '35 RED'],
+      ['NIL', '8 RED', 'NIL', 'NIL', 'NIL', 'NIL', 'NIL', 'NIL'],
+      ['NIL', 'NIL']
+    ]);
+  });
+});

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

@@ -142,10 +142,10 @@ describe('TreeMultiMap operations test1', () => {
     const nodesByCount2 = tmm.getNodes(2, node => node.count);
     expect(nodesByCount2.length).toBe(2);
     const leftMost = tmm.getLeftMost();
-    expect(leftMost?.key).toBe(1);
+    expect(leftMost).toBe(1);
 
     const node15 = tmm.getNode(15);
-    const minNodeBySpecificNode = node15 && tmm.getLeftMost(node15);
+    const minNodeBySpecificNode = node15 && tmm.getLeftMost(node => node, node15);
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
@@ -400,10 +400,10 @@ describe('TreeMultiMap operations test recursively1', () => {
     const nodesByCount2 = tmm.getNodes(2, node => node.count);
     expect(nodesByCount2.length).toBe(2);
     const leftMost = tmm.getLeftMost();
-    expect(leftMost?.key).toBe(1);
+    expect(leftMost).toBe(1);
 
     const node15 = tmm.getNode(15);
-    const minNodeBySpecificNode = node15 && tmm.getLeftMost(node15);
+    const minNodeBySpecificNode = node15 && tmm.getLeftMost(node => node, node15);
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
@@ -755,14 +755,14 @@ describe('TreeMultiMap iterative methods test', () => {
     treeMM.add([3, 'c'], undefined, 1);
   });
 
-  test('The node obtained by get Node should match the node type', () => {
+  it('The node obtained by get Node should match the node type', () => {
     const node3 = treeMM.getNode(3);
     expect(node3).toBeInstanceOf(BinaryTreeNode);
     expect(node3).toBeInstanceOf(BSTNode);
     expect(node3).toBeInstanceOf(RedBlackTreeNode);
   });
 
-  test('forEach should iterate over all elements', () => {
+  it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
     treeMM.forEach((value, key) => {
       mockCallback(value, key);
@@ -774,7 +774,7 @@ describe('TreeMultiMap iterative methods test', () => {
     expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
   });
 
-  test('filter should return a new tree with filtered elements', () => {
+  it('filter should return a new tree with filtered elements', () => {
     const filteredTree = treeMM.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
@@ -783,7 +783,7 @@ describe('TreeMultiMap iterative methods test', () => {
     ]);
   });
 
-  test('map should return a new tree with modified elements', () => {
+  it('map should return a new tree with modified elements', () => {
     const mappedTree = treeMM.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([
@@ -793,12 +793,12 @@ describe('TreeMultiMap iterative methods test', () => {
     ]);
   });
 
-  test('reduce should accumulate values', () => {
+  it('reduce should accumulate values', () => {
     const sum = treeMM.reduce((acc, value, key) => acc + key, 0);
     expect(sum).toBe(6);
   });
 
-  test('[Symbol.iterator] should provide an iterator', () => {
+  it('[Symbol.iterator] should provide an iterator', () => {
     const entries = [];
     for (const entry of treeMM) {
       entries.push(entry);
@@ -812,7 +812,7 @@ describe('TreeMultiMap iterative methods test', () => {
     ]);
   });
 
-  test('should clone work well', () => {
+  it('should clone work well', () => {
     expect(treeMM.count).toBe(21);
     expect(treeMM.getComputedCount()).toBe(21);
     const cloned = treeMM.clone();
@@ -820,13 +820,18 @@ describe('TreeMultiMap iterative methods test', () => {
     expect(cloned.root?.right?.value).toBe('c');
   });
 
-  test('should keys', () => {
+  it('should keys', () => {
     const keys = treeMM.keys();
     expect([...keys]).toEqual([1, 2, 3]);
   });
 
-  test('should values', () => {
+  it('should values', () => {
     const values = treeMM.values();
     expect([...values]).toEqual(['a', 'b', 'c']);
   });
+
+  it('should leaves', () => {
+    const leaves = treeMM.leaves();
+    expect(leaves).toEqual([1, 3]);
+  });
 });