data-structure-typed 1.54.3 → 2.0.0

package/test/unit/data-structures/queue/queue.test.ts

@@ -11,21 +11,21 @@ describe('Queue', () => {
   });
 
   it('new Queue() should create an empty queue', () => {
-    expect(queue.size).toBe(0);
+    expect(queue.length).toBe(0);
     expect(queue.isEmpty()).toBeTruthy();
   });
 
   it('push should add elements to the queue', () => {
     queue.push(1);
     queue.push(2);
-    expect(queue.size).toBe(2);
+    expect(queue.length).toBe(2);
   });
 
   it('shift should remove the first element', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.shift()).toBe(1);
-    expect(queue.size).toBe(1);
+    expect(queue.length).toBe(1);
   });
 
   it('shift should return undefined if queue is empty', () => {
@@ -36,17 +36,17 @@ describe('Queue', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.first).toBe(1);
-    expect(queue.size).toBe(2);
+    expect(queue.length).toBe(2);
   });
 
   it('first should return undefined if queue is empty', () => {
     expect(queue.first).toBeUndefined();
   });
 
-  it('size should return the number of elements', () => {
+  it('length should return the number of elements', () => {
     queue.push(1);
     queue.push(2);
-    expect(queue.size).toBe(2);
+    expect(queue.length).toBe(2);
   });
 
   it('isEmpty should return true if the queue is empty', () => {
@@ -68,7 +68,7 @@ describe('Queue', () => {
     queue.push(1);
     queue.push(2);
     queue.clear();
-    expect(queue.size).toBe(0);
+    expect(queue.length).toBe(0);
   });
 
   it('forEach should iterate over all elements', () => {
@@ -90,6 +90,16 @@ describe('Queue', () => {
     expect(queue.isEmpty()).toBeTruthy();
   });
 
+  it('push with maxLen', () => {
+    const queue = new Queue<number>([], { maxLen: 10 });
+    for (let i = 0; i < 1000; i++) {
+      queue.push(i);
+    }
+    expect(queue.maxLen).toBe(10);
+    expect(queue.length).toBe(10);
+    expect(queue.first).toBe(990);
+  });
+
   it('compact method should work well', () => {
     for (let i = 0; i < 1000; i++) queue.push(i);
 
@@ -119,9 +129,9 @@ describe('Queue', () => {
       toElementFn: rawElement => rawElement.id
     });
 
-    expect(queue.size).toBe(5);
+    expect(queue.length).toBe(5);
     queue.shift();
-    expect(queue.size).toBe(4);
+    expect(queue.length).toBe(4);
     expect(queue.at(1)).toBe('3');
   });
 
@@ -193,11 +203,11 @@ describe('Queue', () => {
     queue.push(9);
     queue.push(10);
     expect(queue.elements.length).toBe(10);
-    while (queue.size > 7) queue.shift();
-    expect(queue.size).toBe(7);
+    while (queue.length > 7) queue.shift();
+    expect(queue.length).toBe(7);
     expect(queue.elements.length).toBe(10);
     queue.shift();
-    expect(queue.size).toBe(6);
+    expect(queue.length).toBe(6);
     expect(queue.elements.length).toBe(6);
   });
 });
@@ -260,7 +270,7 @@ describe('Queue - Additional Methods', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.last).toBe(2);
-    expect(queue.size).toBe(2);
+    expect(queue.length).toBe(2);
   });
 
   it('peekLast should return undefined if queue is empty', () => {
@@ -288,12 +298,101 @@ describe('Queue - Additional Methods', () => {
   });
 });
 
+describe('Queue Additional Methods', () => {
+  // Slice method implementation and test
+  test('slice should return a new list with specified range', () => {
+    const list = new Queue([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 Queue([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 Queue([1, 2]);
+    const list2 = new Queue([3, 4]);
+    const list3 = new Queue([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 Queue([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 Queue([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 Queue(['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 Queue([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 Queue([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 Queue([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 Queue([1, 2, 3, 2, 1]);
+    expect([...list.fill(9)]).toEqual([9, 9, 9, 9, 9]);
+    list = new Queue([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, 2, 3)]).toEqual([1, 2, 9, 2, 1]);
+    list = new Queue([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -3, -2)]).toEqual([1, 2, 9, 2, 1]);
+    list = new Queue([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -2, -3)]).toEqual([1, 2, 3, 2, 1]);
+  });
+});
+
 describe('Queue - Static and Clone Methods', () => {
   it('fromArray should create a new queue from an array', () => {
     const array = [1, 2, 3];
     const queue = Queue.fromArray(array);
     expect(queue.toArray()).toEqual(array);
-    expect(queue.size).toBe(array.length);
+    expect(queue.length).toBe(array.length);
   });
 
   it('fromArray should create an empty queue from an empty array', () => {
@@ -308,7 +407,7 @@ describe('Queue - Static and Clone Methods', () => {
 
     const clonedQueue = originalQueue.clone();
     expect(clonedQueue.toArray()).toEqual(originalQueue.toArray());
-    expect(clonedQueue.size).toBe(originalQueue.size);
+    expect(clonedQueue.length).toBe(originalQueue.length);
   });
 
   it('clone should not affect the original queue when mutated', () => {
@@ -319,7 +418,7 @@ describe('Queue - Static and Clone Methods', () => {
     const clonedQueue = originalQueue.clone();
     clonedQueue.push(3);
 
-    expect(clonedQueue.size).not.toBe(originalQueue.size);
+    expect(clonedQueue.length).not.toBe(originalQueue.length);
     expect(originalQueue.toArray()).not.toContain(3);
   });
 });
@@ -335,14 +434,14 @@ describe('LinkedListQueue', () => {
 
   it('should push elements to the end of the queue', () => {
     expect(queue.first).toBe('A');
-    expect(queue.size).toBe(2);
+    expect(queue.length).toBe(2);
   });
 
   it('should shift elements from the front of the queue', () => {
     const dequeued = queue.shift();
     expect(dequeued).toBe('A');
     expect(queue.first).toBe('B');
-    expect(queue.size).toBe(1);
+    expect(queue.length).toBe(1);
   });
 
   it('should peek at the front of the queue', () => {
@@ -352,6 +451,6 @@ describe('LinkedListQueue', () => {
   it('should clone method work correctly', () => {
     const cloned = queue.clone();
     expect(cloned instanceof LinkedListQueue).toBe(true);
-    expect(cloned.size).toBe(2);
+    expect(cloned.length).toBe(2);
   });
 });

package/test/unit/unrestricted-interconversion.test.ts

@@ -263,7 +263,7 @@ describe('conversions', () => {
       'triangle'
     ]);
     const dq = new Deque<string>(heap);
-    expect(dq.size).toBe(10);
+    expect(dq.length).toBe(10);
     if (isDebug) dq.print();
     expect([...dq]).toEqual([
       'transmit',