test: Add test coverage

src/compat/array/size.spec.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
-import { size } from '../../index';
 import { falsey } from '../_internal/falsey';
 import { toArgs } from '../_internal/toArgs';
+import { size } from './size';
 
 const args = toArgs([1, 2, 3]);
 /**

src/compat/string/padStart.spec.ts

@@ -29,12 +29,4 @@ describe('padStart', () => {
   it('should not pad a string if the length is negative', () => {
     expect(padStart('abc', -3)).toBe('abc');
   });
-
-  it('should not pad a string if the length is Infinity', () => {
-    expect(padStart('abc', Infinity)).toBe('abc');
-  });
-
-  it('should not pad a string if the length is -Infinity', () => {
-    expect(padStart('abc', -Infinity)).toBe('abc');
-  });
 });

src/object/cloneDeep.spec.ts

@@ -26,6 +26,14 @@ describe('cloneDeep', () => {
     expect(clonedArr).not.toBe(arr);
   });
 
+  it('should clone RegExp arrays', () => {
+    const arr = /test/.exec('hello test');
+    const cloned = cloneDeep(arr);
+
+    expect(cloned).toEqual(arr);
+    expect(cloned).not.toBe(arr);
+  })
+
   it('should clone arrays with nested objects', () => {
     const arr = [{ a: 1 }, { b: 2 }, { c: 3 }];
     const clonedArr = cloneDeep(arr);
@@ -319,4 +327,24 @@ describe('cloneDeep', () => {
     expect(clonedError.cause).toBe(error.cause);
     expect(clonedError.code).toBe(error.code);
   });
+
+  it('should clone DataViews', () => {
+    const buffer = new Uint8Array([1, 2]).buffer;
+    const view = new DataView(buffer);
+
+    const cloned = cloneDeep(view);
+
+    expect(cloned).not.toBe(view);
+    expect(cloned.getInt8(0)).toBe(view.getInt8(0));
+    expect(cloned.getInt8(1)).toBe(view.getInt8(1));
+  })
+
+  it('should clone buffers', () => {
+    const buffer = Buffer.from([1, 2, 3]);
+
+    const cloned = cloneDeep(buffer);
+
+    expect(cloned).not.toBe(buffer);
+    expect(cloned).toEqual(buffer);
+  })
 });

src/predicate/isEqual.spec.ts

@@ -6,12 +6,14 @@ describe('isEqual', () => {
     expect(isEqual(1, 1)).toBe(true);
     expect(isEqual('hello', 'hello')).toBe(true);
     expect(isEqual(true, true)).toBe(true);
+    expect(isEqual(100n, 100n)).toBe(true);
   });
 
   it('should return false for different primitive values', () => {
     expect(isEqual(1, 2)).toBe(false);
     expect(isEqual('hello', 'world')).toBe(false);
     expect(isEqual(true, false)).toBe(false);
+    expect(isEqual(101n, 100n)).toBe(false);
   });
 
   it('should return true for NaN comparisons', () => {
@@ -50,6 +52,11 @@ describe('isEqual', () => {
     const obj1 = { a: 1, b: { c: 2 } };
     const obj2 = { a: 1, b: { c: 2 } };
     expect(isEqual(obj1, obj2)).toBe(true);
+
+    const obj3 = null;
+    const obj4 = null;
+
+    expect(isEqual(obj3, obj4)).toBe(true);
   });
 
   it('should return false for objects with different values', () => {
@@ -81,4 +88,23 @@ describe('isEqual', () => {
     const arr2 = [1, 2];
     expect(isEqual(arr1, arr2)).toBe(false);
   });
+
+  it('should return true for equal array buffers', () => {
+    const buffer1 = new Uint8Array([1, 2, 3]).buffer;
+    const buffer2 = new Uint8Array([1, 2, 3]).buffer;
+
+    expect(isEqual(buffer1, buffer2)).toBe(true);
+  })
+
+  it('should return false for different array buffers', () => {
+    const buffer1 = new Uint8Array([1, 2, 3]).buffer;
+    const buffer2 = new Uint8Array([1, 2]).buffer;
+
+    expect(isEqual(buffer1, buffer2)).toBe(false);
+
+    const buffer3 = new Uint8Array([1, 2, 3]).buffer;
+    const buffer4 = new Uint8Array([1, 2, 4]).buffer;
+
+    expect(isEqual(buffer3, buffer4)).toBe(false);
+  })
 });

src/predicate/isEqual.ts

@@ -68,7 +68,6 @@ function areObjectsEqual(a: any, b: any, stack?: Map<any, any>) {
   }
 
   switch (aTag) {
-    case regexpTag:
     case stringTag:
       return a.toString() === b.toString();
 
@@ -196,8 +195,8 @@ function areObjectsEqual(a: any, b: any, stack?: Map<any, any>) {
       }
 
       case objectTag: {
-        if (a == null || b == null) {
-          return a === b;
+        if (a === null || b === null) {
+          return true;
         }
 
         const areEqualInstances =