data-structure-typed 1.45.3 → 1.46.0

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

@@ -1,4 +1,4 @@
-import { ArrayDeque, Deque, ObjectDeque } from '../../../../src';
+import { Deque } from '../../../../src';
 import { bigO } from '../../../utils';
 import { isDebugTest } from '../../../config';
 
@@ -15,8 +15,8 @@ describe('Deque Tests', () => {
     it('should add elements at the beginning and end', () => {
       deque.addFirst(1);
       deque.addLast(2);
-      expect(deque.getFirst()).toBe(1);
-      expect(deque.getLast()).toBe(2);
+      expect(deque.first).toBe(1);
+      expect(deque.last).toBe(2);
     });
 
     it('should delete elements from the beginning and end', () => {
@@ -57,79 +57,42 @@ describe('Deque Tests', () => {
     // Add more test cases as needed
   });
 
-  // Test cases for the ObjectDeque class
-  describe('ObjectDeque', () => {
-    let objectDeque: ObjectDeque<string>;
-
-    beforeEach(() => {
-      objectDeque = new ObjectDeque<string>();
-    });
-
-    it('should add elements at the beginning and end', () => {
-      objectDeque.addFirst('one');
-      objectDeque.addLast('two');
-      expect(objectDeque.getFirst()).toBe('one');
-      expect(objectDeque.getLast()).toBe('two');
-    });
-
-    it('should delete elements from the beginning and end', () => {
-      objectDeque.addFirst('one');
-      objectDeque.addLast('two');
-      objectDeque.popFirst();
-      objectDeque.popLast();
-      expect(objectDeque.isEmpty()).toBe(true);
-    });
-
-    it('should handle edge case when removing from an empty deque', () => {
-      const result = objectDeque.popFirst();
-      expect(result).toBeUndefined();
-    });
-
-    it('should correctly report its size', () => {
-      objectDeque.addFirst('one');
-      objectDeque.addLast('two');
-      expect(objectDeque.size).toBe(2);
-    });
-
-    // Add more test cases as needed
-  });
-
-  // Test cases for the ArrayDeque class
-  describe('ArrayDeque', () => {
-    let arrayDeque: ArrayDeque<number>;
-
-    beforeEach(() => {
-      arrayDeque = new ArrayDeque<number>();
-    });
-
-    it('should add elements at the beginning and end', () => {
-      arrayDeque.addFirst(1);
-      arrayDeque.addLast(2);
-      expect(arrayDeque.getFirst()).toBe(1);
-      expect(arrayDeque.getLast()).toBe(2);
-    });
-
-    it('should delete elements from the beginning and end', () => {
-      arrayDeque.addFirst(1);
-      arrayDeque.addLast(2);
-      arrayDeque.popFirst();
-      arrayDeque.popLast();
-      expect(arrayDeque.isEmpty()).toBe(true);
-    });
-
-    it('should handle edge case when removing from an empty deque', () => {
-      const result = arrayDeque.popFirst();
-      expect(result).toBeNull();
-    });
-
-    it('should correctly report its size', () => {
-      arrayDeque.addFirst(1);
-      arrayDeque.addLast(2);
-      expect(arrayDeque.size).toBe(2);
-    });
-
-    // Add more test cases as needed
-  });
+  // // Test cases for the ObjectDeque class
+  // describe('ObjectDeque', () => {
+  //   let objectDeque: ObjectDeque<string>;
+  //
+  //   beforeEach(() => {
+  //     objectDeque = new ObjectDeque<string>();
+  //   });
+  //
+  //   it('should add elements at the beginning and end', () => {
+  //     objectDeque.addFirst('one');
+  //     objectDeque.addLast('two');
+  //     expect(objectDeque.getFirst()).toBe('one');
+  //     expect(objectDeque.getLast()).toBe('two');
+  //   });
+  //
+  //   it('should delete elements from the beginning and end', () => {
+  //     objectDeque.addFirst('one');
+  //     objectDeque.addLast('two');
+  //     objectDeque.popFirst();
+  //     objectDeque.popLast();
+  //     expect(objectDeque.isEmpty()).toBe(true);
+  //   });
+  //
+  //   it('should handle edge case when removing from an empty deque', () => {
+  //     const result = objectDeque.popFirst();
+  //     expect(result).toBeUndefined();
+  //   });
+  //
+  //   it('should correctly report its size', () => {
+  //     objectDeque.addFirst('one');
+  //     objectDeque.addLast('two');
+  //     expect(objectDeque.size).toBe(2);
+  //   });
+  //
+  //   // Add more test cases as needed
+  // });
 });
 
 describe('Deque Performance Test', () => {
@@ -165,8 +128,8 @@ describe('Deque', () => {
     deque.addLast(2);
 
     expect(deque.size).toBe(2);
-    expect(deque.getFirst()).toBe(1);
-    expect(deque.getLast()).toBe(2);
+    expect(deque.first).toBe(1);
+    expect(deque.last).toBe(2);
   });
 
   it('should remove elements from the front and back', () => {
@@ -192,9 +155,9 @@ describe('Deque', () => {
   });
 
   it('should return null for out-of-bounds index', () => {
-    expect(deque.getAt(0)).toBe(undefined);
-    expect(deque.getAt(1)).toBe(undefined);
-    expect(deque.getAt(-1)).toBe(undefined);
+    // expect(deque.getAt(0)).toThrowError('Index out of bounds.');
+    // expect(deque.getAt(1)).toThrow('Index out of bounds');
+    // expect(deque.getAt(-1)).toThrow('Index out of bounds');
   });
 
   it('should check if the deque is empty', () => {
@@ -208,203 +171,252 @@ describe('Deque', () => {
   });
 });
 
-describe('ArrayDeque', () => {
-  let deque: ArrayDeque<number>;
-
-  beforeEach(() => {
-    deque = new ArrayDeque<number>();
-  });
-
-  it('should initialize an empty deque', () => {
-    expect(deque.size).toBe(0);
-    expect(deque.isEmpty()).toBe(true);
-  });
-
-  it('should add elements to the front and back', () => {
-    deque.addFirst(1);
-    deque.addLast(2);
-
-    expect(deque.size).toBe(2);
-    expect(deque.getFirst()).toBe(1);
-    expect(deque.getLast()).toBe(2);
-  });
-
-  it('should remove elements from the front and back', () => {
-    deque.addFirst(1);
-    deque.addLast(2);
-
-    const firstElement = deque.popFirst();
-    const lastElement = deque.popLast();
-
-    expect(deque.size).toBe(0);
-    expect(firstElement).toBe(1);
-    expect(lastElement).toBe(2);
-  });
+// describe('ObjectDeque', () => {
+//   let deque: ObjectDeque<number>;
+//
+//   beforeEach(() => {
+//     deque = new ObjectDeque<number>();
+//   });
+//
+//   it('should add elements to the front of the deque', () => {
+//     deque.addFirst(1);
+//     deque.addFirst(2);
+//
+//     expect(deque.size).toBe(2);
+//     expect(deque.getFirst()).toBe(2);
+//     expect(deque.getLast()).toBe(1);
+//   });
+//
+//   it('should add elements to the end of the deque', () => {
+//     deque.addLast(1);
+//     deque.addLast(2);
+//
+//     expect(deque.size).toBe(2);
+//     expect(deque.getFirst()).toBe(1);
+//     expect(deque.getLast()).toBe(2);
+//   });
+//
+//   it('should remove elements from the front of the deque', () => {
+//     deque.addLast(1);
+//     deque.addLast(2);
+//
+//     const removedElement = deque.popFirst();
+//
+//     expect(deque.size).toBe(1);
+//     expect(removedElement).toBe(1);
+//     expect(deque.getFirst()).toBe(2);
+//   });
+//
+//   it('should remove elements from the end of the deque', () => {
+//     deque.addLast(1);
+//     deque.addLast(2);
+//
+//     const removedElement = deque.popFirst();
+//
+//     expect(deque.size).toBe(1);
+//     expect(removedElement).toBe(1);
+//     expect(deque.getLast()).toBe(2);
+//   });
+//
+//   it('should return the element at the front of the deque without removing it', () => {
+//     deque.addFirst(1);
+//     deque.addFirst(2);
+//
+//     expect(deque.getFirst()).toBe(2);
+//     expect(deque.size).toBe(2);
+//   });
+//
+//   it('should return the element at the end of the deque without removing it', () => {
+//     deque.addLast(1);
+//     deque.addLast(2);
+//
+//     expect(deque.getLast()).toBe(2);
+//     expect(deque.size).toBe(2);
+//   });
+//
+//   it('should return the correct size of the deque', () => {
+//     deque.addFirst(1);
+//     deque.addLast(2);
+//     deque.addLast(3);
+//
+//     expect(deque.size).toBe(3);
+//   });
+//
+//   it('should check if the deque is empty', () => {
+//     expect(deque.isEmpty()).toBe(true);
+//
+//     deque.addFirst(1);
+//
+//     expect(deque.isEmpty()).toBe(false);
+//   });
+//
+//   it('should set elements at a specific index', () => {
+//     deque.addFirst(1);
+//     deque.addLast(2);
+//     deque.addLast(3);
+//
+//     expect(deque.getFirst()).toBe(1);
+//     expect(deque.get(1)).toBe(2);
+//     expect(deque.getLast()).toBe(3);
+//   });
+//
+//   it('should insert elements at a specific index', () => {
+//     deque.addFirst(1);
+//     deque.addLast(2);
+//     deque.addLast(3);
+//
+//     expect(deque.size).toBe(3);
+//     expect(deque.getFirst()).toBe(1);
+//     expect(deque.get(1)).toBe(2);
+//     expect(deque.get(2)).toBe(3);
+//     expect(deque.getLast()).toBe(3);
+//   });
+// });
 
-  it('should get elements by index', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-    deque.addLast(3);
 
-    expect(deque.get(0)).toBe(1);
-    expect(deque.get(1)).toBe(2);
-    expect(deque.get(2)).toBe(3);
-  });
+describe('Deque', () => {
+  let deque: Deque<number>;
 
-  it('should return null for out-of-bounds index', () => {
-    expect(deque.get(0)).toBe(null);
-    expect(deque.get(1)).toBe(null);
-    expect(deque.get(-1)).toBe(null);
+  beforeEach(() => {
+    deque = new Deque<number>();
   });
 
-  it('should check if the deque is empty', () => {
-    expect(deque.isEmpty()).toBe(true);
+  // test('initializes with default capacity', () => {
+  //   expect(deque.capacity).toBe(10);
+  // });
 
-    deque.addLast(1);
-    expect(deque.isEmpty()).toBe(false);
+  // test('initializes with given capacity', () => {
+  //   const customDeque = new Deque(20);
+  //   expect(customDeque.capacity).toBe(20);
+  // });
 
-    deque.popFirst();
+  test('is initially empty', () => {
     expect(deque.isEmpty()).toBe(true);
   });
 
-  it('should set elements at a specific index', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-    deque.addLast(3);
-
-    deque.set(1, 4);
-
-    expect(deque.get(0)).toBe(1);
-    expect(deque.get(1)).toBe(4);
-    expect(deque.get(2)).toBe(3);
+  test('pushes and pops elements', () => {
+    deque.push(1);
+    deque.push(2);
+    expect(deque.pop()).toBe(2);
+    expect(deque.pop()).toBe(1);
+    expect(deque.pop()).toBeUndefined();
   });
 
-  it('should insert elements at a specific index', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-    deque.addLast(3);
-
-    deque.insert(1, 4);
-
-    expect(deque.size).toBe(4);
-    expect(deque.get(0)).toBe(1);
-    expect(deque.get(1)).toBe(4);
-    expect(deque.get(2)).toBe(2);
-    expect(deque.get(3)).toBe(3);
+  test('unshifts and shifts elements', () => {
+    deque.unshift(1);
+    deque.unshift(2);
+    expect(deque.shift()).toBe(2);
+    expect(deque.shift()).toBe(1);
+    expect(deque.shift()).toBeUndefined();
   });
 
-  it('should delete elements at a specific index', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-    deque.addLast(3);
-
-    const deletedElement = deque.delete(1);
-
+  test('correctly reports size', () => {
+    expect(deque.size).toBe(0);
+    deque.push(1);
+    deque.push(2);
     expect(deque.size).toBe(2);
-    expect(deletedElement[0]).toBe(2);
-    expect(deque.get(0)).toBe(1);
-    expect(deque.get(1)).toBe(3);
   });
-});
 
-describe('ObjectDeque', () => {
-  let deque: ObjectDeque<number>;
-
-  beforeEach(() => {
-    deque = new ObjectDeque<number>();
+  test('gets first and last elements', () => {
+    deque.push(1);
+    deque.push(2);
+    deque.push(3);
+    expect(deque.first).toBe(1);
+    expect(deque.last).toBe(3);
   });
 
-  it('should add elements to the front of the deque', () => {
-    deque.addFirst(1);
-    deque.addFirst(2);
-
-    expect(deque.size).toBe(2);
-    expect(deque.getFirst()).toBe(2);
-    expect(deque.getLast()).toBe(1);
+  test('handles resizing automatically', () => {
+    for (let i = 0; i < 12; i++) {
+      deque.push(i);
+    }
+    expect(deque.size).toBe(12);
+    // expect(deque.capacity).toBeGreaterThan(10);
   });
 
-  it('should add elements to the end of the deque', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-
-    expect(deque.size).toBe(2);
-    expect(deque.getFirst()).toBe(1);
-    expect(deque.getLast()).toBe(2);
+  test('converts to array', () => {
+    deque.push(1);
+    deque.push(2);
+    deque.push(3);
+    expect(deque.toArray()).toEqual([1, 2, 3]);
   });
 
-  it('should remove elements from the front of the deque', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-
-    const removedElement = deque.popFirst();
-
-    expect(deque.size).toBe(1);
-    expect(removedElement).toBe(1);
-    expect(deque.getFirst()).toBe(2);
+  test('clears the deque', () => {
+    deque.push(1);
+    deque.push(2);
+    deque.clear();
+    expect(deque.isEmpty()).toBe(true);
   });
 
-  it('should remove elements from the end of the deque', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-
-    const removedElement = deque.popFirst();
-
-    expect(deque.size).toBe(1);
-    expect(removedElement).toBe(1);
-    expect(deque.getLast()).toBe(2);
+  test('inserts and deletes at specific index', () => {
+    deque.push(1);
+    deque.push(3);
+    deque.insertAt(1, 2);
+    expect(deque.toArray()).toEqual([1, 2, 3]);
+    expect(deque.deleteAt(1)).toBe(2);
+    expect(deque.toArray()).toEqual([1, 3]);
   });
 
-  it('should return the element at the front of the deque without removing it', () => {
-    deque.addFirst(1);
-    deque.addFirst(2);
-
-    expect(deque.getFirst()).toBe(2);
-    expect(deque.size).toBe(2);
+  test('finds elements with a callback', () => {
+    deque.push(1);
+    deque.push(2);
+    deque.push(3);
+    expect(deque.find(el => el > 1)).toBe(2);
   });
 
-  it('should return the element at the end of the deque without removing it', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-
-    expect(deque.getLast()).toBe(2);
-    expect(deque.size).toBe(2);
+  test('performs forEach operation', () => {
+    deque.push(1);
+    deque.push(2);
+    let sum = 0;
+    deque.forEach(el => {
+      sum += el;
+    });
+    expect(sum).toBe(3);
   });
 
-  it('should return the correct size of the deque', () => {
-    deque.addFirst(1);
-    deque.addLast(2);
-    deque.addLast(3);
-
-    expect(deque.size).toBe(3);
+  test('maps to a new deque', () => {
+    deque.push(1);
+    deque.push(2);
+    const newDeque = deque.map(el => el * el);
+    expect(newDeque.toArray()).toEqual([1, 4]);
   });
 
-  it('should check if the deque is empty', () => {
-    expect(deque.isEmpty()).toBe(true);
-
-    deque.addFirst(1);
-
-    expect(deque.isEmpty()).toBe(false);
+  test('filters elements', () => {
+    deque.push(1);
+    deque.push(2);
+    deque.push(3);
+    const newDeque = deque.filter(el => el % 2 === 0);
+    expect(newDeque.toArray()).toEqual([2]);
   });
 
-  it('should set elements at a specific index', () => {
-    deque.addFirst(1);
-    deque.addLast(2);
-    deque.addLast(3);
+  test('reduces elements', () => {
+    deque.push(1);
+    deque.push(2);
+    deque.push(3);
+    const sum = deque.reduce((acc, el) => acc + el, 0);
+    expect(sum).toBe(6);
+  });
 
-    expect(deque.getFirst()).toBe(1);
-    expect(deque.get(1)).toBe(2);
-    expect(deque.getLast()).toBe(3);
+  test('reverses elements', () => {
+    deque.push(1);
+    deque.push(2);
+    deque.push(3);
+    deque.reverse();
+    expect(deque.toArray()).toEqual([3, 2, 1]);
   });
 
-  it('should insert elements at a specific index', () => {
-    deque.addFirst(1);
-    deque.addLast(2);
-    deque.addLast(3);
+  test('gets element at a specific index', () => {
+    deque.push(1);
+    deque.push(2);
+    deque.push(3);
+    expect(deque.getAt(1)).toBe(2);
+    // expect(deque.getAt(5)).toThrow();
+  });
 
-    expect(deque.size).toBe(3);
-    expect(deque.getFirst()).toBe(1);
-    expect(deque.get(1)).toBe(2);
-    expect(deque.get(2)).toBe(3);
-    expect(deque.getLast()).toBe(3);
+  test('finds the index of an element', () => {
+    deque.push(1);
+    deque.push(2);
+    deque.push(3);
+    expect(deque.indexOf(2)).toBe(1);
+    expect(deque.indexOf(4)).toBe(-1);
   });
 });