LibJS: Improve deep equals algorithm in tests

The `deepEquals` algorithm used for testing was naive, and incorrectly
evaluated equality of objects in some cases. The new algorithm considers
that the second object could have more keys than the first, and compares
the prototypes of the objects.

Userland/Libraries/LibJS/Tests/builtins/Array/Array.prototype.sort.js

@@ -153,7 +153,7 @@ describe("Array.prototype.sort", () => {
 
         obj = { 0: 3, 1: 2, 2: 1, a: "b", hello: "friends!", length: 2 };
         expect(Array.prototype.sort.call(obj)).toBe(obj);
-        expect(obj).toEqual({ 0: 2, 1: 3, 2: 1, 3: 0, a: "b", hello: "friends!", length: 2 });
+        expect(obj).toEqual({ 0: 2, 1: 3, 2: 1, a: "b", hello: "friends!", length: 2 });
 
         obj = { 0: 2, 1: 3, 2: 1, a: "b", hello: "friends!", length: 2 };
         expect(
@@ -163,7 +163,7 @@ describe("Array.prototype.sort", () => {
                 return b - a;
             })
         ).toBe(obj);
-        expect(obj).toEqual({ 0: 3, 1: 2, 2: 1, 3: 0, a: "b", hello: "friends!", length: 2 });
+        expect(obj).toEqual({ 0: 3, 1: 2, 2: 1, a: "b", hello: "friends!", length: 2 });
     });
 
     test("that it handles abrupt completions correctly", () => {

Userland/Libraries/LibJS/Tests/builtins/Atomics/Atomics.add.js

@@ -28,16 +28,16 @@ test("basic functionality (non-BigInt)", () => {
         const array = new ArrayType(4);
 
         expect(Atomics.add(array, 0, 1)).toBe(0);
-        expect(array).toEqual([1, 0, 0, 0]);
+        expect(array).toEqual(new ArrayType([1, 0, 0, 0]));
 
         expect(Atomics.add(array, 0, 1)).toBe(1);
-        expect(array).toEqual([2, 0, 0, 0]);
+        expect(array).toEqual(new ArrayType([2, 0, 0, 0]));
 
         expect(Atomics.add(array, 2, 3.14)).toBe(0);
-        expect(array).toEqual([2, 0, 3, 0]);
+        expect(array).toEqual(new ArrayType([2, 0, 3, 0]));
 
         expect(Atomics.add(array, 3, "1")).toBe(0);
-        expect(array).toEqual([2, 0, 3, 1]);
+        expect(array).toEqual(new ArrayType([2, 0, 3, 1]));
     });
 });
 
@@ -46,15 +46,15 @@ test("basic functionality (BigInt)", () => {
         const array = new ArrayType(4);
 
         expect(Atomics.add(array, 0, 1n)).toBe(0n);
-        expect(array).toEqual([1n, 0n, 0n, 0n]);
+        expect(array).toEqual(new ArrayType([1n, 0n, 0n, 0n]));
 
         expect(Atomics.add(array, 0, 1n)).toBe(1n);
-        expect(array).toEqual([2n, 0n, 0n, 0n]);
+        expect(array).toEqual(new ArrayType([2n, 0n, 0n, 0n]));
 
         expect(Atomics.add(array, 2, 3n)).toBe(0n);
-        expect(array).toEqual([2n, 0n, 3n, 0n]);
+        expect(array).toEqual(new ArrayType([2n, 0n, 3n, 0n]));
 
         expect(Atomics.add(array, 3, 4n)).toBe(0n);
-        expect(array).toEqual([2n, 0n, 3n, 4n]);
+        expect(array).toEqual(new ArrayType([2n, 0n, 3n, 4n]));
     });
 });

Userland/Libraries/LibJS/Tests/builtins/Atomics/Atomics.and.js

@@ -30,19 +30,19 @@ test("basic functionality (non-BigInt)", () => {
         array[1] = 0b0101;
 
         expect(Atomics.and(array, 0, 0b0000)).toBe(0b0000);
-        expect(array).toEqual([0b0000, 0b0101]);
+        expect(array).toEqual(new ArrayType([0b0000, 0b0101]));
 
         expect(Atomics.and(array, 0, 0b1111)).toBe(0b0000);
-        expect(array).toEqual([0b0000, 0b0101]);
+        expect(array).toEqual(new ArrayType([0b0000, 0b0101]));
 
         expect(Atomics.and(array, 1, 0b0101)).toBe(0b0101);
-        expect(array).toEqual([0b0000, 0b0101]);
+        expect(array).toEqual(new ArrayType([0b0000, 0b0101]));
 
         expect(Atomics.and(array, 1, 0b0100)).toBe(0b0101);
-        expect(array).toEqual([0b0000, 0b0100]);
+        expect(array).toEqual(new ArrayType([0b0000, 0b0100]));
 
         expect(Atomics.and(array, 1, 0b0000)).toBe(0b0100);
-        expect(array).toEqual([0b0000, 0b0000]);
+        expect(array).toEqual(new ArrayType([0b0000, 0b0000]));
     });
 });
 
@@ -53,18 +53,18 @@ test("basic functionality (BigInt)", () => {
         array[1] = 0b0101n;
 
         expect(Atomics.and(array, 0, 0b0000n)).toBe(0b0000n);
-        expect(array).toEqual([0b0000n, 0b0101n]);
+        expect(array).toEqual(new ArrayType([0b0000n, 0b0101n]));
 
         expect(Atomics.and(array, 0, 0b1111n)).toBe(0b0000n);
-        expect(array).toEqual([0b0000n, 0b0101n]);
+        expect(array).toEqual(new ArrayType([0b0000n, 0b0101n]));
 
         expect(Atomics.and(array, 1, 0b0101n)).toBe(0b0101n);
-        expect(array).toEqual([0b0000n, 0b0101n]);
+        expect(array).toEqual(new ArrayType([0b0000n, 0b0101n]));
 
         expect(Atomics.and(array, 1, 0b0100n)).toBe(0b0101n);
-        expect(array).toEqual([0b0000n, 0b0100n]);
+        expect(array).toEqual(new ArrayType([0b0000n, 0b0100n]));
 
         expect(Atomics.and(array, 1, 0b0000n)).toBe(0b0100n);
-        expect(array).toEqual([0b0000n, 0b0000n]);
+        expect(array).toEqual(new ArrayType([0b0000n, 0b0000n]));
     });
 });

Userland/Libraries/LibJS/Tests/builtins/Atomics/Atomics.compareExchange.js

@@ -30,16 +30,16 @@ test("basic functionality (non-BigInt)", () => {
         array[1] = 2;
 
         expect(Atomics.compareExchange(array, 0, 0, 5)).toBe(1);
-        expect(array).toEqual([1, 2]);
+        expect(array).toEqual(new ArrayType([1, 2]));
 
         expect(Atomics.compareExchange(array, 0, 1, "5")).toBe(1);
-        expect(array).toEqual([5, 2]);
+        expect(array).toEqual(new ArrayType([5, 2]));
 
         expect(Atomics.compareExchange(array, 0, "5", 6)).toBe(5);
-        expect(array).toEqual([6, 2]);
+        expect(array).toEqual(new ArrayType([6, 2]));
 
         expect(Atomics.compareExchange(array, 1, 2, 3.14)).toBe(2);
-        expect(array).toEqual([6, 3]);
+        expect(array).toEqual(new ArrayType([6, 3]));
     });
 });
 
@@ -50,15 +50,15 @@ test("basic functionality (BigInt)", () => {
         array[1] = 2n;
 
         expect(Atomics.compareExchange(array, 0, 0n, 5n)).toBe(1n);
-        expect(array).toEqual([1n, 2n]);
+        expect(array).toEqual(new ArrayType([1n, 2n]));
 
         expect(Atomics.compareExchange(array, 0, 1n, 5n)).toBe(1n);
-        expect(array).toEqual([5n, 2n]);
+        expect(array).toEqual(new ArrayType([5n, 2n]));
 
         expect(Atomics.compareExchange(array, 0, 5n, 6n)).toBe(5n);
-        expect(array).toEqual([6n, 2n]);
+        expect(array).toEqual(new ArrayType([6n, 2n]));
 
         expect(Atomics.compareExchange(array, 1, 2n, 3n)).toBe(2n);
-        expect(array).toEqual([6n, 3n]);
+        expect(array).toEqual(new ArrayType([6n, 3n]));
     });
 });

Userland/Libraries/LibJS/Tests/builtins/Atomics/Atomics.exchange.js

@@ -32,19 +32,19 @@ test("basic functionality (non-BigInt)", () => {
         array[3] = 4;
 
         expect(Atomics.exchange(array, 0, 5)).toBe(1);
-        expect(array).toEqual([5, 2, 3, 4]);
+        expect(array).toEqual(new ArrayType([5, 2, 3, 4]));
 
         expect(Atomics.exchange(array, 0, 6)).toBe(5);
-        expect(array).toEqual([6, 2, 3, 4]);
+        expect(array).toEqual(new ArrayType([6, 2, 3, 4]));
 
         expect(Atomics.exchange(array, "1", 7)).toBe(2);
-        expect(array).toEqual([6, 7, 3, 4]);
+        expect(array).toEqual(new ArrayType([6, 7, 3, 4]));
 
         expect(Atomics.exchange(array, 2, "8")).toBe(3);
-        expect(array).toEqual([6, 7, 8, 4]);
+        expect(array).toEqual(new ArrayType([6, 7, 8, 4]));
 
         expect(Atomics.exchange(array, 3.14, 9)).toBe(4);
-        expect(array).toEqual([6, 7, 8, 9]);
+        expect(array).toEqual(new ArrayType([6, 7, 8, 9]));
     });
 });
 
@@ -57,18 +57,18 @@ test("basic functionality (BigInt)", () => {
         array[3] = 4n;
 
         expect(Atomics.exchange(array, 0, 5n)).toBe(1n);
-        expect(array).toEqual([5n, 2n, 3n, 4n]);
+        expect(array).toEqual(new ArrayType([5n, 2n, 3n, 4n]));
 
         expect(Atomics.exchange(array, 0, 6n)).toBe(5n);
-        expect(array).toEqual([6n, 2n, 3n, 4n]);
+        expect(array).toEqual(new ArrayType([6n, 2n, 3n, 4n]));
 
         expect(Atomics.exchange(array, 1, 7n)).toBe(2n);
-        expect(array).toEqual([6n, 7n, 3n, 4n]);
+        expect(array).toEqual(new ArrayType([6n, 7n, 3n, 4n]));
 
         expect(Atomics.exchange(array, 2, 8n)).toBe(3n);
-        expect(array).toEqual([6n, 7n, 8n, 4n]);
+        expect(array).toEqual(new ArrayType([6n, 7n, 8n, 4n]));
 
         expect(Atomics.exchange(array, 3, 9n)).toBe(4n);
-        expect(array).toEqual([6n, 7n, 8n, 9n]);
+        expect(array).toEqual(new ArrayType([6n, 7n, 8n, 9n]));
     });
 });

Userland/Libraries/LibJS/Tests/builtins/Atomics/Atomics.or.js

@@ -30,19 +30,19 @@ test("basic functionality (non-BigInt)", () => {
         array[1] = 0b0101;
 
         expect(Atomics.or(array, 0, 0b0000)).toBe(0b0000);
-        expect(array).toEqual([0b0000, 0b0101]);
+        expect(array).toEqual(new ArrayType([0b0000, 0b0101]));
 
         expect(Atomics.or(array, 0, 0b1111)).toBe(0b0000);
-        expect(array).toEqual([0b1111, 0b0101]);
+        expect(array).toEqual(new ArrayType([0b1111, 0b0101]));
 
         expect(Atomics.or(array, 1, 0b0101)).toBe(0b0101);
-        expect(array).toEqual([0b1111, 0b0101]);
+        expect(array).toEqual(new ArrayType([0b1111, 0b0101]));
 
         expect(Atomics.or(array, 1, 0b1000)).toBe(0b0101);
-        expect(array).toEqual([0b1111, 0b1101]);
+        expect(array).toEqual(new ArrayType([0b1111, 0b1101]));
 
         expect(Atomics.or(array, 1, 0b0010)).toBe(0b1101);
-        expect(array).toEqual([0b1111, 0b1111]);
+        expect(array).toEqual(new ArrayType([0b1111, 0b1111]));
     });
 });
 
@@ -53,18 +53,18 @@ test("basic functionality (BigInt)", () => {
         array[1] = 0b0101n;
 
         expect(Atomics.or(array, 0, 0b0000n)).toBe(0b0000n);
-        expect(array).toEqual([0b0000n, 0b0101n]);
+        expect(array).toEqual(new ArrayType([0b0000n, 0b0101n]));
 
         expect(Atomics.or(array, 0, 0b1111n)).toBe(0b0000n);
-        expect(array).toEqual([0b1111n, 0b0101n]);
+        expect(array).toEqual(new ArrayType([0b1111n, 0b0101n]));
 
         expect(Atomics.or(array, 1, 0b0101n)).toBe(0b0101n);
-        expect(array).toEqual([0b1111n, 0b0101n]);
+        expect(array).toEqual(new ArrayType([0b1111n, 0b0101n]));
 
         expect(Atomics.or(array, 1, 0b1000n)).toBe(0b0101n);
-        expect(array).toEqual([0b1111n, 0b1101n]);
+        expect(array).toEqual(new ArrayType([0b1111n, 0b1101n]));
 
         expect(Atomics.or(array, 1, 0b0010n)).toBe(0b1101n);
-        expect(array).toEqual([0b1111n, 0b1111n]);
+        expect(array).toEqual(new ArrayType([0b1111n, 0b1111n]));
     });
 });

Userland/Libraries/LibJS/Tests/builtins/Atomics/Atomics.sub.js

@@ -32,19 +32,19 @@ test("basic functionality (non-BigInt)", () => {
         array[3] = 4;
 
         expect(Atomics.sub(array, 0, 1)).toBe(1);
-        expect(array).toEqual([0, 2, 3, 4]);
+        expect(array).toEqual(new ArrayType([0, 2, 3, 4]));
 
         expect(Atomics.sub(array, 1, 1)).toBe(2);
-        expect(array).toEqual([0, 1, 3, 4]);
+        expect(array).toEqual(new ArrayType([0, 1, 3, 4]));
 
         expect(Atomics.sub(array, 1, 1)).toBe(1);
-        expect(array).toEqual([0, 0, 3, 4]);
+        expect(array).toEqual(new ArrayType([0, 0, 3, 4]));
 
         expect(Atomics.sub(array, 2, 3.14)).toBe(3);
-        expect(array).toEqual([0, 0, 0, 4]);
+        expect(array).toEqual(new ArrayType([0, 0, 0, 4]));
 
         expect(Atomics.sub(array, 3, "1")).toBe(4);
-        expect(array).toEqual([0, 0, 0, 3]);
+        expect(array).toEqual(new ArrayType([0, 0, 0, 3]));
     });
 });
 
@@ -57,18 +57,18 @@ test("basic functionality (BigInt)", () => {
         array[3] = 4n;
 
         expect(Atomics.sub(array, 0, 1n)).toBe(1n);
-        expect(array).toEqual([0n, 2n, 3n, 4n]);
+        expect(array).toEqual(new ArrayType([0n, 2n, 3n, 4n]));
 
         expect(Atomics.sub(array, 1, 1n)).toBe(2n);
-        expect(array).toEqual([0n, 1n, 3n, 4n]);
+        expect(array).toEqual(new ArrayType([0n, 1n, 3n, 4n]));
 
         expect(Atomics.sub(array, 1, 1n)).toBe(1n);
-        expect(array).toEqual([0n, 0n, 3n, 4n]);
+        expect(array).toEqual(new ArrayType([0n, 0n, 3n, 4n]));
 
         expect(Atomics.sub(array, 2, 3n)).toBe(3n);
-        expect(array).toEqual([0n, 0n, 0n, 4n]);
+        expect(array).toEqual(new ArrayType([0n, 0n, 0n, 4n]));
 
         expect(Atomics.sub(array, 3, 1n)).toBe(4n);
-        expect(array).toEqual([0n, 0n, 0n, 3n]);
+        expect(array).toEqual(new ArrayType([0n, 0n, 0n, 3n]));
     });
 });

Userland/Libraries/LibJS/Tests/builtins/Atomics/Atomics.xor.js

@@ -30,19 +30,19 @@ test("basic functionality (non-BigInt)", () => {
         array[1] = 0b0101;
 
         expect(Atomics.xor(array, 0, 0b0000)).toBe(0b0000);
-        expect(array).toEqual([0b0000, 0b0101]);
+        expect(array).toEqual(new ArrayType([0b0000, 0b0101]));
 
         expect(Atomics.xor(array, 0, 0b1111)).toBe(0b0000);
-        expect(array).toEqual([0b1111, 0b0101]);
+        expect(array).toEqual(new ArrayType([0b1111, 0b0101]));
 
         expect(Atomics.xor(array, 1, 0b0000)).toBe(0b0101);
-        expect(array).toEqual([0b1111, 0b0101]);
+        expect(array).toEqual(new ArrayType([0b1111, 0b0101]));
 
         expect(Atomics.xor(array, 1, 0b0100)).toBe(0b0101);
-        expect(array).toEqual([0b1111, 0b0001]);
+        expect(array).toEqual(new ArrayType([0b1111, 0b0001]));
 
         expect(Atomics.xor(array, 1, 0b0001)).toBe(0b0001);
-        expect(array).toEqual([0b1111, 0b0000]);
+        expect(array).toEqual(new ArrayType([0b1111, 0b0000]));
     });
 });
 
@@ -53,18 +53,18 @@ test("basic functionality (BigInt)", () => {
         array[1] = 0b0101n;
 
         expect(Atomics.xor(array, 0, 0b0000n)).toBe(0b0000n);
-        expect(array).toEqual([0b0000n, 0b0101n]);
+        expect(array).toEqual(new ArrayType([0b0000n, 0b0101n]));
 
         expect(Atomics.xor(array, 0, 0b1111n)).toBe(0b0000n);
-        expect(array).toEqual([0b1111n, 0b0101n]);
+        expect(array).toEqual(new ArrayType([0b1111n, 0b0101n]));
 
         expect(Atomics.xor(array, 1, 0b0000n)).toBe(0b0101n);
-        expect(array).toEqual([0b1111n, 0b0101n]);
+        expect(array).toEqual(new ArrayType([0b1111n, 0b0101n]));
 
         expect(Atomics.xor(array, 1, 0b0100n)).toBe(0b0101n);
-        expect(array).toEqual([0b1111n, 0b0001n]);
+        expect(array).toEqual(new ArrayType([0b1111n, 0b0001n]));
 
         expect(Atomics.xor(array, 1, 0b0001n)).toBe(0b0001n);
-        expect(array).toEqual([0b1111n, 0b0000n]);
+        expect(array).toEqual(new ArrayType([0b1111n, 0b0000n]));
     });
 });