data-structure-typed 2.4.1 → 2.4.3

package/test/unit/data-structures/binary-tree/data/cost-of-living-by-country.ts

@@ -1,259 +0,0 @@
-export type CostOfLiving = {
-  rank: number;
-  country: string;
-  'Meal, Inexpensive Restaurant': number;
-  'Domestic Beer (0.5 liter draught)': number;
-  'Water (0.33 liter bottle)': number;
-  'Milk (regular), (1 liter)': number;
-  'Loaf of Fresh White Bread (500g)': number;
-  'Eggs (regular) (12)': number;
-  'Local Cheese (1kg)': number;
-  'Water (1.5 liter bottle)': number;
-  'One-way Ticket (Local Transport)': number;
-  'Gasoline (1 liter)': number;
-  'Apartment (3 bedrooms) in City Centre': number;
-  'Basic (Electricity, Heating, Cooling, Water, Garbage) for 85m2 Apartment': number;
-  'Internet (60 Mbps or More, Unlimited Data, Cable/ADSL)': number;
-  'Mobile Phone Monthly Plan with Calls and 10GB+ Data': number;
-  'Cinema, International Release, 1 Seat': number;
-  '1 Pair of Jeans (Levis 501 Or Similar)': number;
-  'Price per Square Meter to Buy Apartment in City Centre': number;
-  'Average Monthly Net Salary (After Tax)': number;
-  'Mortgage Interest Rate in Percentages (%), Yearly, for 20 Years Fixed-Rate': number;
-  'Taxi 1km (Normal Tariff)': number;
-  'Oranges (1kg)': number;
-  'Potato (1kg)': number;
-  'Lettuce (1 head)': number;
-  'Rice (white), (1kg)': number;
-  'Onion (1kg)': number;
-  'Beef Round (1kg) (or Equivalent Back Leg Red Meat)': number;
-  'Toyota Corolla Sedan 1.6l 97kW Comfort (Or Equivalent New Car)': number;
-  'Preschool (or Kindergarten), Full Day, Private, Monthly for 1 Child': number;
-};
-
-export const costOfLiving: CostOfLiving[] = [
-  {
-    rank: 1,
-    country: 'Switzerland',
-    'Meal, Inexpensive Restaurant': 27.98,
-    'Domestic Beer (0.5 liter draught)': 7.83,
-    'Water (0.33 liter bottle)': 4.49,
-    'Milk (regular), (1 liter)': 1.95,
-    'Loaf of Fresh White Bread (500g)': 3.63,
-    'Eggs (regular) (12)': 6.83,
-    'Local Cheese (1kg)': 26.02,
-    'Water (1.5 liter bottle)': 1.13,
-    'One-way Ticket (Local Transport)': 3.92,
-    'Gasoline (1 liter)': 2.06,
-    'Apartment (3 bedrooms) in City Centre': 3359.12,
-    'Basic (Electricity, Heating, Cooling, Water, Garbage) for 85m2 Apartment': 243.82,
-    'Internet (60 Mbps or More, Unlimited Data, Cable/ADSL)': 54.3,
-    'Mobile Phone Monthly Plan with Calls and 10GB+ Data': 51.26,
-    'Cinema, International Release, 1 Seat': 22.38,
-    '1 Pair of Jeans (Levis 501 Or Similar)': 120.18,
-    'Price per Square Meter to Buy Apartment in City Centre': 16439.97,
-    'Average Monthly Net Salary (After Tax)': 6628.35,
-    'Mortgage Interest Rate in Percentages (%), Yearly, for 20 Years Fixed-Rate': 2.49,
-    'Taxi 1km (Normal Tariff)': 4.36,
-    'Oranges (1kg)': 2.93,
-    'Potato (1kg)': 2.48,
-    'Lettuce (1 head)': 2.35,
-    'Rice (white), (1kg)': 3.98,
-    'Onion (1kg)': 2.29,
-    'Beef Round (1kg) (or Equivalent Back Leg Red Meat)': 45.89,
-    'Toyota Corolla Sedan 1.6l 97kW Comfort (Or Equivalent New Car)': 37549.18,
-    'Preschool (or Kindergarten), Full Day, Private, Monthly for 1 Child': 2832.82
-  },
-  {
-    rank: 23,
-    country: 'New Zealand',
-    'Meal, Inexpensive Restaurant': 14.58,
-    'Domestic Beer (0.5 liter draught)': 6.42,
-    'Water (0.33 liter bottle)': 2.01,
-    'Milk (regular), (1 liter)': 1.76,
-    'Loaf of Fresh White Bread (500g)': 1.87,
-    'Eggs (regular) (12)': 6.32,
-    'Local Cheese (1kg)': 8.02,
-    'Water (1.5 liter bottle)': 1.16,
-    'One-way Ticket (Local Transport)': 2.33,
-    'Gasoline (1 liter)': 1.63,
-    'Apartment (3 bedrooms) in City Centre': 1758.7,
-    'Basic (Electricity, Heating, Cooling, Water, Garbage) for 85m2 Apartment': 135.28,
-    'Internet (60 Mbps or More, Unlimited Data, Cable/ADSL)': 50.44,
-    'Mobile Phone Monthly Plan with Calls and 10GB+ Data': 34.27,
-    'Cinema, International Release, 1 Seat': 11.67,
-    '1 Pair of Jeans (Levis 501 Or Similar)': 67.67,
-    'Price per Square Meter to Buy Apartment in City Centre': 5371.0,
-    'Average Monthly Net Salary (After Tax)': 2920.79,
-    'Mortgage Interest Rate in Percentages (%), Yearly, for 20 Years Fixed-Rate': 6.84,
-    'Taxi 1km (Normal Tariff)': 2.01,
-    'Oranges (1kg)': 2.94,
-    'Potato (1kg)': 2.07,
-    'Lettuce (1 head)': 2.35,
-    'Rice (white), (1kg)': 1.82,
-    'Onion (1kg)': 1.77,
-    'Beef Round (1kg) (or Equivalent Back Leg Red Meat)': 12.58,
-    'Toyota Corolla Sedan 1.6l 97kW Comfort (Or Equivalent New Car)': 20980.7,
-    'Preschool (or Kindergarten), Full Day, Private, Monthly for 1 Child': 752.33
-  },
-  {
-    rank: 41,
-    country: 'Mexico',
-    'Meal, Inexpensive Restaurant': 9.79,
-    'Domestic Beer (0.5 liter draught)': 2.2,
-    'Water (0.33 liter bottle)': 0.83,
-    'Milk (regular), (1 liter)': 1.35,
-    'Loaf of Fresh White Bread (500g)': 2.36,
-    'Eggs (regular) (12)': 2.16,
-    'Local Cheese (1kg)': 7.87,
-    'Water (1.5 liter bottle)': 0.91,
-    'One-way Ticket (Local Transport)': 0.54,
-    'Gasoline (1 liter)': 1.18,
-    'Apartment (3 bedrooms) in City Centre': 1148.12,
-    'Basic (Electricity, Heating, Cooling, Water, Garbage) for 85m2 Apartment': 59.55,
-    'Internet (60 Mbps or More, Unlimited Data, Cable/ADSL)': 25.94,
-    'Mobile Phone Monthly Plan with Calls and 10GB+ Data': 21.52,
-    'Cinema, International Release, 1 Seat': 4.41,
-    '1 Pair of Jeans (Levis 501 Or Similar)': 49.23,
-    'Price per Square Meter to Buy Apartment in City Centre': 1781.03,
-    'Average Monthly Net Salary (After Tax)': 660.35,
-    'Mortgage Interest Rate in Percentages (%), Yearly, for 20 Years Fixed-Rate': 11.43,
-    'Taxi 1km (Normal Tariff)': 1.91,
-    'Oranges (1kg)': 1.61,
-    'Potato (1kg)': 1.81,
-    'Lettuce (1 head)': 1.17,
-    'Rice (white), (1kg)': 1.58,
-    'Onion (1kg)': 1.66,
-    'Beef Round (1kg) (or Equivalent Back Leg Red Meat)': 9.79,
-    'Toyota Corolla Sedan 1.6l 97kW Comfort (Or Equivalent New Car)': 21077.68,
-    'Preschool (or Kindergarten), Full Day, Private, Monthly for 1 Child': 224.39
-  },
-  {
-    rank: 52,
-    country: 'South Africa',
-    'Meal, Inexpensive Restaurant': 8.28,
-    'Domestic Beer (0.5 liter draught)': 2.21,
-    'Water (0.33 liter bottle)': 0.73,
-    'Milk (regular), (1 liter)': 1.07,
-    'Loaf of Fresh White Bread (500g)': 0.97,
-    'Eggs (regular) (12)': 2.26,
-    'Local Cheese (1kg)': 7.35,
-    'Water (1.5 liter bottle)': 0.92,
-    'One-way Ticket (Local Transport)': 1.66,
-    'Gasoline (1 liter)': 1.29,
-    'Apartment (3 bedrooms) in City Centre': 892.16,
-    'Basic (Electricity, Heating, Cooling, Water, Garbage) for 85m2 Apartment': 104.63,
-    'Internet (60 Mbps or More, Unlimited Data, Cable/ADSL)': 41.21,
-    'Mobile Phone Monthly Plan with Calls and 10GB+ Data': 31.79,
-    'Cinema, International Release, 1 Seat': 6.62,
-    '1 Pair of Jeans (Levis 501 Or Similar)': 47.28,
-    'Price per Square Meter to Buy Apartment in City Centre': 1031.57,
-    'Average Monthly Net Salary (After Tax)': 1383.11,
-    'Mortgage Interest Rate in Percentages (%), Yearly, for 20 Years Fixed-Rate': 11.58,
-    'Taxi 1km (Normal Tariff)': 1.1,
-    'Oranges (1kg)': 1.4,
-    'Potato (1kg)': 1.21,
-    'Lettuce (1 head)': 1.02,
-    'Rice (white), (1kg)': 1.53,
-    'Onion (1kg)': 1.34,
-    'Beef Round (1kg) (or Equivalent Back Leg Red Meat)': 6.55,
-    'Toyota Corolla Sedan 1.6l 97kW Comfort (Or Equivalent New Car)': 23105.93,
-    'Preschool (or Kindergarten), Full Day, Private, Monthly for 1 Child': 193.32
-  },
-  {
-    rank: 65,
-    country: 'Japan',
-    'Meal, Inexpensive Restaurant': 6.46,
-    'Domestic Beer (0.5 liter draught)': 3.23,
-    'Water (0.33 liter bottle)': 0.73,
-    'Milk (regular), (1 liter)': 1.4,
-    'Loaf of Fresh White Bread (500g)': 1.46,
-    'Eggs (regular) (12)': 2.08,
-    'Local Cheese (1kg)': 11.12,
-    'Water (1.5 liter bottle)': 0.85,
-    'One-way Ticket (Local Transport)': 1.42,
-    'Gasoline (1 liter)': 1.11,
-    'Apartment (3 bedrooms) in City Centre': 1248.4,
-    'Basic (Electricity, Heating, Cooling, Water, Garbage) for 85m2 Apartment': 166.85,
-    'Internet (60 Mbps or More, Unlimited Data, Cable/ADSL)': 32.64,
-    'Mobile Phone Monthly Plan with Calls and 10GB+ Data': 25.29,
-    'Cinema, International Release, 1 Seat': 12.28,
-    '1 Pair of Jeans (Levis 501 Or Similar)': 43.21,
-    'Price per Square Meter to Buy Apartment in City Centre': 6324.16,
-    'Average Monthly Net Salary (After Tax)': 2069.74,
-    'Mortgage Interest Rate in Percentages (%), Yearly, for 20 Years Fixed-Rate': 1.83,
-    'Taxi 1km (Normal Tariff)': 2.91,
-    'Oranges (1kg)': 4.35,
-    'Potato (1kg)': 2.63,
-    'Lettuce (1 head)': 1.26,
-    'Rice (white), (1kg)': 3.72,
-    'Onion (1kg)': 2.39,
-    'Beef Round (1kg) (or Equivalent Back Leg Red Meat)': 16.87,
-    'Toyota Corolla Sedan 1.6l 97kW Comfort (Or Equivalent New Car)': 16534.56,
-    'Preschool (or Kindergarten), Full Day, Private, Monthly for 1 Child': 353.95
-  },
-  {
-    rank: 72,
-    country: 'Brazil',
-    'Meal, Inexpensive Restaurant': 5.17,
-    'Domestic Beer (0.5 liter draught)': 1.72,
-    'Water (0.33 liter bottle)': 0.65,
-    'Milk (regular), (1 liter)': 0.93,
-    'Loaf of Fresh White Bread (500g)': 1.43,
-    'Eggs (regular) (12)': 1.92,
-    'Local Cheese (1kg)': 8.08,
-    'Water (1.5 liter bottle)': 0.63,
-    'One-way Ticket (Local Transport)': 0.86,
-    'Gasoline (1 liter)': 0.98,
-    'Apartment (3 bedrooms) in City Centre': 622.9,
-    'Basic (Electricity, Heating, Cooling, Water, Garbage) for 85m2 Apartment': 65.01,
-    'Internet (60 Mbps or More, Unlimited Data, Cable/ADSL)': 18.39,
-    'Mobile Phone Monthly Plan with Calls and 10GB+ Data': 13.92,
-    'Cinema, International Release, 1 Seat': 6.03,
-    '1 Pair of Jeans (Levis 501 Or Similar)': 46.84,
-    'Price per Square Meter to Buy Apartment in City Centre': 1513.42,
-    'Average Monthly Net Salary (After Tax)': 417.56,
-    'Mortgage Interest Rate in Percentages (%), Yearly, for 20 Years Fixed-Rate': 10.98,
-    'Taxi 1km (Normal Tariff)': 0.83,
-    'Oranges (1kg)': 1.04,
-    'Potato (1kg)': 1.11,
-    'Lettuce (1 head)': 0.68,
-    'Rice (white), (1kg)': 1.11,
-    'Onion (1kg)': 1.06,
-    'Beef Round (1kg) (or Equivalent Back Leg Red Meat)': 6.93,
-    'Toyota Corolla Sedan 1.6l 97kW Comfort (Or Equivalent New Car)': 26186.46,
-    'Preschool (or Kindergarten), Full Day, Private, Monthly for 1 Child': 279.87
-  },
-  {
-    rank: 74,
-    country: 'Taiwan',
-    'Meal, Inexpensive Restaurant': 4.6,
-    'Domestic Beer (0.5 liter draught)': 1.84,
-    'Water (0.33 liter bottle)': 0.65,
-    'Milk (regular), (1 liter)': 2.99,
-    'Loaf of Fresh White Bread (500g)': 1.84,
-    'Eggs (regular) (12)': 2.75,
-    'Local Cheese (1kg)': 15.19,
-    'Water (1.5 liter bottle)': 1.14,
-    'One-way Ticket (Local Transport)': 0.77,
-    'Gasoline (1 liter)': 0.95,
-    'Apartment (3 bedrooms) in City Centre': 1124.03,
-    'Basic (Electricity, Heating, Cooling, Water, Garbage) for 85m2 Apartment': 78.3,
-    'Internet (60 Mbps or More, Unlimited Data, Cable/ADSL)': 21.65,
-    'Mobile Phone Monthly Plan with Calls and 10GB+ Data': 22.18,
-    'Cinema, International Release, 1 Seat': 9.51,
-    '1 Pair of Jeans (Levis 501 Or Similar)': 63.34,
-    'Price per Square Meter to Buy Apartment in City Centre': 8859.94,
-    'Average Monthly Net Salary (After Tax)': 1654.66,
-    'Mortgage Interest Rate in Percentages (%), Yearly, for 20 Years Fixed-Rate': 2.0,
-    'Taxi 1km (Normal Tariff)': 0.77,
-    'Oranges (1kg)': 2.64,
-    'Potato (1kg)': 2.61,
-    'Lettuce (1 head)': 1.82,
-    'Rice (white), (1kg)': 2.97,
-    'Onion (1kg)': 2.15,
-    'Beef Round (1kg) (or Equivalent Back Leg Red Meat)': 18.14,
-    'Toyota Corolla Sedan 1.6l 97kW Comfort (Or Equivalent New Car)': 24143.1,
-    'Preschool (or Kindergarten), Full Day, Private, Monthly for 1 Child': 508.49
-  }
-];

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

@@ -1,219 +0,0 @@
-import { AVLTree, BST, RedBlackTree, TreeMultiMap } from '../../../../src';
-
-describe('Overall BinaryTree Test', () => {
-  it('should perform various operations on BinaryTree', () => {
-    const bst = new BST<number>();
-    bst.set(11);
-    bst.set(3);
-    bst.setMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
-    expect(bst.size).toBe(16); // true
-    bst.has(6); // true
-    expect(bst.has(6)).toBe(true); // true
-    expect(bst.getHeight(6)).toBe(2); // true
-    expect(bst.getHeight()).toBe(5); // true
-    expect(bst.getDepth(6)).toBe(3); // true
-    const leftMost = bst.getLeftMost();
-    expect(leftMost).toBe(1);
-    bst.delete(6);
-    bst.getNode(6); // undefined
-    expect(bst.getNode(6)).toBe(undefined);
-    bst.isAVLBalanced(); // true or false
-    expect(bst.isAVLBalanced()).toBe(true);
-    const bfsIDs: number[] = [];
-    bst.bfs(node => bfsIDs.push(node.key));
-    expect(bfsIDs[0]).toBe(11);
-
-    const objBST = new BST<number, { key: number; keyA: number }>();
-    objBST.set([11, { key: 11, keyA: 11 }]);
-    objBST.set([3, { key: 3, keyA: 3 }]);
-
-    objBST.setMany([
-      [15, { key: 15, keyA: 15 }],
-      [1, { key: 1, keyA: 1 }],
-      [8, { key: 8, keyA: 8 }],
-      [13, { key: 13, keyA: 13 }],
-      [16, { key: 16, keyA: 16 }],
-      [2, { key: 2, keyA: 2 }],
-      [6, { key: 6, keyA: 6 }],
-      [9, { key: 9, keyA: 9 }],
-      [12, { key: 12, keyA: 12 }],
-      [14, { key: 14, keyA: 14 }],
-      [4, { key: 4, keyA: 4 }],
-      [7, { key: 7, keyA: 7 }],
-      [10, { key: 10, keyA: 10 }],
-      [5, { key: 5, keyA: 5 }]
-    ]);
-
-    objBST.delete(11);
-
-    const avlTree = new AVLTree();
-    avlTree.setMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
-    avlTree.isAVLBalanced(); // true
-    expect(avlTree.isAVLBalanced()).toBe(true); // true
-    avlTree.delete(10);
-    avlTree.isAVLBalanced(); // true
-    expect(avlTree.isAVLBalanced()).toBe(true); // true
-  });
-
-  it('Should clone a BST works fine', () => {
-    const bst = new BST<number>([3, 6, 7, 1, 9], {
-      iterationType: 'RECURSIVE',
-      comparator: (a, b) => b - a
-    });
-    expect(bst.size).toBe(5);
-    expect(bst.root?.key).toBe(6);
-    expect(bst.root?.left?.key).toBe(9);
-    expect(bst.root?.left?.right?.key).toBe(7);
-    expect(bst.root?.right?.key).toBe(3);
-    expect(bst.root?.right?.right?.key).toBe(1);
-    expect(bst.getNode(9)?.right?.key).toBe(7);
-    expect(bst.getHeight()).toBe(2);
-    expect(bst.has(9)).toBe(true);
-    expect(bst.has(7)).toBe(true);
-    expect(bst.delete(7)[0].deleted?.key).toBe(7);
-    expect(bst.has(7)).toBe(false);
-    expect(bst.size).toBe(4);
-    expect(bst.root?.key).toBe(6);
-    expect(bst.root?.left?.key).toBe(9);
-    expect(bst.root?.right?.key).toBe(3);
-    expect(bst.root?.right?.right?.key).toBe(1);
-    expect(bst.getNode(6)?.left?.key).toBe(9);
-    expect(bst.getHeight()).toBe(2);
-    expect(bst.has(9)).toBe(true);
-    expect(bst.has(7)).toBe(false);
-    expect(bst.bfs()).toEqual([6, 9, 3, 1]);
-
-    const clonedBST = bst.clone();
-
-    expect(clonedBST.size).toBe(4);
-    expect(clonedBST.root?.key).toBe(6);
-    expect(clonedBST.root?.left?.key).toBe(9);
-    expect(clonedBST.root?.right?.key).toBe(3);
-    expect(clonedBST.root?.right?.right?.key).toBe(1);
-    expect(clonedBST.getNode(6)?.left?.key).toBe(9);
-    expect(clonedBST.getHeight()).toBe(2);
-    expect(clonedBST.has(9)).toBe(true);
-    expect(clonedBST.has(7)).toBe(false);
-    expect(clonedBST.bfs()).toEqual([6, 9, 3, 1]);
-  });
-
-  it('Should clone a AVLTree works fine', () => {
-    const avl = new AVLTree<number>([3, 6, 7, 1, 9], {
-      iterationType: 'RECURSIVE',
-      comparator: (a, b) => b - a
-    });
-    expect(avl.size).toBe(5);
-    avl.set(2);
-    avl.set(5);
-    avl.set(4);
-    expect(avl.root?.key).toBe(3);
-    expect(avl.root?.left?.key).toBe(7);
-    expect(avl.root?.left?.left?.key).toBe(9);
-    expect(avl.root?.right?.key).toBe(1);
-    expect(avl.root?.right?.left?.key).toBe(2);
-    expect(avl.getNode(7)?.left?.key).toBe(9);
-    expect(avl.getHeight()).toBe(3);
-    expect(avl.has(9)).toBe(true);
-    expect(avl.has(7)).toBe(true);
-    expect(avl.delete(7)[0].deleted?.key).toBe(7);
-    expect(avl.has(7)).toBe(false);
-    expect(avl.size).toBe(7);
-    expect(avl.root?.key).toBe(3);
-    expect(avl.root?.left?.key).toBe(5);
-    expect(avl.root?.right?.key).toBe(1);
-    expect(avl.root?.right?.left?.key).toBe(2);
-    expect(avl.getNode(6)?.left?.key).toBe(undefined);
-    expect(avl.getHeight()).toBe(3);
-    expect(avl.has(9)).toBe(true);
-    expect(avl.has(7)).toBe(false);
-    expect(avl.bfs()).toEqual([3, 5, 1, 9, 4, 2, 6]);
-    const clonedAVL = avl.clone();
-    expect(clonedAVL.size).toBe(7);
-    expect(clonedAVL.root?.key).toBe(3);
-    expect(clonedAVL.root?.left?.key).toBe(5);
-    expect(clonedAVL.root?.right?.key).toBe(1);
-    expect(clonedAVL.root?.right?.left?.key).toBe(2);
-    expect(clonedAVL.getNode(6)?.left?.key).toBe(undefined);
-    expect(clonedAVL.getHeight()).toBe(3);
-    expect(clonedAVL.has(9)).toBe(true);
-    expect(clonedAVL.has(7)).toBe(false);
-    expect(clonedAVL.bfs()).toEqual([3, 5, 1, 9, 4, 2, 6]);
-  });
-
-  // TreeMultiMap uses composition, not inheritance - tests use public API only
-  it('Should clone a TreeMultiMap works fine', () => {
-    const tmm = new TreeMultiMap<number, string>();
-    tmm.set(3, 'a');
-    tmm.set(6, 'b');
-    tmm.set(7, 'c');
-    tmm.set(1, 'd');
-    tmm.set(9, 'e');
-    expect(tmm.size).toBe(5);
-    tmm.set(2, 'f');
-    tmm.set(2, 'g'); // duplicate key, adds to bucket
-    tmm.set(2, 'h'); // duplicate key, adds to bucket
-    tmm.set(5, 'i');
-    tmm.set(4, 'j');
-    expect(tmm.size).toBe(8); // 8 unique keys
-    expect(tmm.count(2)).toBe(3); // 3 values for key 2
-    expect(tmm.has(9)).toBe(true);
-    expect(tmm.has(7)).toBe(true);
-    expect(tmm.delete(7)).toBe(true);
-    expect(tmm.has(7)).toBe(false);
-    expect(tmm.size).toBe(7);
-    expect(tmm.has(9)).toBe(true);
-    expect(tmm.has(7)).toBe(false);
-    
-    const clonedTMM = tmm.clone();
-    expect(clonedTMM.size).toBe(7);
-    expect(clonedTMM.has(9)).toBe(true);
-    expect(clonedTMM.has(7)).toBe(false);
-    expect(clonedTMM.count(2)).toBe(3);
-    expect(clonedTMM.get(2)).toEqual(['f', 'g', 'h']);
-  });
-
-  it('Should clone a RedBlackTree works fine', () => {
-    const rbTree = new RedBlackTree<number>([3, 6, 7, 1, 9], {
-      iterationType: 'RECURSIVE'
-    });
-    expect(rbTree.size).toBe(5);
-    rbTree.set(2);
-    rbTree.set(2);
-    rbTree.set(2);
-    rbTree.set(5);
-    rbTree.set(4);
-    expect(rbTree.root?.key).toBe(3);
-    expect(rbTree.root?.left?.key).toBe(1);
-    expect(rbTree.root?.left?.left?.key).toBe(NaN);
-    expect(rbTree.root?.right?.key).toBe(7);
-    expect(rbTree.root?.right?.left?.key).toBe(5);
-    expect(rbTree.getNode(7)?.left?.key).toBe(5);
-    expect(rbTree.getHeight()).toBe(3);
-    expect(rbTree.has(9)).toBe(true);
-    expect(rbTree.has(7)).toBe(true);
-    expect(rbTree.delete(7)?.[0]?.deleted?.key).toBe(7);
-    expect(rbTree.has(7)).toBe(false);
-    expect(rbTree.size).toBe(7);
-    expect(rbTree.root?.key).toBe(3);
-    expect(rbTree.root?.left?.key).toBe(1);
-    expect(rbTree.root?.right?.key).toBe(9);
-    expect(rbTree.root?.right?.left?.key).toBe(5);
-    expect(rbTree.getNode(6)?.left?.key).toBe(NaN);
-    expect(rbTree.getHeight()).toBe(3);
-    expect(rbTree.has(9)).toBe(true);
-    expect(rbTree.has(7)).toBe(false);
-    // expect(rbTree.bfs()).toEqual([3, 1, 5, 2, 4, 9, 6]);
-    expect(rbTree.bfs()).toEqual([3, 1, 9, 2, 5, 4, 6]);
-    const clonedRbTree = rbTree.clone();
-    expect(clonedRbTree.size).toBe(7);
-    expect(clonedRbTree.root?.key).toBe(3);
-    expect(clonedRbTree.root?.left?.key).toBe(1);
-    expect(clonedRbTree.root?.right?.key).toBe(5);
-    expect(clonedRbTree.root?.right?.left?.key).toBe(4);
-    expect(clonedRbTree.getNode(6)?.left?.key).toBe(NaN);
-    expect(clonedRbTree.getHeight()).toBe(3);
-    expect(clonedRbTree.has(9)).toBe(true);
-    expect(clonedRbTree.has(7)).toBe(false);
-    expect(clonedRbTree.bfs()).toEqual([3, 1, 5, 2, 4, 9, 6]);
-  });
-});

package/test/unit/data-structures/binary-tree/red-black-tree.boundary-corruption-repair.coverage.test.ts

@@ -1,66 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree boundary corruption repair coverage', () => {
-  it('min-attach: when header._right is corrupted to NIL, branch mirrors max cache to new min', () => {
-    let tree: RedBlackTree<number, number> = new RedBlackTree<number>();
-    let active = false;
-    let flipped = false;
-    const comparator = (a: number, b: number) => {
-      // Flip once during the boundary pre-check, before the attach happens.
-      if (active && !flipped && tree) {
-        flipped = true;
-        (tree as any)._header._right = tree.NIL;
-      }
-      return a - b;
-    };
-
-    tree = new RedBlackTree<number, number>([], { isMapMode: false, comparator });
-    tree.set(10, 10);
-    tree.set(5, 5);
-    tree.set(15, 15);
-
-    // Boundary insert smaller than current min.
-    active = true;
-    tree.set(1, 1);
-    active = false;
-
-    // Repair branch should have mirrored max cache when header._right was NIL.
-    expect((tree as any)._header._right.key).toBe(1);
-
-    // Restore correct max cache so subsequent tests/users aren't affected.
-    const root = (tree as any)._root;
-    (tree as any)._setMaxCache(tree.isRealNode(root) ? tree.getRightMost((n: any) => n, root) : undefined);
-    expect((tree as any)._header._right.key).toBe(15);
-  });
-
-  it('max-attach: when header._left is corrupted to NIL, branch initializes min cache during max attach', () => {
-    let tree: RedBlackTree<number, number> = new RedBlackTree<number>();;
-    let active = false;
-    let flipped = false;
-    const comparator = (a: number, b: number) => {
-      if (active && !flipped && tree) {
-        flipped = true;
-        (tree as any)._header._left = tree.NIL;
-      }
-      return a - b;
-    };
-
-    tree = new RedBlackTree<number, number>([], { isMapMode: false, comparator });
-    tree.set(10, 10);
-    tree.set(5, 5);
-    tree.set(15, 15);
-
-    // Boundary insert larger than current max.
-    active = true;
-    tree.set(100, 100);
-    active = false;
-
-    // Observe the branch effect before repairing (min cache got initialized).
-    expect((tree as any)._header._left.key).toBe(100);
-
-    // Restore correct min cache.
-    const root = (tree as any)._root;
-    (tree as any)._setMinCache(tree.isRealNode(root) ? tree.getLeftMost((n: any) => n, root) : undefined);
-    expect((tree as any)._header._left.key).toBe(5);
-  });
-});

package/test/unit/data-structures/binary-tree/red-black-tree.boundary-max-update.coverage.test.ts

@@ -1,18 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree boundary max update coverage', () => {
-  it('mapMode: updating existing max key with defined value hits store.set branch in cMax===0 fast-path', () => {
-    const t = new RedBlackTree<number, string>(); // mapMode default
-
-    t.set(10, 'mid');
-    t.set(5, 'min');
-    t.set(15, 'max');
-
-    // Update existing max key with a defined value.
-    t.set(15, 'max2');
-
-    expect(t.get(15)).toBe('max2');
-    // Assert store updated (fast-path uses store.set).
-    expect((t as any)._store.get(15)?.value).toBe('max2');
-  });
-});

package/test/unit/data-structures/binary-tree/red-black-tree.boundary-null.coverage.test.ts

@@ -1,53 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree boundary attach null/undefined coverage', () => {
-  it('min boundary attach works when min.left is null', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    t.set(10, 10);
-    t.set(5, 5);
-
-    const minNode = t.getNode(5)!;
-    // Force the boundary condition to treat left as empty via null.
-    (minNode as any)._left = null;
-
-    t.set(1, 1);
-
-    expect(t.getNode(1)?.parent?.key).toBe(5);
-    expect((t as any)._header._left.key).toBe(1);
-  });
-
-  it('min boundary attach works when min.left is undefined', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    t.set(10, 10);
-    t.set(5, 5);
-
-    const minNode = t.getNode(5)!;
-    // Force the boundary condition to treat left as empty via undefined.
-    (minNode as any)._left = undefined;
-
-    t.set(1, 1);
-
-    expect(t.getNode(1)?.parent?.key).toBe(5);
-    expect((t as any)._header._left.key).toBe(1);
-  });
-
-  it('max boundary attach works when max.right is null/undefined', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    t.set(10, 10);
-    t.set(15, 15);
-
-    const maxNode = t.getNode(15)!;
-    // First cover null.
-    (maxNode as any)._right = null;
-    t.set(20, 20);
-    expect(t.getNode(20)?.parent?.key).toBe(15);
-    expect((t as any)._header._right.key).toBe(20);
-
-    // Now cover undefined on the new max.
-    const maxNode2 = t.getNode(20)!;
-    (maxNode2 as any)._right = undefined;
-    t.set(25, 25);
-    expect(t.getNode(25)?.parent?.key).toBe(20);
-    expect((t as any)._header._right.key).toBe(25);
-  });
-});

package/test/unit/data-structures/binary-tree/red-black-tree.boundary-stale-cache.coverage.test.ts

@@ -1,25 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree boundary attach stale cache coverage', () => {
-  it('boundary max attach repairs stale min cache when header._left === NIL', () => {
-    const t = new RedBlackTree<number, number>([], { isMapMode: false });
-    t.set(10, 10);
-    t.set(5, 5);
-
-    const NIL = (t as any).NIL;
-
-    // Stale min cache: header._left is NIL, but tree is non-empty.
-    (t as any)._header._left = NIL;
-
-    // Insert new maximum; should take boundary max attach path and hit:
-    // if (header._left === NIL) this._setMinCache(newNode)
-    t.set(20, 20);
-
-    expect((t as any)._header._right.key).toBe(20);
-    expect((t as any)._header._left).not.toBe(NIL);
-
-    // Under stale/corrupted cache conditions, the boundary fast path mirrors min to the inserted node.
-    // (In normal operation header._left would not be NIL when the tree is non-empty.)
-    expect((t as any)._header._left.key).toBe(20);
-  });
-});

package/test/unit/data-structures/binary-tree/red-black-tree.boundary-update.coverage.test.ts

@@ -1,23 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree boundary update coverage', () => {
-  it('updating existing min/max via boundary cache fast paths does not change size', () => {
-    const t = new RedBlackTree<number, string>([], { isMapMode: false });
-
-    t.set(10, 'a');
-    t.set(5, 'min');
-    t.set(15, 'max');
-
-    const size0 = t.size;
-
-    // Update existing min key: should hit cMin===0 fast-path.
-    expect(t.set(5, 'min2')).toBe(true);
-    expect(t.size).toBe(size0);
-    expect(t.getNode(5)?.value).toBe('min2');
-
-    // Update existing max key: should hit cMax===0 fast-path.
-    expect(t.set(15, 'max2')).toBe(true);
-    expect(t.size).toBe(size0);
-    expect(t.getNode(15)?.value).toBe('max2');
-  });
-});