data-structure-typed 1.41.4 → 1.41.6

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

@@ -1,410 +0,0 @@
-import {ArrayDeque, Deque, ObjectDeque} from '../../../../src';
-import {bigO} from '../../../utils';
-import {isDebugTest} from '../../../config';
-
-const isDebug = isDebugTest;
-describe('Deque Tests', () => {
-  // Test cases for the Deque class (DoublyLinkedList-based)
-  describe('Deque (DoublyLinkedList-based)', () => {
-    let deque: Deque<number>;
-
-    beforeEach(() => {
-      deque = new Deque<number>();
-    });
-
-    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);
-    });
-
-    it('should delete elements from the beginning and end', () => {
-      deque.addFirst(1);
-      deque.addLast(2);
-      deque.popFirst();
-      deque.popLast();
-      expect(deque.isEmpty()).toBe(true);
-    });
-
-    it('should handle edge case when removing from an empty deque', () => {
-      const result = deque.popFirst();
-      expect(result).toBeUndefined();
-    });
-
-    it('should correctly report its size', () => {
-      deque.addFirst(1);
-      deque.addLast(2);
-      expect(deque.size).toBe(2);
-    });
-
-    it('should handle adding and removing elements alternately', () => {
-      deque.addFirst(1);
-      expect(deque.popFirst()).toBe(1);
-      deque.addLast(2);
-      expect(deque.popLast()).toBe(2);
-      expect(deque.isEmpty()).toBe(true);
-    });
-
-    it('should handle adding and removing elements in a cyclic manner', () => {
-      deque.addFirst(1);
-      deque.addLast(2);
-      expect(deque.popFirst()).toBe(1);
-      deque.addFirst(3);
-      expect(deque.popLast()).toBe(2);
-      expect(deque.size).toBe(1);
-    });
-    // 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
-  });
-});
-
-describe('Deque Performance Test', () => {
-  const dataSize = 10000;
-  it('should numeric queue be efficient', function () {
-    const startTime = performance.now();
-    const queue = new Deque<number>();
-    for (let i = 0; i < dataSize; i++) {
-      queue.unshift(i);
-    }
-    for (let i = 0; i < dataSize; i++) {
-      queue.pop();
-    }
-    isDebug && console.log(`Queue Deque Test: ${performance.now() - startTime} ms`);
-    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
-  });
-});
-
-describe('Deque', () => {
-  let deque: Deque<number>;
-
-  beforeEach(() => {
-    deque = new Deque<number>();
-  });
-
-  test('should initialize an empty deque', () => {
-    expect(deque.size).toBe(0);
-    expect(deque.isEmpty()).toBe(true);
-  });
-
-  test('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);
-  });
-
-  test('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);
-  });
-
-  test('should get elements by index', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-    deque.addLast(3);
-
-    expect(deque.getAt(0)).toBe(1);
-    expect(deque.getAt(1)).toBe(2);
-    expect(deque.getAt(2)).toBe(3);
-  });
-
-  test('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);
-  });
-
-  test('should check if the deque is empty', () => {
-    expect(deque.isEmpty()).toBe(true);
-
-    deque.addLast(1);
-    expect(deque.isEmpty()).toBe(false);
-
-    deque.popFirst();
-    expect(deque.isEmpty()).toBe(true);
-  });
-});
-
-describe('ArrayDeque', () => {
-  let deque: ArrayDeque<number>;
-
-  beforeEach(() => {
-    deque = new ArrayDeque<number>();
-  });
-
-  test('should initialize an empty deque', () => {
-    expect(deque.size).toBe(0);
-    expect(deque.isEmpty()).toBe(true);
-  });
-
-  test('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);
-  });
-
-  test('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);
-  });
-
-  test('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);
-  });
-
-  test('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);
-  });
-
-  test('should check if the deque is empty', () => {
-    expect(deque.isEmpty()).toBe(true);
-
-    deque.addLast(1);
-    expect(deque.isEmpty()).toBe(false);
-
-    deque.popFirst();
-    expect(deque.isEmpty()).toBe(true);
-  });
-
-  test('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('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('should delete elements at a specific index', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-    deque.addLast(3);
-
-    const deletedElement = deque.delete(1);
-
-    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('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('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('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('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('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('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('should return the correct size of the deque', () => {
-    deque.addFirst(1);
-    deque.addLast(2);
-    deque.addLast(3);
-
-    expect(deque.size).toBe(3);
-  });
-
-  test('should check if the deque is empty', () => {
-    expect(deque.isEmpty()).toBe(true);
-
-    deque.addFirst(1);
-
-    expect(deque.isEmpty()).toBe(false);
-  });
-
-  test('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);
-  });
-
-  test('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);
-  });
-});

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

@@ -1,207 +0,0 @@
-import {LinkedListQueue, Queue} from '../../../../src';
-import {bigO} from '../../../utils';
-import {isDebugTest} from '../../../config';
-
-const isDebug = isDebugTest;
-describe('Queue Operation Test', () => {
-  it('should validate a queue', () => {
-    const queue = new Queue<number>();
-    for (let i = 0; i < 1000; i++) {
-      queue.enqueue(i);
-    }
-    let last: number | undefined = 0;
-    for (let i = 0; i < 1000; i++) {
-      last = queue.dequeue();
-    }
-    expect(last).toBe(999);
-  });
-});
-
-describe('Queue', () => {
-  let queue: Queue<number>;
-
-  beforeEach(() => {
-    queue = new Queue<number>();
-  });
-
-  it('should initialize an empty queue', () => {
-    expect(queue.size).toBe(0);
-  });
-
-  it('should push elements to the end of the queue', () => {
-    queue.push(1);
-    queue.push(2);
-    expect(queue.peek()).toBe(1);
-    expect(queue.size).toBe(2);
-  });
-});
-
-describe('Queue', () => {
-  let queue: Queue<number>;
-
-  beforeEach(() => {
-    queue = new Queue<number>();
-  });
-
-  it('should initialize an empty queue', () => {
-    expect(queue.size).toBe(0);
-    expect(queue.isEmpty()).toBe(true);
-  });
-
-  it('should push elements to the end of the queue', () => {
-    queue.push(1);
-    queue.push(2);
-    expect(queue.size).toBe(2);
-    expect(queue.peek()).toBe(1);
-    expect(queue.getLast()).toBe(2);
-  });
-
-  it('should shift elements from the front of the queue', () => {
-    queue.push(1);
-    queue.push(2);
-    const shifted = queue.shift();
-    expect(shifted).toBe(1);
-    expect(queue.size).toBe(1);
-    expect(queue.peek()).toBe(2);
-    expect(queue.getLast()).toBe(2);
-  });
-
-  it('should handle shifting when queue reaches half size', () => {
-    for (let i = 1; i <= 5; i++) {
-      queue.push(i);
-    }
-    for (let i = 1; i <= 3; i++) {
-      queue.shift();
-    }
-    // Queue size should be 2, but internal array size is still 5.
-    // Test that shifting optimizes the internal array.
-    expect(queue.size).toBe(2);
-    expect(queue.nodes.length).toBe(2);
-    expect(queue.peek()).toBe(4);
-  });
-
-  it('should peek at the front and end of the queue', () => {
-    queue.push(1);
-    queue.push(2);
-    expect(queue.peek()).toBe(1);
-    expect(queue.getLast()).toBe(2);
-  });
-
-  it('should handle shifting when the queue is empty', () => {
-    const shifted = queue.shift();
-    expect(shifted).toBeUndefined();
-    expect(queue.size).toBe(0);
-    expect(queue.peek()).toBeUndefined();
-  });
-
-  it('should handle peeking when the queue is empty', () => {
-    expect(queue.peek()).toBeUndefined();
-    expect(queue.getLast()).toBeUndefined();
-  });
-
-  it('should handle clearing the queue', () => {
-    for (let i = 1; i <= 3; i++) {
-      queue.push(i);
-    }
-    queue.clear();
-    expect(queue.size).toBe(0);
-    expect(queue.peek()).toBeUndefined();
-    expect(queue.getLast()).toBeUndefined();
-  });
-
-  it('should clone the queue', () => {
-    for (let i = 1; i <= 3; i++) {
-      queue.push(i);
-    }
-    const clonedQueue = queue.clone();
-    expect(clonedQueue.size).toBe(3);
-    expect(clonedQueue.peek()).toBe(1);
-    expect(clonedQueue.getLast()).toBe(3);
-  });
-
-  it('should handle creating a queue from an array', () => {
-    const elements = [1, 2, 3, 4, 5];
-    const newQueue = Queue.fromArray(elements);
-    expect(newQueue.size).toBe(5);
-    expect(newQueue.peek()).toBe(1);
-    expect(newQueue.getLast()).toBe(5);
-  });
-
-  it('should iterate through the queue', () => {
-    for (let i = 1; i <= 3; i++) {
-      queue.push(i);
-    }
-    const values = Array.from(queue);
-    expect(values).toEqual([1, 2, 3]);
-  });
-});
-describe('LinkedListQueue', () => {
-  let queue: LinkedListQueue<string>;
-
-  beforeEach(() => {
-    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');
-    expect(queue.length).toBe(2);
-  });
-
-  it('should dequeue elements from the front of the queue', () => {
-    queue.enqueue('A');
-    queue.enqueue('B');
-    const dequeued = queue.dequeue();
-    expect(dequeued).toBe('A');
-    expect(queue.peek()).toBe('B');
-    expect(queue.length).toBe(1);
-  });
-
-  it('should peek at the front of the queue', () => {
-    queue.enqueue('A');
-    queue.enqueue('B');
-    expect(queue.peek()).toBe('A');
-  });
-});
-
-describe('Queue Performance Test', () => {
-  const dataSize = 10000;
-  it('should numeric queue be efficient', function () {
-    const startTime = performance.now();
-    const queue = new Queue<number>();
-    for (let i = 0; i < dataSize; i++) {
-      queue.enqueue(i);
-    }
-    for (let i = 0; i < dataSize; i++) {
-      queue.dequeue();
-    }
-    isDebug && console.log(`Queue Performance Test: ${performance.now() - startTime} ms`);
-    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
-  });
-
-  it('should numeric Array be more efficient than Queue when the data size is 10000', function () {
-    const startTime2 = performance.now();
-    const queue2: number[] = [];
-    for (let i = 0; i < dataSize; i++) {
-      queue2.push(i);
-    }
-    for (let i = 0; i < dataSize; i++) {
-      queue2.shift();
-    }
-    expect(performance.now() - startTime2).toBeLessThan(bigO.CUBED * 100);
-  });
-
-  it('should numeric LinkedListQueue be efficient', function () {
-    const startTime = performance.now();
-    const queue = new LinkedListQueue<number>();
-    for (let i = 0; i < dataSize; i++) {
-      queue.enqueue(i);
-    }
-    for (let i = 0; i < dataSize; i++) {
-      queue.dequeue();
-    }
-    // console.log(`LinkedListQueue Performance Test: ${performance.now() - startTime} ms`);
-    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
-  });
-});

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

@@ -1,67 +0,0 @@
-import {Stack} from '../../../../src';
-
-describe('Stack', () => {
-  let stack: Stack<number>;
-
-  beforeEach(() => {
-    stack = new Stack<number>();
-  });
-
-  it('should be empty when initialized', () => {
-    expect(stack.isEmpty()).toBe(true);
-  });
-
-  it('should push elements onto the stack', () => {
-    stack.push(1);
-    stack.push(2);
-    stack.push(3);
-    expect(stack.size()).toBe(3);
-  });
-
-  it('should peek at the top element without removing it', () => {
-    stack.push(1);
-    stack.push(2);
-    stack.push(3);
-    expect(stack.peek()).toBe(3);
-    expect(stack.size()).toBe(3);
-  });
-
-  it('should pop elements from the stack', () => {
-    stack.push(1);
-    stack.push(2);
-    stack.push(3);
-    const poppedElement = stack.pop();
-    expect(poppedElement).toBe(3);
-    expect(stack.size()).toBe(2);
-  });
-
-  it('should return null when popping from an empty stack', () => {
-    const poppedElement = stack.pop();
-    expect(poppedElement).toBeNull();
-  });
-
-  it('should convert the stack to an array', () => {
-    stack.push(1);
-    stack.push(2);
-    stack.push(3);
-    const stackArray = stack.toArray();
-    expect(stackArray).toEqual([1, 2, 3]);
-  });
-
-  it('should clear all elements from the stack', () => {
-    stack.push(1);
-    stack.push(2);
-    stack.push(3);
-    stack.clear();
-    expect(stack.size()).toBe(0);
-    expect(stack.isEmpty()).toBe(true);
-  });
-
-  it('should clone the stack', () => {
-    stack.push(1);
-    stack.push(2);
-    const clonedStack = stack.clone();
-    expect(clonedStack.size()).toBe(2);
-    expect(clonedStack.pop()).toBe(2);
-  });
-});