data-structure-typed 1.54.3 → 2.0.0

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

@@ -570,3 +570,171 @@ describe('AVLTreeMultiMap iterative methods not map mode', () => {
     expect(cloned.get(cloned.root?.right?.key)).toEqual(['c']);
   });
 });
+
+describe('classic use', () => {
+  // Test suite for TreeMultiMap with player ranking and equipment
+  it('players ranked by score with their equipment', () => {
+    type Equipment = {
+      name: string; // Equipment name
+      quality: 'legendary' | 'epic' | 'rare' | 'common';
+      level: number;
+    };
+
+    type Player = {
+      name: string;
+      score: number;
+      equipments: Equipment[];
+    };
+
+    // Mock player data with their scores and equipment
+    const players: Player[] = [
+      {
+        name: 'DragonSlayer',
+        score: 8750,
+        equipments: [
+          { name: 'AWM', quality: 'legendary', level: 85 },
+          { name: 'Level 3 Helmet', quality: 'epic', level: 80 },
+          { name: 'Extended Quickdraw Mag', quality: 'rare', level: 75 },
+          { name: 'Compensator', quality: 'epic', level: 78 },
+          { name: 'Vertical Grip', quality: 'rare', level: 72 }
+        ]
+      },
+      {
+        name: 'ShadowNinja',
+        score: 7200,
+        equipments: [
+          { name: 'M416', quality: 'epic', level: 75 },
+          { name: 'Ghillie Suit', quality: 'rare', level: 70 },
+          { name: 'Red Dot Sight', quality: 'common', level: 65 },
+          { name: 'Extended QuickDraw Mag', quality: 'rare', level: 68 }
+        ]
+      },
+      {
+        name: 'RuneMaster',
+        score: 9100,
+        equipments: [
+          { name: 'KAR98K', quality: 'legendary', level: 90 },
+          { name: 'Level 3 Vest', quality: 'legendary', level: 85 },
+          { name: 'Holographic Sight', quality: 'epic', level: 82 },
+          { name: 'Suppressor', quality: 'legendary', level: 88 },
+          { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+        ]
+      },
+      {
+        name: 'BattleKing',
+        score: 8500,
+        equipments: [
+          { name: 'AUG', quality: 'epic', level: 82 },
+          { name: 'Red Dot Sight', quality: 'rare', level: 75 },
+          { name: 'Extended Mag', quality: 'common', level: 70 },
+          { name: 'Tactical Stock', quality: 'rare', level: 76 }
+        ]
+      },
+      {
+        name: 'SniperElite',
+        score: 7800,
+        equipments: [
+          { name: 'M24', quality: 'legendary', level: 88 },
+          { name: 'Compensator', quality: 'epic', level: 80 },
+          { name: 'Scope 8x', quality: 'legendary', level: 85 },
+          { name: 'Level 2 Helmet', quality: 'rare', level: 75 }
+        ]
+      },
+      {
+        name: 'RushMaster',
+        score: 7500,
+        equipments: [
+          { name: 'Vector', quality: 'rare', level: 72 },
+          { name: 'Level 2 Helmet', quality: 'common', level: 65 },
+          { name: 'Quickdraw Mag', quality: 'common', level: 60 },
+          { name: 'Laser Sight', quality: 'rare', level: 68 }
+        ]
+      },
+      {
+        name: 'GhostWarrior',
+        score: 8200,
+        equipments: [
+          { name: 'SCAR-L', quality: 'epic', level: 78 },
+          { name: 'Extended Quickdraw Mag', quality: 'rare', level: 70 },
+          { name: 'Holographic Sight', quality: 'epic', level: 75 },
+          { name: 'Suppressor', quality: 'rare', level: 72 },
+          { name: 'Vertical Grip', quality: 'common', level: 65 }
+        ]
+      },
+      {
+        name: 'DeathDealer',
+        score: 7300,
+        equipments: [
+          { name: 'SKS', quality: 'epic', level: 76 },
+          { name: 'Holographic Sight', quality: 'rare', level: 68 },
+          { name: 'Extended Mag', quality: 'common', level: 65 }
+        ]
+      },
+      {
+        name: 'StormRider',
+        score: 8900,
+        equipments: [
+          { name: 'MK14', quality: 'legendary', level: 92 },
+          { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+          { name: 'Scope 8x', quality: 'epic', level: 80 },
+          { name: 'Suppressor', quality: 'legendary', level: 88 },
+          { name: 'Tactical Stock', quality: 'rare', level: 75 }
+        ]
+      },
+      {
+        name: 'CombatLegend',
+        score: 7600,
+        equipments: [
+          { name: 'UMP45', quality: 'rare', level: 74 },
+          { name: 'Level 2 Vest', quality: 'common', level: 67 },
+          { name: 'Red Dot Sight', quality: 'common', level: 62 },
+          { name: 'Extended Mag', quality: 'rare', level: 70 }
+        ]
+      }
+    ];
+
+    // Create a TreeMultiMap for player rankings
+    const playerRankings = new AVLTreeMultiMap<number, Equipment, Player>(players, {
+      toEntryFn: ({ score, equipments }) => [score, equipments],
+      isMapMode: false
+    });
+
+    const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node));
+    expect(topPlayersEquipments).toEqual([
+      [
+        {
+          name: 'MK14',
+          quality: 'legendary',
+          level: 92
+        },
+        { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+        {
+          name: 'Scope 8x',
+          quality: 'epic',
+          level: 80
+        },
+        { name: 'Suppressor', quality: 'legendary', level: 88 },
+        {
+          name: 'Tactical Stock',
+          quality: 'rare',
+          level: 75
+        }
+      ],
+      [
+        { name: 'KAR98K', quality: 'legendary', level: 90 },
+        {
+          name: 'Level 3 Vest',
+          quality: 'legendary',
+          level: 85
+        },
+        { name: 'Holographic Sight', quality: 'epic', level: 82 },
+        {
+          name: 'Suppressor',
+          quality: 'legendary',
+          level: 88
+        },
+        { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+      ]
+    ]);
+  });
+});

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

@@ -1,4 +1,4 @@
-import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode, Range } from '../../../../src';
+import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode } from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -546,6 +546,7 @@ describe('AVLTree iterative methods not map mode', () => {
 describe('classic use', () => {
   // Test case for finding elements in a given range
   it('@example Find elements in a range', () => {
+    // In interval queries, AVL trees, with their strictly balanced structure and lower height, offer better query efficiency, making them ideal for frequent and high-performance interval queries. In contrast, Red-Black trees, with lower update costs, are more suitable for scenarios involving frequent insertions and deletions where the requirements for interval queries are less demanding.
     type Datum = { timestamp: Date; temperature: number };
     // Fixed dataset of CPU temperature readings
     const cpuData: Datum[] = [
@@ -594,18 +595,18 @@ describe('classic use', () => {
       temperature: cpuTemperatureTree.get(node ? node.key : undefined)
     }));
 
-    expect(rangeResults).toEqual( [
-            { minute: 5, temperature: 59.4 },
-            { minute: 6, temperature: 60.1 },
-            { minute: 7, temperature: 61.3 },
-            { minute: 8, temperature: 62 },
-            { minute: 9, temperature: 63.5 },
-            { minute: 10, temperature: 64 },
-            { minute: 11, temperature: 62.8 },
-            { minute: 12, temperature: 61.5 },
-            { minute: 13, temperature: 60.2 },
-            { minute: 14, temperature: 59.8 },
-            { minute: 15, temperature: 58.6 }
-          ]);
+    expect(rangeResults).toEqual([
+      { minute: 5, temperature: 59.4 },
+      { minute: 6, temperature: 60.1 },
+      { minute: 7, temperature: 61.3 },
+      { minute: 8, temperature: 62 },
+      { minute: 9, temperature: 63.5 },
+      { minute: 10, temperature: 64 },
+      { minute: 11, temperature: 62.8 },
+      { minute: 12, temperature: 61.5 },
+      { minute: 13, temperature: 60.2 },
+      { minute: 14, temperature: 59.8 },
+      { minute: 15, temperature: 58.6 }
+    ]);
   });
 });

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

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, Range, RedBlackTree, RedBlackTreeNode } from '../../../../src';
+import { BinaryTreeNode, BSTNode, RedBlackTree, RedBlackTreeNode } from '../../../../src';
 import { getRandomInt, getRandomIntArray, magnitude } from '../../../utils';
 import { OrderedMap } from 'js-sdsl';
 

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

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, Range, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
+import { BinaryTreeNode, BSTNode, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
 import { getRandomInt } from '../../../utils';
 
 import { isDebugTest } from '../../../config';
@@ -837,11 +837,169 @@ describe('real world data', () => {
 });
 
 describe('classic use', () => {
-  // Test case for finding elements in a given range
-  it('@example Find elements in a range', () => {
-    const tmm = new TreeMultiMap<number>([10, 5, 15, 3, 7, 12, 18]);
-    expect(tmm.search(new Range(5, 10))).toEqual([5, 7, 10]);
-    expect(tmm.search(new Range(4, 12))).toEqual([5, 7, 10, 12]);
-    expect(tmm.search(new Range(15, 20))).toEqual([15, 18]);
+  // Test suite for TreeMultiMap with player ranking and equipment
+  it('@example players ranked by score with their equipment', () => {
+    type Equipment = {
+      name: string; // Equipment name
+      quality: 'legendary' | 'epic' | 'rare' | 'common';
+      level: number;
+    };
+
+    type Player = {
+      name: string;
+      score: number;
+      equipments: Equipment[];
+    };
+
+    // Mock player data with their scores and equipment
+    const players: Player[] = [
+      {
+        name: 'DragonSlayer',
+        score: 8750,
+        equipments: [
+          { name: 'AWM', quality: 'legendary', level: 85 },
+          { name: 'Level 3 Helmet', quality: 'epic', level: 80 },
+          { name: 'Extended Quickdraw Mag', quality: 'rare', level: 75 },
+          { name: 'Compensator', quality: 'epic', level: 78 },
+          { name: 'Vertical Grip', quality: 'rare', level: 72 }
+        ]
+      },
+      {
+        name: 'ShadowNinja',
+        score: 7200,
+        equipments: [
+          { name: 'M416', quality: 'epic', level: 75 },
+          { name: 'Ghillie Suit', quality: 'rare', level: 70 },
+          { name: 'Red Dot Sight', quality: 'common', level: 65 },
+          { name: 'Extended QuickDraw Mag', quality: 'rare', level: 68 }
+        ]
+      },
+      {
+        name: 'RuneMaster',
+        score: 9100,
+        equipments: [
+          { name: 'KAR98K', quality: 'legendary', level: 90 },
+          { name: 'Level 3 Vest', quality: 'legendary', level: 85 },
+          { name: 'Holographic Sight', quality: 'epic', level: 82 },
+          { name: 'Suppressor', quality: 'legendary', level: 88 },
+          { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+        ]
+      },
+      {
+        name: 'BattleKing',
+        score: 8500,
+        equipments: [
+          { name: 'AUG', quality: 'epic', level: 82 },
+          { name: 'Red Dot Sight', quality: 'rare', level: 75 },
+          { name: 'Extended Mag', quality: 'common', level: 70 },
+          { name: 'Tactical Stock', quality: 'rare', level: 76 }
+        ]
+      },
+      {
+        name: 'SniperElite',
+        score: 7800,
+        equipments: [
+          { name: 'M24', quality: 'legendary', level: 88 },
+          { name: 'Compensator', quality: 'epic', level: 80 },
+          { name: 'Scope 8x', quality: 'legendary', level: 85 },
+          { name: 'Level 2 Helmet', quality: 'rare', level: 75 }
+        ]
+      },
+      {
+        name: 'RushMaster',
+        score: 7500,
+        equipments: [
+          { name: 'Vector', quality: 'rare', level: 72 },
+          { name: 'Level 2 Helmet', quality: 'common', level: 65 },
+          { name: 'Quickdraw Mag', quality: 'common', level: 60 },
+          { name: 'Laser Sight', quality: 'rare', level: 68 }
+        ]
+      },
+      {
+        name: 'GhostWarrior',
+        score: 8200,
+        equipments: [
+          { name: 'SCAR-L', quality: 'epic', level: 78 },
+          { name: 'Extended Quickdraw Mag', quality: 'rare', level: 70 },
+          { name: 'Holographic Sight', quality: 'epic', level: 75 },
+          { name: 'Suppressor', quality: 'rare', level: 72 },
+          { name: 'Vertical Grip', quality: 'common', level: 65 }
+        ]
+      },
+      {
+        name: 'DeathDealer',
+        score: 7300,
+        equipments: [
+          { name: 'SKS', quality: 'epic', level: 76 },
+          { name: 'Holographic Sight', quality: 'rare', level: 68 },
+          { name: 'Extended Mag', quality: 'common', level: 65 }
+        ]
+      },
+      {
+        name: 'StormRider',
+        score: 8900,
+        equipments: [
+          { name: 'MK14', quality: 'legendary', level: 92 },
+          { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+          { name: 'Scope 8x', quality: 'epic', level: 80 },
+          { name: 'Suppressor', quality: 'legendary', level: 88 },
+          { name: 'Tactical Stock', quality: 'rare', level: 75 }
+        ]
+      },
+      {
+        name: 'CombatLegend',
+        score: 7600,
+        equipments: [
+          { name: 'UMP45', quality: 'rare', level: 74 },
+          { name: 'Level 2 Vest', quality: 'common', level: 67 },
+          { name: 'Red Dot Sight', quality: 'common', level: 62 },
+          { name: 'Extended Mag', quality: 'rare', level: 70 }
+        ]
+      }
+    ];
+
+    // Create a TreeMultiMap for player rankings
+    const playerRankings = new TreeMultiMap<number, Equipment, Player>(players, {
+      toEntryFn: ({ score, equipments }) => [score, equipments],
+      isMapMode: false
+    });
+
+    const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node));
+    expect(topPlayersEquipments).toEqual([
+      [
+        {
+          name: 'MK14',
+          quality: 'legendary',
+          level: 92
+        },
+        { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+        {
+          name: 'Scope 8x',
+          quality: 'epic',
+          level: 80
+        },
+        { name: 'Suppressor', quality: 'legendary', level: 88 },
+        {
+          name: 'Tactical Stock',
+          quality: 'rare',
+          level: 75
+        }
+      ],
+      [
+        { name: 'KAR98K', quality: 'legendary', level: 90 },
+        {
+          name: 'Level 3 Vest',
+          quality: 'legendary',
+          level: 85
+        },
+        { name: 'Holographic Sight', quality: 'epic', level: 82 },
+        {
+          name: 'Suppressor',
+          quality: 'legendary',
+          level: 88
+        },
+        { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+      ]
+    ]);
   });
 });

package/test/unit/data-structures/linked-list/doubly-linked-list.test.ts

@@ -32,14 +32,14 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should deleteAt', () => {
-    expect(list.deleteAt(1)).toBe(true);
-    expect(list.deleteAt(-1)).toBe(false);
-    expect(list.deleteAt(list.size)).toBe(false);
-    expect(list.size).toBe(4);
-    expect(list.deleteAt(4)).toBe(false);
+    expect(list.deleteAt(1)).toBe(2);
+    expect(list.deleteAt(-1)).toBe(undefined);
+    expect(list.deleteAt(list.length)).toBe(undefined);
+    expect(list.length).toBe(4);
+    expect(list.deleteAt(4)).toBe(undefined);
     expect([...list]).toEqual([1, 3, 4, 5]);
     expect(list.isEmpty()).toBe(false);
-    expect(list.deleteAt(3)).toBe(true);
+    expect(list.deleteAt(3)).toBe(5);
     expect([...list]).toEqual([1, 3, 4]);
   });
 
@@ -103,7 +103,7 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should initialize an empty list', () => {
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -119,17 +119,36 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(1);
     list.push(2);
     list.push(3);
-    expect(list.size).toBe(3);
+    expect(list.length).toBe(3);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(3);
   });
 
+  it('push with maxLen', () => {
+    const list = new DoublyLinkedList<number>([], { maxLen: 10 });
+    for (let i = 0; i < 1000; i++) {
+      list.push(i);
+    }
+    expect(list.maxLen).toBe(10);
+    expect(list.length).toBe(10);
+    expect(list.first).toBe(990);
+
+    list.clear();
+    for (let i = 0; i < 1000; i++) {
+      list.unshift(i);
+    }
+
+    expect(list.maxLen).toBe(10);
+    expect(list.length).toBe(10);
+    expect(list.last).toBe(990);
+  });
+
   it('should pop elements from the end of the list', () => {
     list.push(1);
     list.push(2);
     const poppedValue = list.pop();
     expect(poppedValue).toBe(2);
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(1);
     list.pop();
@@ -145,19 +164,19 @@ describe('DoublyLinkedList Operation Test', () => {
 
     // Inserting at the beginning
     list.addAt(0, 0);
-    expect(list.size).toBe(4);
+    expect(list.length).toBe(4);
     expect(list.at(0)).toBe(0);
     expect(list.at(1)).toBe(1);
 
     // Inserting in the middle
     list.addAt(2, 1.5);
-    expect(list.size).toBe(5);
+    expect(list.length).toBe(5);
     expect(list.at(2)).toBe(1.5);
     expect(list.at(3)).toBe(2);
 
     // Inserting at the end
     list.addAt(5, 4);
-    expect(list.size).toBe(6);
+    expect(list.length).toBe(6);
     expect(list.at(5)).toBe(4);
     expect(list.tail!.value).toBe(4);
     expect(list.at(-1)).toBe(undefined);
@@ -171,18 +190,18 @@ describe('DoublyLinkedList Operation Test', () => {
 
     // Deleting from the beginning
     const deletedValue = list.deleteAt(0);
-    expect(deletedValue).toBe(true);
-    expect(list.size).toBe(2);
+    expect(deletedValue).toBe(1);
+    expect(list.length).toBe(2);
     expect(list.head!.value).toBe(2);
 
     // Deleting from the middle
     list.deleteAt(0); // Deleting the second element
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
     expect(list.head!.value).toBe(3);
 
     // Deleting from the end
     list.deleteAt(0);
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -193,16 +212,16 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
 
     list.delete(2);
-    expect(list.size).toBe(2);
+    expect(list.length).toBe(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(3);
 
     list.delete(1);
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
     expect(list.head!.value).toBe(3);
 
     list.delete(3);
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -307,7 +326,7 @@ describe('DoublyLinkedList Operation Test', () => {
 
     list.clear();
 
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -447,6 +466,95 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 });
 
+describe('DoublyLinkedList Additional Methods', () => {
+  // Slice method implementation and test
+  test('slice should return a new list with specified range', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+    const slicedList = list.slice(1, 4);
+
+    expect(slicedList.toArray()).toEqual([2, 3, 4]);
+    expect(list.length).toBe(5); // Original list unchanged
+  });
+
+  // Splice method implementation
+  test('splice should modify list and return removed elements', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+    const removedList = list.splice(2, 2, 6, 7);
+
+    expect(list.toArray()).toEqual([1, 2, 6, 7, 5]);
+    expect(removedList.toArray()).toEqual([3, 4]);
+  });
+
+  // Concat method test
+  test('concat should combine multiple lists', () => {
+    const list1 = new DoublyLinkedList([1, 2]);
+    const list2 = new DoublyLinkedList([3, 4]);
+    const list3 = new DoublyLinkedList([5, 6]);
+
+    const concatenatedList = list1.concat(list2, list3);
+    expect(concatenatedList.toArray()).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  // Sort method test
+  test('sort should order elements in ascending order', () => {
+    const list = new DoublyLinkedList([5, 2, 8, 1, 9]);
+    list.sort((a, b) => a - b);
+
+    expect(list.toArray()).toEqual([1, 2, 5, 8, 9]);
+  });
+
+  // Reverse method test
+  test('reverse should invert the list order', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+    list.reverse();
+
+    expect(list.toArray()).toEqual([5, 4, 3, 2, 1]);
+  });
+
+  // Join method test
+  test('join should convert list to string with separator', () => {
+    const list = new DoublyLinkedList(['a', 'b', 'c']);
+
+    expect(list.join('-')).toBe('a-b-c');
+    expect(list.join()).toBe('a,b,c');
+  });
+
+  // IndexOf method test
+  test('indexOf should return first occurrence index', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.indexOf(2)).toBe(1);
+    expect(list.indexOf(4)).toBe(-1);
+  });
+
+  // LastIndexOf method test
+  test('lastIndexOf should return last occurrence index', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.lastIndexOf(2)).toBe(3);
+    expect(list.lastIndexOf(4)).toBe(-1);
+  });
+
+  // findIndex method test
+  test('findIndex should return first occurrence index', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect(list.findIndex(item => item === 2)).toBe(1);
+    expect(list.findIndex(item => item === 4)).toBe(-1);
+  });
+
+  // fill method test
+  test('fill should return fill all the list', () => {
+    let list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9)]).toEqual([9, 9, 9, 9, 9]);
+    list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, 2, 3)]).toEqual([1, 2, 9, 2, 1]);
+    list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -3, -2)]).toEqual([1, 2, 9, 2, 1]);
+    list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -2, -3)]).toEqual([1, 2, 3, 2, 1]);
+  });
+});
+
 describe('iterable methods', () => {
   it('should forEach, some, every, filter, map, reduce of the deque', () => {
     const dl = new DoublyLinkedList<number>();
@@ -578,7 +686,7 @@ describe('classic use', () => {
         const initialNode = this.currentSong;
 
         // Loop through the playlist twice
-        for (let i = 0; i < this.playlist.size * 2; i++) {
+        for (let i = 0; i < this.playlist.length * 2; i++) {
           playedSongs.push(this.currentSong!.value);
           this.currentSong = this.currentSong!.next || this.playlist.head; // Loop back to the start if needed
         }
@@ -700,7 +808,7 @@ describe('classic use', () => {
         }
 
         // Check capacity
-        if (this.list.size >= this.capacity) {
+        if (this.list.length >= this.capacity) {
           // Delete the least recently used element (the tail of the linked list)
           const removedNode = this.list.tail;
           if (removedNode) {
@@ -745,9 +853,9 @@ describe('classic use', () => {
         this.map.clear();
       }
 
-      // Get the current cache size
-      get size(): number {
-        return this.list.size;
+      // Get the current cache length
+      get length(): number {
+        return this.list.length;
       }
 
       // Check if it is empty
@@ -806,7 +914,7 @@ describe('classic use', () => {
 
     expect(cache.delete('a')).toBe(true);
     expect(cache.get('a')).toBeUndefined();
-    expect(cache.size).toBe(1);
+    expect(cache.length).toBe(1);
 
     // Should support clearing cache
     cache.clear();
@@ -814,7 +922,7 @@ describe('classic use', () => {
     cache.set('b', 2);
     cache.clear();
 
-    expect(cache.size).toBe(0);
+    expect(cache.length).toBe(0);
     expect(cache.isEmpty).toBe(true);
   });