1 files changed, 111 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/self-test/assertDeepEq.js b/js/src/jit-test/tests/self-test/assertDeepEq.js
new file mode 100644
index 000000000..b2a949abc
--- /dev/null
+++ b/js/src/jit-test/tests/self-test/assertDeepEq.js
@@ -0,0 +1,111 @@
+// Tests for the assertEqual function in jit-test/lib/asserts.js
+
+load(libdir + "asserts.js");
+
+function assertNotDeepEq(a, b, options) {
+    assertThrowsInstanceOf(() => assertDeepEq(a, b, options), Error);
+}
+
+// primitives
+assertDeepEq(undefined, undefined);
+assertDeepEq("1", "1");
+assertNotDeepEq(1, "1");
+assertNotDeepEq(undefined, null);
+assertNotDeepEq({}, null);
+
+// symbols
+assertDeepEq(Symbol(), Symbol());
+assertNotDeepEq(Symbol(), Symbol(""));
+assertDeepEq(Symbol("tweedledum"), Symbol("tweedledum"));
+assertNotDeepEq(Symbol("tweedledum"), Symbol("alice"));
+assertNotDeepEq(Symbol("what-its-called"), Symbol.for("what-its-called"));
+assertNotDeepEq(Symbol.iterator, Symbol.for("Symbol.iterator"));
+assertDeepEq([Symbol(), Symbol(), Symbol()],
+             [Symbol(), Symbol(), Symbol()]);
+var sym = Symbol();
+assertDeepEq([sym, sym], [sym, sym]);
+assertNotDeepEq([sym, sym], [Symbol(), Symbol()]);
+assertNotDeepEq([sym, sym], [Symbol(), sym]);
+var obj1 = {}, obj2 = {};
+obj1[Symbol("x")] = "y";
+obj2[Symbol("x")] = "y";
+assertDeepEq(obj1, obj2);
+
+// objects
+assertDeepEq({}, {});
+assertDeepEq({one: 1, two: 2}, {one: 1, two: 2});
+assertNotDeepEq(Object.freeze({}), {});
+assertDeepEq(Object.create(null), Object.create(null));
+assertNotDeepEq(Object.create(null, {a: {configurable: false, value: 3}}),
+               Object.create(null, {a: {configurable: true, value: 3}}));
+assertNotDeepEq({one: 1}, {one: 1, two: 2});
+assertNotDeepEq({yes: true}, {oui: true});
+assertNotDeepEq({zero: 0}, {zero: "0"});
+
+// test the comment
+var x = {}, y = {}, ax = [x];
+assertDeepEq([ax, x], [ax, y]);  // passes (bogusly)
+assertNotDeepEq([ax, x], [ax, y], {strictEquivalence: true});
+assertDeepEq([x, ax], [y, ax]);  // passes (bogusly)
+assertNotDeepEq([x, ax], [y, ax], {strictEquivalence: true});
+
+// object identity
+assertNotDeepEq([x, y], [x, x]);
+assertDeepEq([x, y], [x, y]);
+assertDeepEq([y, x], [x, y]);
+
+// proto chain
+var x = {};
+assertDeepEq(Object.create(x), Object.create(x));
+assertDeepEq(Object.create({}), Object.create({})); // equivalent but not identical proto objects
+
+// arrays
+assertDeepEq([], []);
+assertNotDeepEq([], [1]);
+assertDeepEq([1], [1]);
+assertNotDeepEq([0], [1]);
+assertDeepEq([1, 2, 3], [1, 2, 3]);
+assertNotDeepEq([1, , 3], [1, undefined, 3]);
+var p = [], q = [];
+p.prop = 1;
+assertNotDeepEq(p, q);
+assertNotDeepEq(q, p);
+q.prop = 1;
+assertDeepEq(q, p);
+
+// functions
+assertNotDeepEq(() => 1, () => 2);
+assertNotDeepEq((...x) => 1, x => 1);
+assertNotDeepEq(function f(){}, function g(){});
+var f1 = function () {}, f2 = function () {};
+assertDeepEq(f1, f1);
+assertDeepEq(f1, f2);  // same text, close enough
+f1.prop = 1;
+assertNotDeepEq(f1, f2);
+f2.prop = 1;
+assertDeepEq(f1, f2);
+
+// recursion
+var a = [], b = [];
+a[0] = a;
+b[0] = b;
+assertDeepEq(a, b);
+a[0] = b;
+assertNotDeepEq(a, b);  // [#1=[#1#]] is not structurally equivalent to #1=[[#1#]]
+b[0] = a;
+assertDeepEq(a, b);
+b[0] = [a];  // a[0] === b, b[0] === c, c[0] === a
+assertDeepEq(a, b);
+
+// objects that merge
+var x = {};
+assertDeepEq({x: x}, {x: x});
+var y = [x];
+assertDeepEq([y], [y]);
+
+// cross-compartment
+var g1 = newGlobal(), g2 = newGlobal();
+assertDeepEq(g1, g2);
+assertDeepEq(g1, g2, {strictEquivalence: true});
+Object.preventExtensions(g2.Math.abs);  // make some miniscule change
+assertNotDeepEq(g1, g2);