test: enhance skipPrototypeComparison tests for Assert class

Author: miguelmarcondesf

test/parallel/test-assert-class.js

@@ -498,8 +498,14 @@ test('Assert class non strict with simple diff', () => {
   function CoolClass(name) { this.name = name; }
 
   function AwesomeClass(name) { this.name = name; }
-  const person = new CoolClass('Assert is inspiring');
-  const user = new AwesomeClass('Assert is inspiring');
+
+  class Modern { constructor(value) { this.value = value; } }
+  class Legacy { constructor(value) { this.value = value; } }
+
+  const cool = new CoolClass('Assert is inspiring');
+  const awesome = new AwesomeClass('Assert is inspiring');
+  const modern = new Modern(42);
+  const legacy = new Legacy(42);
 
   test('Assert class strict with skipPrototypeComparison', () => {
     const assertInstance = new Assert({ skipPrototypeComparison: true });
@@ -508,7 +514,25 @@ test('Assert class non strict with simple diff', () => {
       () => assertInstance.deepEqual([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5, 9, 7]),
       { message }
     );
-    assertInstance.deepEqual(person, user);
+
+    assertInstance.deepEqual(cool, awesome);
+    assertInstance.deepStrictEqual(cool, awesome);
+    assertInstance.deepEqual(modern, legacy);
+    assertInstance.deepStrictEqual(modern, legacy);
+
+    const cool2 = new CoolClass('Soooo coooool');
+    assert.throws(
+      () => assertInstance.deepStrictEqual(cool, cool2),
+      { code: 'ERR_ASSERTION' }
+    );
+
+    const nested1 = { obj: new CoolClass('test'), arr: [1, 2, 3] };
+    const nested2 = { obj: new AwesomeClass('test'), arr: [1, 2, 3] };
+    assertInstance.deepStrictEqual(nested1, nested2);
+
+    const arr = new Uint8Array([1, 2, 3]);
+    const buf = Buffer.from([1, 2, 3]);
+    assertInstance.deepStrictEqual(arr, buf);
   });
 
   test('Assert class non strict with skipPrototypeComparison', () => {
@@ -518,6 +542,99 @@ test('Assert class non strict with simple diff', () => {
       () => assertInstance.deepStrictEqual([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5, 9, 7]),
       { message }
     );
-    assertInstance.deepStrictEqual(person, user);
+
+    assertInstance.deepStrictEqual(cool, awesome);
+    assertInstance.deepStrictEqual(modern, legacy);
+  });
+
+  test('Assert class skipPrototypeComparison with complex objects', () => {
+    const assertInstance = new Assert({ skipPrototypeComparison: true });
+
+    function ComplexAwesomeClass(name, age) {
+      this.name = name;
+      this.age = age;
+      this.settings = {
+        theme: 'dark',
+        lang: 'en'
+      };
+    }
+
+    function ComplexCoolClass(name, age) {
+      this.name = name;
+      this.age = age;
+      this.settings = {
+        theme: 'dark',
+        lang: 'en'
+      };
+    }
+
+    const awesome1 = new ComplexAwesomeClass('Foo', 30);
+    const cool1 = new ComplexCoolClass('Foo', 30);
+
+    assertInstance.deepStrictEqual(awesome1, cool1);
+
+    const cool2 = new ComplexCoolClass('Foo', 30);
+    cool2.settings.theme = 'light';
+
+    assert.throws(
+      () => assertInstance.deepStrictEqual(awesome1, cool2),
+      { code: 'ERR_ASSERTION' }
+    );
+  });
+
+  test('Assert class skipPrototypeComparison with arrays and special objects', () => {
+    const assertInstance = new Assert({ skipPrototypeComparison: true });
+
+    const arr1 = [1, 2, 3];
+    const arr2 = new Array(1, 2, 3);
+    assertInstance.deepStrictEqual(arr1, arr2);
+
+    const date1 = new Date('2023-01-01');
+    const date2 = new Date('2023-01-01');
+    assertInstance.deepStrictEqual(date1, date2);
+
+    const regex1 = /test/g;
+    const regex2 = new RegExp('test', 'g');
+    assertInstance.deepStrictEqual(regex1, regex2);
+
+    const date3 = new Date('2023-01-02');
+    assert.throws(
+      () => assertInstance.deepStrictEqual(date1, date3),
+      { code: 'ERR_ASSERTION' }
+    );
+  });
+
+  test('Assert class skipPrototypeComparison with notDeepStrictEqual', () => {
+    const assertInstance = new Assert({ skipPrototypeComparison: true });
+
+    assert.throws(
+      () => assertInstance.notDeepStrictEqual(cool, awesome),
+      { code: 'ERR_ASSERTION' }
+    );
+
+    const notAwesome = new AwesomeClass('Not so awesome');
+    assertInstance.notDeepStrictEqual(cool, notAwesome);
+
+    const defaultAssertInstance = new Assert({ skipPrototypeComparison: false });
+    defaultAssertInstance.notDeepStrictEqual(cool, awesome);
+  });
+
+  test('Assert class skipPrototypeComparison with mixed types', () => {
+    const assertInstance = new Assert({ skipPrototypeComparison: true });
+
+    const obj1 = { value: 42, nested: { prop: 'test' } };
+
+    function CustomObj(value, nested) {
+      this.value = value;
+      this.nested = nested;
+    }
+
+    const obj2 = new CustomObj(42, { prop: 'test' });
+    assertInstance.deepStrictEqual(obj1, obj2);
+
+    assert.throws(
+      () => assertInstance.deepStrictEqual({ num: 42 }, { num: '42' }),
+      { code: 'ERR_ASSERTION' }
+    );
   });
 }