The Tor Browser: js/src/jit-test/tests/self-test/assertDeepEq.js@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 // Tests for the assertEqual function in jit-test/lib/asserts.js

     3 load(libdir + "asserts.js");

     5 function assertNotDeepEq(a, b, options) {

     6     assertThrowsInstanceOf(() => assertDeepEq(a, b, options), Error);

7 }

     9 // primitives

    10 assertDeepEq(undefined, undefined);

    11 assertDeepEq("1", "1");

    12 assertNotDeepEq(1, "1");

    13 assertNotDeepEq(undefined, null);

    14 assertNotDeepEq({}, null);

    16 // objects

    17 assertDeepEq({}, {});

    18 assertDeepEq({one: 1, two: 2}, {one: 1, two: 2});

    19 assertNotDeepEq(Object.freeze({}), {});

    20 assertDeepEq(Object.create(null), Object.create(null));

    21 assertNotDeepEq(Object.create(null, {a: {configurable: false, value: 3}}),

    22                Object.create(null, {a: {configurable: true, value: 3}}));

    23 assertNotDeepEq({one: 1}, {one: 1, two: 2});

    24 assertNotDeepEq({yes: true}, {oui: true});

    25 assertNotDeepEq({zero: 0}, {zero: "0"});

    27 // test the comment

    28 var x = {}, y = {}, ax = [x];

    29 assertDeepEq([ax, x], [ax, y]);  // passes (bogusly)

    30 assertNotDeepEq([ax, x], [ax, y], {strictEquivalence: true});

    31 assertDeepEq([x, ax], [y, ax]);  // passes (bogusly)

    32 assertNotDeepEq([x, ax], [y, ax], {strictEquivalence: true});

    34 // object identity

    35 assertNotDeepEq([x, y], [x, x]);

    36 assertDeepEq([x, y], [x, y]);

    37 assertDeepEq([y, x], [x, y]);

    39 // proto chain

    40 var x = {};

    41 assertDeepEq(Object.create(x), Object.create(x));

    42 assertDeepEq(Object.create({}), Object.create({})); // equivalent but not identical proto objects

    44 // arrays

    45 assertDeepEq([], []);

    46 assertNotDeepEq([], [1]);

    47 assertDeepEq([1], [1]);

    48 assertNotDeepEq([0], [1]);

    49 assertDeepEq([1, 2, 3], [1, 2, 3]);

    50 assertNotDeepEq([1, , 3], [1, undefined, 3]);

    51 var p = [], q = [];

    52 p.prop = 1;

    53 assertNotDeepEq(p, q);

    54 assertNotDeepEq(q, p);

    55 q.prop = 1;

    56 assertDeepEq(q, p);

    58 // functions

    59 assertNotDeepEq(() => 1, () => 2);

    60 assertNotDeepEq((...x) => 1, x => 1);

    61 assertNotDeepEq(function f(){}, function g(){});

    62 var f1 = function () {}, f2 = function () {};

    63 assertDeepEq(f1, f1);

    64 assertDeepEq(f1, f2);  // same text, close enough

    65 f1.prop = 1;

    66 assertNotDeepEq(f1, f2);

    67 f2.prop = 1;

    68 assertDeepEq(f1, f2);

    70 // recursion

    71 var a = [], b = [];

    72 a[0] = a;

    73 b[0] = b;

    74 assertDeepEq(a, b);

    75 a[0] = b;

    76 assertNotDeepEq(a, b);  // [#1=[#1#]] is not structurally equivalent to #1=[[#1#]]

    77 b[0] = a;

    78 assertDeepEq(a, b);

    79 b[0] = [a];  // a[0] === b, b[0] === c, c[0] === a

    80 assertDeepEq(a, b);

    82 // objects that merge

    83 var x = {};

    84 assertDeepEq({x: x}, {x: x});

    85 var y = [x];

    86 assertDeepEq([y], [y]);

    88 // cross-compartment

    89 var g1 = newGlobal(), g2 = newGlobal();

    90 assertDeepEq(g1, g2);

    91 assertDeepEq(g1, g2, {strictEquivalence: true});

    92 Object.preventExtensions(g2.Math.abs);  // make some miniscule change

    93 assertNotDeepEq(g1, g2);

The Tor Browser / file revision