data-structure-typed 2.4.0 → 2.4.2

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

@@ -1,703 +0,0 @@
-import { LinkedListQueue, Queue } from '../../../../src';
-// import { isDebugTest } from '../../../config';
-
-// const isDebug = isDebugTest;
-
-describe('Queue', () => {
-  let queue: Queue<number>;
-
-  beforeEach(() => {
-    queue = new Queue<number>();
-  });
-
-  it('new Queue() should create an empty queue', () => {
-    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.length).toBe(2);
-  });
-
-  it('shift should remove the first element', () => {
-    queue.push(1);
-    queue.push(2);
-    expect(queue.shift()).toBe(1);
-    expect(queue.length).toBe(1);
-  });
-
-  it('shift should return undefined if queue is empty', () => {
-    expect(queue.shift()).toBeUndefined();
-  });
-
-  it('first should return the first element without removing it', () => {
-    queue.push(1);
-    queue.push(2);
-    expect(queue.first).toBe(1);
-    expect(queue.length).toBe(2);
-  });
-
-  it('first should return undefined if queue is empty', () => {
-    expect(queue.first).toBeUndefined();
-  });
-
-  it('length should return the number of elements', () => {
-    queue.push(1);
-    queue.push(2);
-    expect(queue.length).toBe(2);
-  });
-
-  it('isEmpty should return true if the queue is empty', () => {
-    expect(queue.isEmpty()).toBeTruthy();
-  });
-
-  it('isEmpty should return false if the queue is not empty', () => {
-    queue.push(1);
-    expect(queue.isEmpty()).toBeFalsy();
-  });
-
-  it('toArray should return an array of queue elements', () => {
-    queue.push(1);
-    queue.push(2);
-    expect(queue.toArray()).toEqual([1, 2]);
-  });
-
-  it('clear should remove all elements from the queue', () => {
-    queue.push(1);
-    queue.push(2);
-    queue.clear();
-    expect(queue.length).toBe(0);
-  });
-
-  it('forEach should iterate over all elements', () => {
-    const arr: number[] = [];
-    queue.push(1);
-    queue.push(2);
-    queue.forEach(element => arr.push(element));
-    expect(arr).toEqual([1, 2]);
-  });
-
-  // Boundary value testing
-  it('push and shift with many elements', () => {
-    for (let i = 0; i < 1000; i++) {
-      queue.push(i);
-    }
-    for (let i = 0; i < 1000; i++) {
-      expect(queue.shift()).toBe(i);
-    }
-    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);
-
-    for (let i = 0; i < 499; i++) queue.shift();
-
-    expect(queue.elements.length).toBe(1000);
-    queue.compact();
-    expect(queue.elements.length).toBe(501);
-  });
-
-  it('should at after shifting', () => {
-    for (let i = 0; i < 100; i++) {
-      queue.push(i);
-    }
-
-    for (let i = 0; i < 10; i++) {
-      expect(queue.shift()).toBe(i);
-    }
-
-    for (let i = 0; i < 90; i++) {
-      expect(queue.at(i)).toBe(i + 10);
-    }
-  });
-
-  it('should toElementFn', () => {
-    const queue = new Queue<string, { id: string }>([{ id: '1' }, { id: '5' }, { id: '3' }, { id: '4' }, { id: '2' }], {
-      toElementFn: rawElement => rawElement.id
-    });
-
-    expect(queue.length).toBe(5);
-    queue.shift();
-    expect(queue.length).toBe(4);
-    expect(queue.at(1)).toBe('3');
-  });
-
-  it('should object queue map & filter', function () {
-    const queue = new Queue<{
-      a: string;
-      key: number;
-    }>([
-      { key: 1, a: 'a1' },
-      { key: 6, a: 'a6' },
-      { key: 5, a: 'a5' },
-      { key: 3, a: 'a3' },
-      { key: 2, a: 'a2' },
-      { key: 4, a: 'a4' },
-      { key: 0, a: 'a0' }
-    ]);
-
-    const mappedQueue = queue.map(item => item.key);
-    expect(mappedQueue.at(0)).toBe(1);
-    expect([...mappedQueue]).toEqual([1, 6, 5, 3, 2, 4, 0]);
-
-    const mappedToElementFnQueue = queue.map<string, { id: string }>(item => item.key.toString(), {
-      toElementFn: rawElement => rawElement.id
-    });
-    expect(mappedToElementFnQueue.at(0)).toBe('1');
-    expect([...mappedToElementFnQueue]).toEqual(['1', '6', '5', '3', '2', '4', '0']);
-
-    const filteredQueue = queue.filter(item => item.key > 3);
-    expect(filteredQueue.at(0)).toEqual({ a: 'a6', key: 6 });
-    expect([...filteredQueue]).toEqual([
-      { a: 'a6', key: 6 },
-      { a: 'a5', key: 5 },
-      { a: 'a4', key: 4 }
-    ]);
-  });
-
-  it('should clone', function () {
-    const queue = new Queue<string>();
-    queue.push('1');
-    queue.push('6');
-    queue.push('2');
-    queue.push('0');
-    queue.push('5');
-    queue.push('9');
-    queue.delete('2');
-    expect([...queue]).toEqual(['1', '6', '0', '5', '9']);
-    const cloned = queue.clone();
-    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
-    queue.delete('5');
-    expect([...queue]).toEqual(['1', '6', '0', '9']);
-    queue.deleteAt(2);
-    expect([...queue]).toEqual(['1', '6', '9']);
-    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
-  });
-
-  it('should set autoCompactRatio', function () {
-    const queue = new Queue<number>();
-
-    queue.autoCompactRatio = 0.3;
-    queue.push(1);
-    queue.push(2);
-    queue.push(3);
-    queue.push(4);
-    queue.push(5);
-    queue.push(6);
-    queue.push(7);
-    queue.push(8);
-    queue.push(9);
-    queue.push(10);
-    expect(queue.elements.length).toBe(10);
-    while (queue.length > 7) queue.shift();
-    expect(queue.length).toBe(7);
-    expect(queue.elements.length).toBe(10);
-    queue.shift();
-    expect(queue.length).toBe(6);
-    expect(queue.elements.length).toBe(6);
-  });
-});
-
-describe('Queue - Advanced Methods', () => {
-  let queue: Queue<number>;
-
-  beforeEach(() => {
-    queue = new Queue<number>();
-  });
-
-  it('reduce should apply a function against an accumulator and each element', () => {
-    queue.push(1);
-    queue.push(2);
-    queue.push(3);
-    const sum = queue.reduce((acc, val) => acc + val, 0);
-    expect(sum).toBe(6);
-  });
-
-  it('reduce should return initial value for empty queue', () => {
-    const initialValue = 0;
-    const sum = queue.reduce((acc, val) => acc + val, initialValue);
-    expect(sum).toBe(initialValue);
-  });
-
-  it('filter should return a new queue with all elements that pass the test implemented by provided function', () => {
-    queue.push(1);
-    queue.push(2);
-    queue.push(3);
-    const filteredQueue = queue.filter(val => val > 1);
-    expect(filteredQueue.toArray()).toEqual([2, 3]);
-  });
-
-  it('filter should return an empty queue for empty queue', () => {
-    const filteredQueue = queue.filter(val => val > 1);
-    expect(filteredQueue.isEmpty()).toBeTruthy();
-  });
-
-  it('map should create a new queue with the results of calling a provided function on every element', () => {
-    queue.push(1);
-    queue.push(2);
-    queue.push(3);
-    const mappedQueue = queue.map(val => val * 2);
-    expect(mappedQueue.toArray()).toEqual([2, 4, 6]);
-  });
-
-  it('map should return an empty queue for empty queue', () => {
-    const mappedQueue = queue.map(val => val * 2);
-    expect(mappedQueue.isEmpty()).toBeTruthy();
-  });
-});
-describe('Queue - Additional Methods', () => {
-  let queue: Queue<number>;
-
-  beforeEach(() => {
-    queue = new Queue<number>();
-  });
-
-  it('peekLast should return the last element without removing it', () => {
-    queue.push(1);
-    queue.push(2);
-    expect(queue.last).toBe(2);
-    expect(queue.length).toBe(2);
-  });
-
-  it('peekLast should return undefined if queue is empty', () => {
-    expect(queue.last).toBeUndefined();
-  });
-
-  it('at should return the element at the specified index', () => {
-    queue.push(1);
-    queue.push(2);
-    queue.push(3);
-    expect(queue.at(1)).toBe(2);
-  });
-
-  it('at should return undefined for an invalid index', () => {
-    queue.push(1);
-    expect(queue.at(3)).toBeUndefined();
-    expect(queue.at(-1)).toBeUndefined();
-  });
-
-  it('print should not throw any errors', () => {
-    expect(() => {
-      queue.push(1);
-      // queue.print();
-    }).not.toThrow();
-  });
-});
-
-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.length).toBe(array.length);
-  });
-
-  it('fromArray should create an empty queue from an empty array', () => {
-    const queue = Queue.fromArray([]);
-    expect(queue.isEmpty()).toBeTruthy();
-  });
-
-  it('clone should create a new queue with the same elements', () => {
-    const originalQueue = new Queue<number>();
-    originalQueue.push(1);
-    originalQueue.push(2);
-
-    const clonedQueue = originalQueue.clone();
-    expect(clonedQueue.toArray()).toEqual(originalQueue.toArray());
-    expect(clonedQueue.length).toBe(originalQueue.length);
-  });
-
-  it('clone should not affect the original queue when mutated', () => {
-    const originalQueue = new Queue<number>();
-    originalQueue.push(1);
-    originalQueue.push(2);
-
-    const clonedQueue = originalQueue.clone();
-    clonedQueue.push(3);
-
-    expect(clonedQueue.length).not.toBe(originalQueue.length);
-    expect(originalQueue.toArray()).not.toContain(3);
-  });
-});
-
-describe('LinkedListQueue', () => {
-  let queue: LinkedListQueue<string>;
-
-  beforeEach(() => {
-    queue = new LinkedListQueue<string>();
-    queue.push('A');
-    queue.push('B');
-  });
-
-  it('should push elements to the end of the queue', () => {
-    expect(queue.first).toBe('A');
-    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.length).toBe(1);
-  });
-
-  it('should peek at the front of the queue', () => {
-    expect(queue.first).toBe('A');
-  });
-
-  it('should clone method work correctly', () => {
-    const cloned = queue.clone();
-    expect(cloned instanceof LinkedListQueue).toBe(true);
-    expect(cloned.length).toBe(2);
-  });
-});
-
-describe('Queue', () => {
-  // Test queue initialization
-  it('should initialize correctly with no elements', () => {
-    const queue = new Queue();
-    expect(queue.isEmpty()).toBe(true);
-    expect(queue.length).toBe(0);
-    expect(queue.first).toBeUndefined();
-    expect(queue.last).toBeUndefined();
-  });
-
-  it('should initialize correctly with given elements', () => {
-    const queue = new Queue([1, 2, 3]);
-    expect(queue.length).toBe(3);
-    expect(queue.first).toBe(1);
-    expect(queue.last).toBe(3);
-  });
-
-  // Test push and pushMany
-  it('should add elements to the queue', () => {
-    const queue = new Queue<number>();
-    queue.push(1);
-    queue.push(2);
-    expect(queue.length).toBe(2);
-    expect(queue.first).toBe(1);
-    expect(queue.last).toBe(2);
-  });
-
-  it('should add multiple elements using pushMany', () => {
-    const queue = new Queue<number>();
-    queue.pushMany([1, 2, 3]);
-    expect(queue.length).toBe(3);
-    expect(queue.elements).toEqual([1, 2, 3]);
-  });
-
-  // Test shift
-  it('should remove the first element from the queue', () => {
-    const queue = new Queue([1, 2, 3]);
-    const shifted = queue.shift();
-    expect(shifted).toBe(1);
-    expect(queue.length).toBe(2);
-    expect(queue.first).toBe(2);
-  });
-
-  // Test delete and deleteAt
-  it('should delete an element from the queue', () => {
-    const queue = new Queue([1, 2, 3]);
-    const result = queue.delete(2);
-    expect(result).toBe(true);
-    expect(queue.elements).toEqual([1, 3]);
-  });
-
-  it('should delete an element at a specific index', () => {
-    const queue = new Queue([1, 2, 3]);
-    const deleted = queue.deleteAt(1);
-    expect(deleted).toBe(2);
-    expect(queue.elements).toEqual([1, 3]);
-  });
-
-  // Test at
-  it('should retrieve an element by index', () => {
-    const queue = new Queue([1, 2, 3]);
-    expect(queue.at(0)).toBe(1);
-    expect(queue.at(2)).toBe(3);
-  });
-
-  // Test reverse
-  it('should reverse the queue', () => {
-    const queue = new Queue([1, 2, 3]);
-    queue.reverse();
-    expect(queue.elements).toEqual([3, 2, 1]);
-    expect(queue.first).toBe(3);
-    expect(queue.last).toBe(1);
-  });
-
-  // Test addAt
-  it('should add an element at a specific index', () => {
-    const queue = new Queue([1, 3]);
-    const result = queue.addAt(1, 2);
-    expect(result).toBe(true);
-    expect(queue.elements).toEqual([1, 2, 3]);
-  });
-
-  // Test setAt
-  it('should set an element at a specific index', () => {
-    const queue = new Queue([1, 2, 3]);
-    const result = queue.setAt(1, 10);
-    expect(result).toBe(true);
-    expect(queue.elements).toEqual([1, 10, 3]);
-  });
-
-  // Test clear
-  it('should clear the queue', () => {
-    const queue = new Queue([1, 2, 3]);
-    queue.clear();
-    expect(queue.isEmpty()).toBe(true);
-    expect(queue.length).toBe(0);
-  });
-
-  // Test compact
-  it('should compact the queue', () => {
-    const queue = new Queue([1, 2, 3]);
-    queue.shift();
-    queue.shift();
-    queue.compact();
-    expect(queue.elements).toEqual([3]);
-  });
-
-  // Test splice
-  it('should splice elements from the queue', () => {
-    const queue = new Queue([1, 2, 3, 4]);
-    const removed = queue.splice(1, 2);
-    expect(removed.elements).toEqual([2, 3]);
-    expect(queue.elements).toEqual([1, 4]);
-  });
-
-  // Test clone
-  it('should create a clone of the queue', () => {
-    const queue = new Queue([1, 2, 3]);
-    const clone = queue.clone();
-    expect(clone.elements).toEqual(queue.elements);
-    clone.push(4);
-    expect(queue.elements).not.toContain(4);
-  });
-
-  // Test filter
-  it('should filter elements based on a predicate', () => {
-    const queue = new Queue([1, 2, 3, 4]);
-    const filtered = queue.filter(el => el % 2 === 0);
-    expect(filtered.elements).toEqual([2, 4]);
-  });
-
-  // Test map
-  it('should map elements to a new queue', () => {
-    const queue = new Queue([1, 2, 3]);
-    const mapped = queue.map(el => el * 2);
-    expect(mapped.elements).toEqual([2, 4, 6]);
-  });
-});
-
-describe('classic uses', () => {
-  it('@example basic Queue creation and push operation', () => {
-    // Create a simple Queue with initial values
-    const queue = new Queue([1, 2, 3, 4, 5]);
-
-    // Verify the queue maintains insertion order
-    expect([...queue]).toEqual([1, 2, 3, 4, 5]);
-
-    // Check length
-    expect(queue.length).toBe(5);
-  });
-
-  it('@example Queue shift and peek operations', () => {
-    const queue = new Queue<number>([10, 20, 30, 40]);
-
-    // Peek at the front element without removing it
-    expect(queue.first).toBe(10);
-
-    // Remove and get the first element (FIFO)
-    const first = queue.shift();
-    expect(first).toBe(10);
-
-    // Verify remaining elements and length decreased
-    expect([...queue]).toEqual([20, 30, 40]);
-    expect(queue.length).toBe(3);
-  });
-
-  it('@example Queue for...of iteration and isEmpty check', () => {
-    const queue = new Queue<string>(['A', 'B', 'C', 'D']);
-
-    const elements: string[] = [];
-    for (const item of queue) {
-      elements.push(item);
-    }
-
-    // Verify all elements are iterated in order
-    expect(elements).toEqual(['A', 'B', 'C', 'D']);
-
-    // Process all elements
-    while (queue.length > 0) {
-      queue.shift();
-    }
-
-    expect(queue.length).toBe(0);
-  });
-
-  it('@example Queue as message broker for event processing', () => {
-    interface Message {
-      id: string;
-      type: 'email' | 'sms' | 'push';
-      recipient: string;
-      content: string;
-      timestamp: Date;
-    }
-
-    // Create a message queue for real-time event processing
-    const messageQueue = new Queue<Message>([
-      {
-        id: 'msg-001',
-        type: 'email',
-        recipient: 'user@example.com',
-        content: 'Welcome!',
-        timestamp: new Date()
-      },
-      {
-        id: 'msg-002',
-        type: 'sms',
-        recipient: '+1234567890',
-        content: 'OTP: 123456',
-        timestamp: new Date()
-      },
-      {
-        id: 'msg-003',
-        type: 'push',
-        recipient: 'device-token-xyz',
-        content: 'New notification',
-        timestamp: new Date()
-      },
-      {
-        id: 'msg-004',
-        type: 'email',
-        recipient: 'admin@example.com',
-        content: 'Daily report',
-        timestamp: new Date()
-      }
-    ]);
-
-    // Process messages in FIFO order (first message first)
-    const processedMessages: string[] = [];
-    while (messageQueue.length > 0) {
-      const message = messageQueue.shift();
-      if (message) {
-        processedMessages.push(`${message.type}:${message.recipient}`);
-      }
-    }
-
-    // Verify messages were processed in order
-    expect(processedMessages).toEqual([
-      'email:user@example.com',
-      'sms:+1234567890',
-      'push:device-token-xyz',
-      'email:admin@example.com'
-    ]);
-
-    // Queue should be empty after processing all messages
-    expect(messageQueue.length).toBe(0);
-  });
-});