data-structure-typed 1.47.9 → 1.48.1

package/test/unit/data-structures/binary-tree/avl-tree.test.ts

@@ -341,4 +341,20 @@ describe('AVLTree iterative methods test', () => {
     expect(entries.length).toBe(3);
     expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
   });
+
+  test('should clone work well', () => {
+    const cloned = avl.clone();
+    expect(cloned.root?.left?.key).toBe(1);
+    expect(cloned.root?.right?.value).toBe('c');
+  });
+
+  test('should keys', () => {
+    const keys = avl.keys();
+    expect(keys).toEqual([1, 2, 3]);
+  });
+
+  test('should values', () => {
+    const values = avl.values();
+    expect(values).toEqual(['a', 'b', 'c']);
+  });
 });

package/test/unit/data-structures/binary-tree/binary-tree.test.ts

@@ -564,7 +564,6 @@ describe('BinaryTree', () => {
   });
 });
 
-
 describe('BinaryTree iterative methods test', () => {
   let binaryTree: BinaryTree<string>;
   beforeEach(() => {
@@ -617,4 +616,20 @@ describe('BinaryTree iterative methods test', () => {
     expect(entries.length).toBe(3);
     expect(entries).toEqual([[2, 'b'], [1, 'a'], [3, 'c']]);
   });
+
+  test('should clone work well', () => {
+    const cloned = binaryTree.clone();
+    expect(cloned.root?.left?.key).toBe(2);
+    expect(cloned.root?.right?.value).toBe('c');
+  });
+
+  test('should keys', () => {
+    const keys = binaryTree.keys();
+    expect(keys).toEqual([2, 1, 3]);
+  });
+
+  test('should values', () => {
+    const values = binaryTree.values();
+    expect(values).toEqual(['b', 'a', 'c']);
+  });
 });

package/test/unit/data-structures/binary-tree/bst.test.ts

@@ -900,4 +900,20 @@ describe('BST iterative methods test', () => {
     expect(entries.length).toBe(3);
     expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
   });
+
+  test('should clone work well', () => {
+    const cloned = bst.clone();
+    expect(cloned.root?.left).toBe(undefined);
+    expect(cloned.root?.right?.value).toBe('b');
+  });
+
+  test('should keys', () => {
+    const keys = bst.keys();
+    expect(keys).toEqual([1, 2, 3]);
+  });
+
+  test('should values', () => {
+    const values = bst.values();
+    expect(values).toEqual(['a', 'b', 'c']);
+  });
 });

package/test/unit/data-structures/binary-tree/tree-multimap.test.ts

@@ -1,4 +1,12 @@
-import { CP, IterationType, TreeMultimap, TreeMultimapNode } from '../../../../src';
+import {
+  AVLTreeNode,
+  BinaryTreeNode,
+  BSTNode,
+  CP,
+  IterationType,
+  TreeMultimap,
+  TreeMultimapNode
+} from '../../../../src';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -592,3 +600,76 @@ describe('TreeMultimap Performance test', function () {
     isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
   });
 });
+
+describe('TreeMultimap iterative methods test', () => {
+  let treeMM: TreeMultimap<string>;
+  beforeEach(() => {
+    treeMM = new TreeMultimap<string>();
+    treeMM.add([1, 'a'], 10);
+    treeMM.add([2, 'b'], 10);
+    treeMM.add([3, 'c'], 1);
+  });
+
+  test('The node obtained by get Node should match the node type', () => {
+    const node3 = treeMM.getNode(3);
+    expect(node3).toBeInstanceOf(BinaryTreeNode);
+    expect(node3).toBeInstanceOf(BSTNode);
+    expect(node3).toBeInstanceOf(AVLTreeNode);
+  });
+
+  test('forEach should iterate over all elements', () => {
+    const mockCallback = jest.fn();
+    treeMM.forEach((entry) => {
+      mockCallback(entry);
+    });
+
+    expect(mockCallback.mock.calls.length).toBe(3);
+    expect(mockCallback.mock.calls[0][0]).toEqual([1, 'a']);
+    expect(mockCallback.mock.calls[1][0]).toEqual([2, 'b']);
+    expect(mockCallback.mock.calls[2][0]).toEqual([3, 'c']);
+  });
+
+  test('filter should return a new tree with filtered elements', () => {
+    const filteredTree = treeMM.filter(([key]) => key > 1);
+    expect(filteredTree.size).toBe(2);
+    expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
+  });
+
+  test('map should return a new tree with modified elements', () => {
+    const mappedTree = treeMM.map(([key]) => (key * 2).toString());
+    expect(mappedTree.size).toBe(3);
+    expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
+  });
+
+  test('reduce should accumulate values', () => {
+    const sum = treeMM.reduce((acc, [key]) => acc + key, 0);
+    expect(sum).toBe(6);
+  });
+
+  test('[Symbol.iterator] should provide an iterator', () => {
+    const entries = [];
+    for (const entry of treeMM) {
+      entries.push(entry);
+    }
+
+    expect(entries.length).toBe(3);
+    expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
+  });
+
+  test('should clone work well', () => {
+    expect(treeMM.count).toBe(21)
+    const cloned = treeMM.clone();
+    expect(cloned.root?.left?.key).toBe(1);
+    expect(cloned.root?.right?.value).toBe('c');
+  });
+
+  test('should keys', () => {
+    const keys = treeMM.keys();
+    expect(keys).toEqual([1, 2, 3]);
+  });
+
+  test('should values', () => {
+    const values = treeMM.values();
+    expect(values).toEqual(['a', 'b', 'c']);
+  });
+});

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])
+  });
+});