data-structure-typed 1.48.0 → 1.48.2

package/test/unit/data-structures/hash/hash-map.test.ts

@@ -1,13 +1,287 @@
-import { HashMap } from '../../../../src';
+import { HashMap, LinkedHashMap } from '../../../../src';
 import { getRandomInt, getRandomIntArray } from '../../../utils';
 
-describe('HashMap', () => {
+describe('HashMap Test1', () => {
   let hashMap: HashMap<string, number>;
 
   beforeEach(() => {
     hashMap = new HashMap<string, number>();
   });
 
+  it('should initialize correctly', () => {
+    expect(hashMap.size).toBe(0);
+    expect(hashMap.isEmpty()).toBe(true);
+  });
+
+  it('should put and get values', () => {
+    hashMap.set('one', 1);
+    hashMap.set('two', 2);
+    hashMap.set('three', 3);
+
+    expect(hashMap.get('one')).toBe(1);
+    expect(hashMap.get('two')).toBe(2);
+    expect(hashMap.get('three')).toBe(3);
+  });
+
+  it('should handle key collisions', () => {
+    // Force a collision by setting two different keys to the same bucket
+    hashMap.set('key1', 1);
+    hashMap.set('key2', 2);
+
+    expect(hashMap.get('key1')).toBe(1);
+    expect(hashMap.get('key2')).toBe(2);
+  });
+
+  it('should delete values', () => {
+    hashMap.set('one', 1);
+    hashMap.set('two', 2);
+
+    hashMap.delete('one');
+    expect(hashMap.get('one')).toBeUndefined();
+    expect(hashMap.size).toBe(1);
+  });
+
+  it('should clear the HashMap', () => {
+    hashMap.set('one', 1);
+    hashMap.set('two', 2);
+
+    hashMap.clear();
+    expect(hashMap.size).toBe(0);
+    expect(hashMap.isEmpty()).toBe(true);
+  });
+
+  it('should iterate over entries', () => {
+    hashMap.set('one', 1);
+    hashMap.set('two', 2);
+    hashMap.set('three', 3);
+
+  });
+
+  it('should resize the table when load factor is exceeded', () => {
+    // Set a small initial capacity for testing resizing
+    hashMap = new HashMap<string, number>();
+
+    hashMap.set('one', 1);
+    hashMap.set('two', 2);
+    hashMap.set('three', 3);
+    hashMap.set('four', 4); // This should trigger a resize
+
+    // expect(hashMap.table.length).toBe(8);
+    expect(hashMap.get('one')).toBe(1);
+    expect(hashMap.get('two')).toBe(2);
+    expect(hashMap.get('three')).toBe(3);
+    expect(hashMap.get('four')).toBe(4);
+  });
+
+  it('should allow using a custom hash function', () => {
+    hashMap = new HashMap<string, number>();
+
+    hashMap.set('one', 1);
+    hashMap.set('two', 2);
+
+    expect(hashMap.get('one')).toBe(1);
+    expect(hashMap.get('two')).toBe(2);
+    // Since the custom hash function always returns 0, these keys will collide.
+    // Make sure they are stored separately.
+    // expect(hashMap.table[0].length).toBe(2);
+  });
+});
+
+describe('HashMap Test2', () => {
+  let hashMap: HashMap;
+
+  beforeEach(() => {
+    hashMap = new HashMap();
+  });
+
+  it('should create an empty map', () => {
+    expect(hashMap.size).toBe(0);
+  });
+
+  it('should add a key-value pair', () => {
+    hashMap.set('key1', 'value1');
+    expect(hashMap.get('key1')).toBe('value1');
+  });
+
+  it('should handle object keys correctly', () => {
+    const keyObj = { id: 1 };
+    hashMap.set(keyObj, 'objectValue');
+    expect(hashMap.get(keyObj)).toBe('objectValue');
+  });
+
+  // it('should handle number keys correctly', () => {
+  //   hashMap.set(999, { a: '999Value' });
+  //   hashMap.set('999', {a: '999StrValue'})
+  //   expect(hashMap.get(999)).toEqual({ a: '999Value' });
+  //   expect(hashMap.get('999')).toEqual({ a: '999StrValue' });
+  // });
+
+  it('should update the value for an existing key', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.set('key1', 'newValue');
+    expect(hashMap.get('key1')).toBe('newValue');
+  });
+
+  it('should return undefined for a non-existent key', () => {
+    expect(hashMap.get('nonExistentKey')).toBeUndefined();
+  });
+
+  it('should remove a key-value pair', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.delete('key1');
+    expect(hashMap.get('key1')).toBeUndefined();
+  });
+
+  it('should clear the map', () => {
+    hashMap.set('key1', 'value1');
+    expect(hashMap.size).toBe(1);
+
+    hashMap.clear();
+    expect(hashMap.size).toBe(0);
+  });
+
+  it('should iterate over values', () => {
+    hashMap.set('key1', 'value1');
+    hashMap.set('key2', 'value2');
+    const values = [];
+    for (const value of hashMap) {
+      values.push(value);
+    }
+    expect(values).toEqual([
+      ['key1', 'value1'],
+      ['key2', 'value2']
+    ]);
+  });
+
+  function compareHashMaps(hashMap: HashMap<unknown, unknown>, stdMap: Map<unknown, unknown>) {
+    expect(hashMap.size).toEqual(stdMap.size);
+    stdMap.forEach((value, key) => {
+      expect(hashMap.get(key)).toEqual(value);
+    });
+  }
+
+  const stdMap: Map<unknown, unknown> = new Map();
+  const arr: number[] = getRandomIntArray(1000, 1, 10000);
+
+  it('delete test', () => {
+    for (const item of arr) {
+      stdMap.set(item, item);
+      hashMap.set(item, item);
+    }
+    for (const item of arr) {
+      if (Math.random() > 0.6) {
+        expect(hashMap.delete(item)).toEqual(stdMap.delete(item));
+      }
+    }
+    compareHashMaps(hashMap, stdMap);
+
+    for (let i = 0; i < 1000; ++i) {
+      const random = getRandomInt(0, 100);
+      expect(hashMap.delete(random)).toEqual(stdMap.delete(random));
+    }
+    compareHashMaps(hashMap, stdMap);
+  });
+
+});
+
+describe('HashMap for coordinate object keys', () => {
+  const hashMap: HashMap<[number, number], number> = new HashMap();
+  const codObjs: [number, number][] = [];
+
+  test('set elements in hash map', () => {
+    for (let i = 0; i < 1000; i++) {
+      const codObj: [number, number] = [getRandomInt(-10000, 10000), i];
+      codObjs.push(codObj);
+      hashMap.set(codObj, i);
+    }
+  });
+
+  test('get elements in hash map', () => {
+    for (let i = 0; i < 1000; i++) {
+      const codObj = codObjs[i];
+      if (codObj) {
+        expect(hashMap.get(codObj)).toBe(i);
+      }
+    }
+  });
+
+  test('delete elements in hash map', () => {
+    for (let i = 0; i < 1000; i++) {
+      if (i === 500) expect(hashMap.size).toBe(500)
+      const codObj = codObjs[i];
+      if (codObj) hashMap.delete(codObj);
+    }
+    expect(hashMap.size).toBe(0);
+  });
+
+});
+
+describe('HashMap setMany, keys, values', () => {
+  const hm: HashMap<number, number> = new HashMap<number, number>();
+
+  beforeEach(() => {
+    hm.clear()
+    hm.setMany([[2, 2], [3, 3], [4, 4], [5, 5]])
+    hm.setMany([[2, 2], [3, 3], [4, 4], [6, 6]])
+  })
+
+  test('keys', () => {
+    expect([...hm.keys()]).toEqual([2, 3, 4, 5, 6])
+  });
+
+  test('values', () => {
+    expect([...hm.values()]).toEqual([2, 3, 4, 5, 6])
+  });
+});
+
+describe('HashMap HOF', () => {
+  let hashMap: HashMap;
+
+  beforeEach(() => {
+    hashMap = new HashMap<string, string>();
+    hashMap.set('key1', 'value1');
+    hashMap.set('key2', 'value2');
+    hashMap.set('key3', 'value3');
+  });
+
+  test('every() returns true if all elements match the condition', () => {
+    expect(hashMap.every((value) => typeof value === 'string')).toBe(true);
+  });
+
+  test('some() returns true if any element matches the condition', () => {
+    expect(hashMap.some((value, key) => key === 'key1')).toBe(true);
+  });
+
+  test('forEach() should execute a function for each element', () => {
+    const mockCallback = jest.fn();
+    hashMap.forEach(mockCallback);
+    expect(mockCallback.mock.calls.length).toBe(3);
+  });
+
+  test('map() should transform each element', () => {
+    const newHashMap = hashMap.map((value) => value.toUpperCase());
+    expect(newHashMap.get('key1')).toBe('VALUE1');
+  });
+
+  test('filter() should remove elements that do not match the condition', () => {
+    const filteredHashMap = hashMap.filter((value, key) => key !== 'key1');
+    expect(filteredHashMap.has('key1')).toBe(false);
+  });
+
+  test('reduce() should accumulate values', () => {
+    const result = hashMap.reduce((acc, value) => acc + value, '');
+    expect(result).toBe('value1value2value3');
+  });
+});
+
+
+describe('LinkedHashMap Test1', () => {
+  let hashMap: LinkedHashMap<string, number>;
+
+  beforeEach(() => {
+    hashMap = new LinkedHashMap<string, number>();
+  });
+
   it('should initialize correctly', () => {
     expect(hashMap.size).toBe(0);
     // expect(hashMap.table.length).toBe(16);
@@ -45,7 +319,7 @@ describe('HashMap', () => {
     expect(hashMap.size).toBe(1);
   });
 
-  it('should clear the HashMap', () => {
+  it('should clear the LinkedHashMap', () => {
     hashMap.set('one', 1);
     hashMap.set('two', 2);
 
@@ -67,7 +341,7 @@ describe('HashMap', () => {
 
   it('should resize the table when load factor is exceeded', () => {
     // Set a small initial capacity for testing resizing
-    hashMap = new HashMap<string, number>();
+    hashMap = new LinkedHashMap<string, number>();
 
     hashMap.set('one', 1);
     hashMap.set('two', 2);
@@ -82,7 +356,7 @@ describe('HashMap', () => {
   });
 
   it('should allow using a custom hash function', () => {
-    hashMap = new HashMap<string, number>();
+    hashMap = new LinkedHashMap<string, number>();
 
     hashMap.set('one', 1);
     hashMap.set('two', 2);
@@ -93,13 +367,22 @@ describe('HashMap', () => {
     // Make sure they are stored separately.
     // expect(hashMap.table[0].length).toBe(2);
   });
+
+
+  // it('should handle number keys correctly', () => {
+  //   const hm = new LinkedHashMap();
+  //   hm.set(999, { a: '999Value' });
+  //   hm.set('999', {a: '999StrValue'})
+  //   expect(hm.get(999)).toEqual({ a: '999Value' });
+  //   expect(hm.get('999')).toEqual({ a: '999StrValue1' });
+  // });
 });
 
-describe('HashMap', () => {
-  let hashMap: HashMap;
+describe('LinkedHashMap Test2', () => {
+  let hashMap: LinkedHashMap;
 
   beforeEach(() => {
-    hashMap = new HashMap();
+    hashMap = new LinkedHashMap();
   });
 
   it('should create an empty map', () => {
@@ -159,14 +442,7 @@ describe('HashMap', () => {
     ]);
   });
 
-  // test('should delete element at specific index', () => {
-  //   hashMap.set('key1', 'value1');
-  //   hashMap.set('key2', 'value2');
-  //   hashMap.deleteAt(0);
-  //   expect(hashMap.get('key1')).toBeUndefined();
-  //   expect(hashMap.size).toBe(1);
-  // });
-  function compareHashMaps(hashMap: HashMap<unknown, unknown>, stdMap: Map<unknown, unknown>) {
+  function compareHashMaps(hashMap: LinkedHashMap<unknown, unknown>, stdMap: Map<unknown, unknown>) {
     expect(hashMap.size).toEqual(stdMap.size);
     let index = 0;
     stdMap.forEach((value, key) => {
@@ -230,8 +506,8 @@ describe('HashMap', () => {
   });
 });
 
-describe('HashMap for coordinate object keys', () => {
-  const hashMap: HashMap<[number, number], number> = new HashMap();
+describe('LinkedHashMap for coordinate object keys', () => {
+  const hashMap: LinkedHashMap<[number, number], number> = new LinkedHashMap();
   const codObjs: [number, number][] = [];
 
   test('set elements in hash map', () => {
@@ -261,3 +537,21 @@ describe('HashMap for coordinate object keys', () => {
   });
 
 });
+
+describe('LinkedHashMap setMany, keys, values', () => {
+  const hm: LinkedHashMap<number, number> = new LinkedHashMap<number, number>();
+
+  beforeEach(() => {
+    hm.clear()
+    hm.setMany([[2, 2], [3, 3], [4, 4], [5, 5]])
+    hm.setMany([[2, 2], [3, 3], [4, 4], [6, 6]])
+  })
+
+  test('keys', () => {
+    expect([...hm.keys()]).toEqual([2, 3, 4, 5, 6])
+  });
+
+  test('values', () => {
+    expect([...hm.values()]).toEqual([2, 3, 4, 5, 6])
+  });
+});

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

@@ -397,3 +397,31 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(shiftedObj).toBe(obj1);
   });
 });
+
+
+describe('iterable methods', () => {
+  it('should forEach, some, every, filter, map, reduce of the deque', () => {
+    const dl = new DoublyLinkedList<number>()
+    dl.push(1);
+    dl.push(2);
+    dl.push(3);
+
+    const mockCallback = jest.fn();
+    dl.forEach((element) => {
+      mockCallback(element);
+    });
+
+    expect(mockCallback.mock.calls.length).toBe(3);
+    expect(mockCallback.mock.calls[0]).toEqual([1]);
+    expect(mockCallback.mock.calls[1]).toEqual([2]);
+    expect(mockCallback.mock.calls[2]).toEqual([3]);
+
+    expect(dl.every(element => element > 0)).toBe(true);
+    expect(dl.every(element => element > 1)).toBe(false);
+    expect(dl.some(element => element > 2)).toBe(true);
+
+    expect([...dl.filter(element => element > 2)]).toEqual([3]);
+    expect([...dl.map(element => element * 2)]).toEqual([2, 4, 6]);
+    expect(dl.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
+  });
+});

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

@@ -471,3 +471,28 @@ describe('SinglyLinkedList', () => {
     expect(list1.reduce((acc, value) => acc + value, 0)).toEqual(6);
   });
 });
+
+
+describe('iterable methods', () => {
+  it('should forEach, some, every, filter, map, reduce of the deque', () => {
+    const sl = new SinglyLinkedList<number>([1, 2, 3])
+
+    const mockCallback = jest.fn();
+    sl.forEach((element) => {
+      mockCallback(element);
+    });
+
+    expect(mockCallback.mock.calls.length).toBe(3);
+    expect(mockCallback.mock.calls[0]).toEqual([1]);
+    expect(mockCallback.mock.calls[1]).toEqual([2]);
+    expect(mockCallback.mock.calls[2]).toEqual([3]);
+
+    expect(sl.every(element => element > 0)).toBe(true);
+    expect(sl.every(element => element > 1)).toBe(false);
+    expect(sl.some(element => element > 2)).toBe(true);
+
+    expect([...sl.filter(element => element > 2)]).toEqual([3]);
+    expect([...sl.map(element => element * 2)]).toEqual([2, 4, 6]);
+    expect(sl.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
+  });
+});

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

@@ -447,4 +447,29 @@ describe('Deque', () => {
     });
   });
 
+  describe('iterable methods', () => {
+    it('should forEach, some, every, filter, map, reduce of the deque', () => {
+      deque.push(1);
+      deque.push(2);
+      deque.push(3);
+
+      const mockCallback = jest.fn();
+      deque.forEach((element) => {
+        mockCallback(element);
+      });
+
+      expect(mockCallback.mock.calls.length).toBe(3);
+      expect(mockCallback.mock.calls[0]).toEqual([1]);
+      expect(mockCallback.mock.calls[1]).toEqual([2]);
+      expect(mockCallback.mock.calls[2]).toEqual([3]);
+
+      expect(deque.every(element => element > 0)).toBe(true);
+      expect(deque.every(element => element > 1)).toBe(false);
+      expect(deque.some(element => element > 2)).toBe(true);
+
+      expect([...deque.filter(element => element > 2)]).toEqual([3]);
+      expect([...deque.map(element => element * 2)]).toEqual([2, 4, 6]);
+      expect(deque.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
+    });
+  });
 });