fix: fixed some functions and unit tests

.github/workflows/ci.yml

@@ -35,7 +35,7 @@ jobs:
         run: npm install
 
       - name: Run tests
-        run: npm test:github"
+        run: npm test:github
 
       - name: Upload Allure report
         if: ${{ github.event.inputs.upload_report == 'true' }}

functionsUnittests/objectFunctions/applyDefaults.test.ts

@@ -28,53 +28,71 @@ describe('applyDefaults', () => {
         expect(result).toEqual(expected);
     });
 
-    // Test case 4: Handle non-object input for the first parameter (number)
-    it('4. should throw a TypeError if the first input is a number', () => {
+    // Test case 4: Handle empty defaults
+    it('4. should return the input object if defaults are empty', () => {
+        const obj = { a: 1, b: 2 };
+        const defaults = {};
+        const result = applyDefaults(obj, defaults);
+        const expected = { a: 1, b: 2 };
+        expect(result).toEqual(expected);
+    });
+
+    // Test case 5: Handle both input objects being empty
+    it('5. should return an empty object if both inputs are empty', () => {
+        const obj = {};
+        const defaults = {};
+        const result = applyDefaults(obj, defaults);
+        const expected = {};
+        expect(result).toEqual(expected);
+    });
+
+    // Test case 6: Handle non-object input for the first parameter (number)
+    it('6. should throw a TypeError if the first input is a number', () => {
         expect(() => applyDefaults(42 as any, { a: 1 })).toThrow(TypeError);
     });
 
-    // Test case 5: Handle non-object input for the first parameter (string)
-    it('5. should throw a TypeError if the first input is a string', () => {
+    // Test case 7: Handle non-object input for the first parameter (string)
+    it('7. should throw a TypeError if the first input is a string', () => {
         expect(() => applyDefaults('string' as any, { a: 1 })).toThrow(TypeError);
     });
 
-    // Test case 6: Handle non-object input for the first parameter (boolean)
-    it('6. should throw a TypeError if the first input is a boolean', () => {
+    // Test case 8: Handle non-object input for the first parameter (boolean)
+    it('8. should throw a TypeError if the first input is a boolean', () => {
         expect(() => applyDefaults(true as any, { a: 1 })).toThrow(TypeError);
     });
 
-    // Test case 7: Handle non-object input for the first parameter (null)
-    it('7. should throw a TypeError if the first input is null', () => {
+    // Test case 9: Handle non-object input for the first parameter (null)
+    it('9. should throw a TypeError if the first input is null', () => {
         expect(() => applyDefaults(null as any, { a: 1 })).toThrow(TypeError);
     });
 
-    // Test case 8: Handle non-object input for the first parameter (undefined)
-    it('8. should throw a TypeError if the first input is undefined', () => {
+    // Test case 10: Handle non-object input for the first parameter (undefined)
+    it('10. should throw a TypeError if the first input is undefined', () => {
         expect(() => applyDefaults(undefined as any, { a: 1 })).toThrow(TypeError);
     });
 
-    // Test case 9: Handle non-object input for the second parameter (number)
-    it('9. should throw a TypeError if the second input is a number', () => {
+    // Test case 11: Handle non-object input for the second parameter (number)
+    it('11. should throw a TypeError if the second input is a number', () => {
         expect(() => applyDefaults({ a: 1 }, 42 as any)).toThrow(TypeError);
     });
 
-    // Test case 10: Handle non-object input for the second parameter (string)
-    it('10. should throw a TypeError if the second input is a string', () => {
+    // Test case 12: Handle non-object input for the second parameter (string)
+    it('12. should throw a TypeError if the second input is a string', () => {
         expect(() => applyDefaults({ a: 1 }, 'string' as any)).toThrow(TypeError);
     });
 
-    // Test case 11: Handle non-object input for the second parameter (boolean)
-    it('11. should throw a TypeError if the second input is a boolean', () => {
+    // Test case 13: Handle non-object input for the second parameter (boolean)
+    it('13. should throw a TypeError if the second input is a boolean', () => {
         expect(() => applyDefaults({ a: 1 }, true as any)).toThrow(TypeError);
     });
 
-    // Test case 12: Handle non-object input for the second parameter (null)
-    it('12. should throw a TypeError if the second input is null', () => {
+    // Test case 14: Handle non-object input for the second parameter (null)
+    it('14. should throw a TypeError if the second input is null', () => {
         expect(() => applyDefaults({ a: 1 }, null as any)).toThrow(TypeError);
     });
 
-    // Test case 13: Handle non-object input for the second parameter (undefined)
-    it('13. should throw a TypeError if the second input is undefined', () => {
+    // Test case 15: Handle non-object input for the second parameter (undefined)
+    it('15. should throw a TypeError if the second input is undefined', () => {
         expect(() => applyDefaults({ a: 1 }, undefined as any)).toThrow(TypeError);
     });
 });

functionsUnittests/objectFunctions/deepEqual.test.ts

@@ -1,129 +1,86 @@
 import { deepEqual } from '../../objectFunctions/deepEqual';
 
 describe('deepEqual', () => {
-    // Test case 1: Compare two identical simple objects
-    it('1. should return true for two identical simple objects', () => {
+    // Test case 1: Compare two simple objects
+    it('1. should return true for two equal simple objects', () => {
         const obj1 = { a: 1, b: 2 };
         const obj2 = { a: 1, b: 2 };
-        const result = deepEqual(obj1, obj2);
-        const expected = true;
-        expect(result).toBe(expected);
+        expect(deepEqual(obj1, obj2)).toBe(true);
     });
 
     // Test case 2: Compare two different simple objects
     it('2. should return false for two different simple objects', () => {
         const obj1 = { a: 1, b: 2 };
         const obj2 = { a: 1, b: 3 };
-        const result = deepEqual(obj1, obj2);
-        const expected = false;
-        expect(result).toBe(expected);
+        expect(deepEqual(obj1, obj2)).toBe(false);
     });
 
-    // Test case 3: Compare two identical nested objects
-    it('3. should return true for two identical nested objects', () => {
+    // Test case 3: Compare two nested objects
+    it('3. should return true for two equal nested objects', () => {
         const obj1 = { a: 1, b: { c: 2, d: 3 } };
         const obj2 = { a: 1, b: { c: 2, d: 3 } };
-        const result = deepEqual(obj1, obj2);
-        const expected = true;
-        expect(result).toBe(expected);
+        expect(deepEqual(obj1, obj2)).toBe(true);
     });
 
     // Test case 4: Compare two different nested objects
     it('4. should return false for two different nested objects', () => {
         const obj1 = { a: 1, b: { c: 2, d: 3 } };
         const obj2 = { a: 1, b: { c: 2, d: 4 } };
-        const result = deepEqual(obj1, obj2);
-        const expected = false;
-        expect(result).toBe(expected);
+        expect(deepEqual(obj1, obj2)).toBe(false);
     });
 
-    // Test case 5: Compare two identical arrays
-    it('5. should return true for two identical arrays', () => {
+    // Test case 5: Compare two arrays
+    it('5. should return true for two equal arrays', () => {
         const arr1 = [1, 2, 3];
         const arr2 = [1, 2, 3];
-        const result = deepEqual(arr1, arr2);
-        const expected = true;
-        expect(result).toBe(expected);
+        expect(deepEqual(arr1, arr2)).toBe(true);
     });
 
     // Test case 6: Compare two different arrays
     it('6. should return false for two different arrays', () => {
         const arr1 = [1, 2, 3];
         const arr2 = [1, 2, 4];
-        const result = deepEqual(arr1, arr2);
-        const expected = false;
-        expect(result).toBe(expected);
+        expect(deepEqual(arr1, arr2)).toBe(false);
     });
 
-    // Test case 7: Compare two identical objects with arrays
-    it('7. should return true for two identical objects with arrays', () => {
-        const obj1 = { a: [1, 2, 3], b: 'test' };
-        const obj2 = { a: [1, 2, 3], b: 'test' };
-        const result = deepEqual(obj1, obj2);
-        const expected = true;
-        expect(result).toBe(expected);
+    // Test case 7: Compare objects with various data types
+    it('7. should return true for objects with equal various data types', () => {
+        const obj1 = { a: 1, b: 'string', c: true, d: null, e: undefined, f: [1, 2, 3], g: { h: 4 } };
+        const obj2 = { a: 1, b: 'string', c: true, d: null, e: undefined, f: [1, 2, 3], g: { h: 4 } };
+        expect(deepEqual(obj1, obj2)).toBe(true);
     });
 
-    // Test case 8: Compare two different objects with arrays
-    it('8. should return false for two different objects with arrays', () => {
-        const obj1 = { a: [1, 2, 3], b: 'test' };
-        const obj2 = { a: [1, 2, 4], b: 'test' };
-        const result = deepEqual(obj1, obj2);
-        const expected = false;
-        expect(result).toBe(expected);
+    // Test case 8: Compare objects with symbols
+    it('8. should return true for objects with equal symbols', () => {
+        const sym1 = Symbol('sym1');
+        const sym2 = Symbol('sym2');
+        const obj1 = { [sym1]: 1, [sym2]: 2 };
+        const obj2 = { [sym1]: 1, [sym2]: 2 };
+        expect(deepEqual(obj1, obj2)).toBe(true);
     });
 
-    // Test case 9: Compare two identical objects with functions
-    it('9. should return true for two identical objects with functions', () => {
-        const obj1 = { a: () => 1, b: 'test' };
-        const obj2 = { a: () => 1, b: 'test' };
-        const result = deepEqual(obj1, obj2);
-        const expected = true;
-        expect(result).toBe(expected);
+    // Test case 9: Handle non-object input (number)
+    it('9. should return false if one input is a number', () => {
+        expect(deepEqual(42 as any, { a: 1 })).toBe(false);
     });
 
-    // Test case 10: Compare two different objects with functions
-    it('10. should return false for two different objects with functions', () => {
-        const obj1 = { a: () => 1, b: 'test' };
-        const obj2 = { a: () => 2, b: 'test' };
-        const result = deepEqual(obj1, obj2);
-        const expected = false;
-        expect(result).toBe(expected);
+    // Test case 10: Handle non-object input (string)
+    it('10. should return false if one input is a string', () => {
+        expect(deepEqual('string' as any, { a: 1 })).toBe(false);
     });
 
-    // Test case 11: Compare two identical objects with symbols
-    it('11. should return true for two identical objects with symbols', () => {
-        const obj1 = { a: Symbol('a'), b: 'test' };
-        const obj2 = { a: Symbol('a'), b: 'test' };
-        const result = deepEqual(obj1, obj2);
-        const expected = true;
-        expect(result).toBe(expected);
+    // Test case 11: Handle non-object input (boolean)
+    it('11. should return false if one input is a boolean', () => {
+        expect(deepEqual(true as any, { a: 1 })).toBe(false);
     });
 
-    // Test case 12: Compare two different objects with symbols
-    it('12. should return false for two different objects with symbols', () => {
-        const obj1 = { a: Symbol('a'), b: 'test' };
-        const obj2 = { a: Symbol('b'), b: 'test' };
-        const result = deepEqual(obj1, obj2);
-        const expected = false;
-        expect(result).toBe(expected);
+    // Test case 12: Handle non-object input (null)
+    it('12. should return false if one input is null', () => {
+        expect(deepEqual(null as any, { a: 1 })).toBe(false);
     });
 
-    // Test case 13: Compare two identical objects with BigInt values
-    it('13. should return true for two identical objects with BigInt values', () => {
-        const obj1 = { a: BigInt(1), b: 'test' };
-        const obj2 = { a: BigInt(1), b: 'test' };
-        const result = deepEqual(obj1, obj2);
-        const expected = true;
-        expect(result).toBe(expected);
-    });
-
-    // Test case 14: Compare two different objects with BigInt values
-    it('14. should return false for two different objects with BigInt values', () => {
-        const obj1 = { a: BigInt(1), b: 'test' };
-        const obj2 = { a: BigInt(2), b: 'test' };
-        const result = deepEqual(obj1, obj2);
-        const expected = false;
-        expect(result).toBe(expected);
+    // Test case 13: Handle non-object input (undefined)
+    it('13. should return false if one input is undefined', () => {
+        expect(deepEqual(undefined as any, { a: 1 })).toBe(false);
     });
 });

functionsUnittests/objectFunctions/deepFreeze.test.ts

@@ -4,51 +4,61 @@ describe('deepFreeze', () => {
     // Test case 1: Deep freeze a simple object
     it('1. should deep freeze a simple object', () => {
         const obj = { a: 1, b: 2 };
-        const result = deepFreeze(obj);
-        expect(Object.isFrozen(result)).toBe(true);
-        expect(() => { (result as any).a = 3; }).toThrow(TypeError);
+        const frozenObj = deepFreeze(obj);
+        expect(Object.isFrozen(frozenObj)).toBe(true);
+        expect(() => { frozenObj.a = 2; }).toThrow(TypeError);
     });
 
     // Test case 2: Deep freeze a nested object
     it('2. should deep freeze a nested object', () => {
         const obj = { a: 1, b: { c: 2, d: 3 } };
-        const result = deepFreeze(obj);
-        expect(Object.isFrozen(result)).toBe(true);
-        expect(Object.isFrozen(result.b)).toBe(true);
-        expect(() => { (result.b as any).c = 4; }).toThrow(TypeError);
+        const frozenObj = deepFreeze(obj);
+        expect(Object.isFrozen(frozenObj)).toBe(true);
+        expect(Object.isFrozen(frozenObj.b)).toBe(true);
+        expect(() => { frozenObj.b.c = 3; }).toThrow(TypeError);
     });
 
     // Test case 3: Deep freeze an array
     it('3. should deep freeze an array', () => {
         const arr = [1, 2, { a: 3 }];
-        const result = deepFreeze(arr);
-        expect(Object.isFrozen(result)).toBe(true);
-        expect(Object.isFrozen(result[2])).toBe(true);
-        expect(() => { (result[2] as any).a = 4; }).toThrow(TypeError);
+        const frozenArr = deepFreeze(arr);
+        expect(Object.isFrozen(frozenArr)).toBe(true);
+        expect(Object.isFrozen(frozenArr[2])).toBe(true);
+        expect(() => { frozenArr[0] = 4; }).toThrow(TypeError);
     });
 
-    // Test case 4: Handle non-object input (number)
-    it('4. should throw a TypeError if input is a number', () => {
+    // Test case 4: Deep freeze an object with various data types
+    it('4. should deep freeze an object with various data types', () => {
+        const obj = { a: 1, b: 'string', c: true, d: null, e: undefined, f: [1, 2, 3], g: { h: 4 } };
+        const frozenObj = deepFreeze(obj);
+        expect(Object.isFrozen(frozenObj)).toBe(true);
+        expect(Object.isFrozen(frozenObj.f)).toBe(true);
+        expect(Object.isFrozen(frozenObj.g)).toBe(true);
+        expect(() => { frozenObj.a = 2; }).toThrow(TypeError);
+    });
+
+    // Test case 5: Handle non-object input (number)
+    it('5. should throw a TypeError if input is a number', () => {
         expect(() => deepFreeze(42 as any)).toThrow(TypeError);
     });
 
-    // Test case 5: Handle non-object input (string)
-    it('5. should throw a TypeError if input is a string', () => {
+    // Test case 6: Handle non-object input (string)
+    it('6. should throw a TypeError if input is a string', () => {
         expect(() => deepFreeze('string' as any)).toThrow(TypeError);
     });
 
-    // Test case 6: Handle non-object input (boolean)
-    it('6. should throw a TypeError if input is a boolean', () => {
+    // Test case 7: Handle non-object input (boolean)
+    it('7. should throw a TypeError if input is a boolean', () => {
         expect(() => deepFreeze(true as any)).toThrow(TypeError);
     });
 
-    // Test case 7: Handle non-object input (null)
-    it('7. should throw a TypeError if input is null', () => {
+    // Test case 8: Handle non-object input (null)
+    it('8. should throw a TypeError if input is null', () => {
         expect(() => deepFreeze(null as any)).toThrow(TypeError);
     });
 
-    // Test case 8: Handle non-object input (undefined)
-    it('8. should throw a TypeError if input is undefined', () => {
+    // Test case 9: Handle non-object input (undefined)
+    it('9. should throw a TypeError if input is undefined', () => {
         expect(() => deepFreeze(undefined as any)).toThrow(TypeError);
     });
-});
+});