data-structure-typed 1.50.4 → 1.50.6

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

@@ -39,12 +39,12 @@ describe('DoublyLinkedList Operation Test', () => {
 
   it('should clone', function () {
     const dList = new DoublyLinkedList<string>();
-    dList.addLast('1');
-    dList.addLast('6');
-    dList.addLast('2');
-    dList.addLast('0');
-    dList.addLast('5');
-    dList.addLast('9');
+    dList.push('1');
+    dList.push('6');
+    dList.push('2');
+    dList.push('0');
+    dList.push('5');
+    dList.push('9');
     dList.delete('2');
     expect([...dList]).toEqual(['1', '6', '0', '5', '9']);
     const cloned = dList.clone();

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

@@ -32,7 +32,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       const popped = list.pop();
       expect(popped).toBe(3);
-      expect(list.pollLast()).toBe(2);
+      expect(list.pop()).toBe(2);
       expect(list.toArray()).toEqual([1]);
     });
 
@@ -49,7 +49,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       const shifted = list.shift();
       expect(shifted).toBe(1);
-      expect(list.pollFirst()).toBe(2);
+      expect(list.shift()).toBe(2);
       expect(list.toArray()).toEqual([3]);
     });
 
@@ -62,7 +62,7 @@ describe('SinglyLinkedList Operation Test', () => {
   describe('unshift', () => {
     it('should add elements to the beginning of the list', () => {
       list.unshift(1);
-      list.addFirst(2);
+      list.unshift(2);
       expect(list.toArray()).toEqual([2, 1]);
     });
   });
@@ -350,12 +350,12 @@ describe('SinglyLinkedList Operation Test', () => {
 
   it('should clone', function () {
     const sList = new SinglyLinkedList<string>();
-    sList.addLast('1');
-    sList.addLast('6');
-    sList.addLast('2');
-    sList.addLast('0');
-    sList.addLast('5');
-    sList.addLast('9');
+    sList.push('1');
+    sList.push('6');
+    sList.push('2');
+    sList.push('0');
+    sList.push('5');
+    sList.push('9');
     sList.delete('2');
     expect([...sList]).toEqual(['1', '6', '0', '5', '9']);
     const cloned = sList.clone();
@@ -478,7 +478,7 @@ describe('SinglyLinkedList', () => {
   });
 
   it('should map the list', () => {
-    list.addLast(1);
+    list.push(1);
     list.push(2);
     list.push(3);
     expect(list.map(value => value * 2).toArray()).toEqual([2, 4, 6]);

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

@@ -65,21 +65,21 @@ describe('SkipList Test2', () => {
     skipList.add(4, 'Four');
   });
 
-  it('getFirst() should return the getFirst element', () => {
+  it('first() should return the first element', () => {
     expect(skipList.first).toBe('One');
   });
 
-  it('getLast() should return the getLast element', () => {
+  it('last() should return the last element', () => {
     expect(skipList.last).toBe('Four');
   });
 
-  it('higher(key) should return the getFirst element greater than the given key', () => {
+  it('higher(key) should return the first element greater than the given key', () => {
     expect(skipList.higher(2)).toBe('Three');
     expect(skipList.higher(3)).toBe('Four');
     expect(skipList.higher(4)).toBeUndefined();
   });
 
-  it('lower(key) should return the getLast element less than the given key', () => {
+  it('lower(key) should return the last element less than the given key', () => {
     expect(skipList.lower(2)).toBe('One');
     expect(skipList.lower(1)).toBe(undefined);
   });

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

@@ -52,12 +52,12 @@ describe('Deque - Basic Operations', () => {
 
   it('should clone', function () {
     const deque = new Deque<string>();
-    deque.addLast('1');
-    deque.addLast('6');
-    deque.addLast('2');
-    deque.addLast('0');
-    deque.addLast('5');
-    deque.addLast('9');
+    deque.push('1');
+    deque.push('6');
+    deque.push('2');
+    deque.push('0');
+    deque.push('5');
+    deque.push('9');
     expect(deque.size).toBe(6);
     deque.delete('2');
     expect(deque.size).toBe(5);
@@ -70,7 +70,7 @@ describe('Deque - Basic Operations', () => {
     expect([...deque]).toEqual(['1', '6', '0', '9']);
     expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
     expect(cloned.size).toBe(5);
-    cloned.addLast('8');
+    cloned.push('8');
     expect(cloned.size).toBe(6);
     cloned.delete('6');
     expect(cloned.size).toBe(5);
@@ -239,52 +239,52 @@ describe('Deque - Additional Operations', () => {
     deque = new Deque<number>();
   });
 
-  test('addLast should add an element to the end', () => {
-    deque.addLast(1);
-    deque.addLast(2);
+  test('push should add an element to the end', () => {
+    deque.push(1);
+    deque.push(2);
     expect(deque.last).toBe(2);
     expect(deque.size).toBe(2);
   });
 
-  test('pollLast should remove and return the last element', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-    expect(deque.pollLast()).toBe(2);
+  test('pop should remove and return the last element', () => {
+    deque.push(1);
+    deque.push(2);
+    expect(deque.pop()).toBe(2);
     expect(deque.size).toBe(1);
   });
 
-  test('addFirst should add an element to the beginning', () => {
-    deque.addFirst(1);
-    deque.addFirst(2);
+  test('unshift should add an element to the beginning', () => {
+    deque.unshift(1);
+    deque.unshift(2);
     expect(deque.first).toBe(2);
     expect(deque.size).toBe(2);
   });
 
-  test('pollFirst should remove and return the first element', () => {
-    deque.addFirst(1);
-    deque.addFirst(2);
-    expect(deque.pollFirst()).toBe(2);
+  test('shift should remove and return the first element', () => {
+    deque.unshift(1);
+    deque.unshift(2);
+    expect(deque.shift()).toBe(2);
     expect(deque.size).toBe(1);
   });
 
   test('clear should reset the deque', () => {
-    deque.addFirst(1);
+    deque.unshift(1);
     deque.clear();
     expect(deque.size).toBe(0);
     expect(deque.isEmpty()).toBeTruthy();
   });
 
   test('begin should yield elements from the beginning', () => {
-    deque.addLast(1);
-    deque.addLast(2);
+    deque.push(1);
+    deque.push(2);
     const iterator = deque.begin();
     expect(iterator.next().value).toBe(1);
     expect(iterator.next().value).toBe(2);
   });
 
   test('reverseBegin should yield elements in reverse order', () => {
-    deque.addLast(1);
-    deque.addLast(2);
+    deque.push(1);
+    deque.push(2);
     const iterator = deque.reverseBegin();
     expect(iterator.next().value).toBe(2);
     expect(iterator.next().value).toBe(1);

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

@@ -23,24 +23,24 @@ describe('Queue', () => {
 
   test('shift should remove the first element', () => {
     queue.push(1);
-    queue.enqueue(2);
+    queue.push(2);
     expect(queue.shift()).toBe(1);
     expect(queue.size).toBe(1);
   });
 
   test('shift should return undefined if queue is empty', () => {
-    expect(queue.dequeue()).toBeUndefined();
+    expect(queue.shift()).toBeUndefined();
   });
 
-  test('peek should return the first element without removing it', () => {
+  test('first should return the first element without removing it', () => {
     queue.push(1);
     queue.push(2);
-    expect(queue.peek()).toBe(1);
+    expect(queue.first).toBe(1);
     expect(queue.size).toBe(2);
   });
 
-  test('peek should return undefined if queue is empty', () => {
-    expect(queue.peek()).toBeUndefined();
+  test('first should return undefined if queue is empty', () => {
+    expect(queue.first).toBeUndefined();
   });
 
   test('size should return the number of elements', () => {
@@ -167,12 +167,12 @@ describe('Queue - Additional Methods', () => {
   test('peekLast should return the last element without removing it', () => {
     queue.push(1);
     queue.push(2);
-    expect(queue.peekLast()).toBe(2);
+    expect(queue.last).toBe(2);
     expect(queue.size).toBe(2);
   });
 
   test('peekLast should return undefined if queue is empty', () => {
-    expect(queue.peekLast()).toBeUndefined();
+    expect(queue.last).toBeUndefined();
   });
 
   test('at should return the element at the specified index', () => {
@@ -239,25 +239,25 @@ describe('LinkedListQueue', () => {
     queue = new LinkedListQueue<string>();
   });
 
-  it('should enqueue elements to the end of the queue', () => {
-    queue.enqueue('A');
-    queue.enqueue('B');
-    expect(queue.peek()).toBe('A');
+  it('should push elements to the end of the queue', () => {
+    queue.push('A');
+    queue.push('B');
+    expect(queue.first).toBe('A');
     expect(queue.size).toBe(2);
   });
 
-  it('should dequeue elements from the front of the queue', () => {
-    queue.enqueue('A');
-    queue.enqueue('B');
-    const dequeued = queue.dequeue();
+  it('should shift elements from the front of the queue', () => {
+    queue.push('A');
+    queue.push('B');
+    const dequeued = queue.shift();
     expect(dequeued).toBe('A');
-    expect(queue.peek()).toBe('B');
+    expect(queue.first).toBe('B');
     expect(queue.size).toBe(1);
   });
 
   it('should peek at the front of the queue', () => {
-    queue.enqueue('A');
-    queue.enqueue('B');
-    expect(queue.peek()).toBe('A');
+    queue.push('A');
+    queue.push('B');
+    expect(queue.first).toBe('A');
   });
 });