deep-equal-diagnostics/Tests/03-test-from-previous-version.js

Ultra-fast robust diagnostic testing for strict deep equality

const {deepStrictEqual} = require('../deep-strict-equal.js')
const assert = require('assert')
function assertEqual(x,y)
{
    try {
        assert.deepStrictEqual(x,y)
        return true
    } catch(e) { return false }
}

function claim(b, message)
{
    if(b) console.log(`\u2713 ${message} is true`)
    else console.log(`\u2639  ${message} is false: should be true`)
    console.log(deepStrictEqual.message)
}


console.log('-----------------------------------------------------------------');
function test_1()
{
    console.log("Test 1a");
    claim(deepStrictEqual(8,8), 'deepStrictEqual(8,8)')

    console.log('-----------------------------------------------------------------');
    console.log("Test 1b");
    let x = {a:{b:{c:{d:"cat"}}}};
    let y = {a:{b:{c:{d:"cat"}}}};

    claim(deepStrictEqual(x,y), 'deepStrictEqual(x,y)')

    console.log('-----------------------------------------------------------------');
    console.log("Test 1c");
    x = new Date();
    y = new Date(x.valueOf())

    claim(deepStrictEqual(x,y), 'deepStrictEqual(x,y)')
}

test_1();

console.log('-----------------------------------------------------------------');
function test_2()
{
    console.log("Test 2");

    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};
     x.a.b.c.e = 8;
     y.a.b.c.e = 9;
     claim(!deepStrictEqual(x,y), '!deepStrictEqual(x,y)')
}

test_2();

console.log('-----------------------------------------------------------------');
function test_3() // Property Descriptor
{
    console.log("Test 3");

    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};
    x.a.b.c.e = 8;
    Object.defineProperty(y.a.b.c, "e",
        {
            value:8
        })
    claim(!deepStrictEqual(x,y), '!deepStrictEqual(x,y)')
}


test_3();

console.log('-----------------------------------------------------------------');
function test_4() // frozen state
{
    console.log("Test 4");
    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};
    Object.freeze(x.a.b.c);

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
    //if(deepStrictEqual(x,y)) console.log("\u2639 equivalent")
    //else console.log("\u2713 not equivalent")
    //console.log(deepStrictEqual.message);
}

test_4();


console.log('-----------------------------------------------------------------');
function test_5()
{
    console.log("Test 5");
    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};
    x.a.b.c.d = new Date();
    y.a.b.c.d = Object.create(Date.prototype);

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}

test_5();


console.log('-----------------------------------------------------------------');
function test_6()
{
    console.log("Test 6");
    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};
    x.a.b.c.e = undefined;

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}

test_6();


console.log('-----------------------------------------------------------------');
function test_7()  // circular
{
    console.log("Test 7 (has circular reference)");
    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};
    x.a.b.c.d = x.a.b;
    y.a.b.c.d = y.a;

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_7();

console.log('-----------------------------------------------------------------');
function test_8()  // circular
    {
    console.log("Test 8 (has circular reference)");
    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};
    x.a.b.c.d = x.a.b;

        claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}

test_8();

console.log('-----------------------------------------------------------------');
function test_9()  // circular
{
    console.log("Test 9 (has circular reference)");
    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};
    y.a.b.c.d = y.a.b;

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_9();


console.log('-----------------------------------------------------------------');
function test_10()  // getter/setter
{
    console.log("Test 10");
    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};

    Object.defineProperty(x.a.b.c, 'e',
        {
            get:function(){return 1;}
        });
    Object.defineProperty(y.a.b.c, 'e',
        {
            get:function(){return 0 + 1;}
        });

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_10();

console.log('-----------------------------------------------------------------');
function test_11()   // property descriptor
{
    console.log("Test 11");
    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};

    Object.defineProperty(y.a.b.c, 'd',
        {
            get:function(){return 'cat';}
        });
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_11();


console.log('-----------------------------------------------------------------');
function test_12()
{
    console.log("Test 12");

    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};

    x.a.b.c.e = Object.create(null);
    y.a.b.c.e = {}

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_12();


console.log('-----------------------------------------------------------------');
function test_13()
{
    console.log("Test 13");

    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};

    x.a.b.c.e = Object.create({});
    y.a.b.c.e = Object.create({});

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_13();


console.log('-----------------------------------------------------------------');
function test_14()
{
    console.log("Test 14");

    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};

    x.a.b.c.e = new Set([x.a]);
    y.a.b.c.e = new Set([y.a.b]);

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_14();


console.log('-----------------------------------------------------------------');
function test_15()
{
    console.log("Test 15");

    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};

    x.a.b.c.e = new Set([x.a]);
    y.a.b.c.e = new Set([5]);

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_15();


console.log('-----------------------------------------------------------------');
function test_16()
{

    console.log('Test 16')
    let x = {q:100}, y = {q:101};
    x.a = y;
    y.b = x;
    let z = {M:x, N:y};

    let xx = {q:100}, yy = {q:101};
    xx.a = yy;
    yy.b = xx;
    let zz = {M:xx, N:yy};

    let a_bool = new Boolean(true);
    a_bool.cat = "meouzer";
    a_bool.o = z;

    let abool_2 = new Boolean(true);
    abool_2.cat = "meouzer";
    abool_2.o = zz;

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')

}
test_16();


console.log('-----------------------------------------------------------------');
function test_17()
{
    console.log("Test 17");
    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};
    x.a.b.c.e = NaN;
    y.a.b.c.e = NaN;

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_17();


console.log('-----------------------------------------------------------------');
// make sure test
// (1) getter vs value

function test_18() // getter
{
    console.log("Test 18");
    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};

    x.a.b.c.e = 7;
    Object.defineProperty(y.a.b.c, 'e',
        {
            get:function(){return 7;},
            enumerable:true,
        })

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_18();

console.log('-----------------------------------------------------------------');
function test_19()
{
    console.log("Test 19");
    const x = {a:{b:{c:{d:"cat"}}}};
    const y = {a:{b:{c:{d:"cat"}}}};

    x.a.b.c.e = new Boolean(true);
    y.a.b.c.e = new Boolean(false);

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_19();


console.log('-----------------------------------------------------------------');
function test_20()
{
    console.log("Test 20");
    const x = {a:{b:{c:{d:"cat", get e(){return 20;}}}}};
    const y = {a:{b:{c:{d:"cat"}}}};

    Object.defineProperty(y.a.b.c, 'e',
        {
            get: function(){return 20;},
            configurable:true,
            enumerable:true
        })

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_20();


console.log('-----------------------------------------------------------------');
function test_21a()
{
    console.log("Test 21a");
    const foo = function foobar(){return "give me a foobar";}
    const bar = function foobar(){return "give me a foobar";}
    const x = {a:{b:{c:{d:foo}}}};
    const y = {a:{b:{c:{d:foo}}}};

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_21a();


function test_21b()
{
    console.log("Test 21b");
    const foo = function foobar(){return "give me a foobar";}
    const bar = function foobar(){return "give me a foobar";}
    const x = {a:{b:{c:{d:foo}}}};
    const y = {a:{b:{c:{d:bar}}}};

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')

}
test_21b();

console.log('-----------------------------------------------------------------');
function test_22()
{
    console.log("Test 22");
    const foo = function foobar(){return "give me a foobar";}
    const bar = function foobar(){return "give me a foobar";}
    const x = {a:{b:{c:{d:foo}}}};
    const y = {a:{b:{c:{d:foo}}}};

    const ws = new Set([Function]);


    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_22();


console.log('-----------------------------------------------------------------');
function test_23()
{
    console.log("Test 23");
    const foo = function foobar(){return "give me a foobar";}
    const bar = function foobar(){return "give me a foobar";}
    const x = {a:{b:{c:{d:foo}}}};
    const y = {a:{b:{c:{d:bar}}}};

    console.log('assertEqual(x,y) is ' + assertEqual(x,y))

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_23();


console.log('-----------------------------------------------------------------');
function test_24()
{
    console.log("Test 24");
    const b = new Boolean(true);
    const c = new Boolean(true);
    const x = {a:{b:{c:{d:b}}}};
    const y = {a:{b:{c:{d:c}}}};

   // const ws = new Set([Boolean]);

    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_24();


console.log('-----------------------------------------------------------------');
function test_25()
{
    console.log("Test 25a");
    const b = new ArrayBuffer(4);
    const c = new ArrayBuffer(4);
    const B = new DataView(b)
    const C = new DataView(c);
    B.setInt8(0, 2)
    C.setInt8(0, 2)
    B.setInt8(1, 2)
    C.setInt8(1, 3)

    if(deepStrictEqual(b,c))console.log("\u2639 equivalent")
    else console.log("\u2713 not equivalent")
    console.log(deepStrictEqual.message);

    console.log('-----------------------------------------------------------------');
    console.log("Test 25b");
    if(deepStrictEqual(B,C))console.log("\u2639 equivalent")
    else console.log("\u2713 not equivalent")
    console.log(deepStrictEqual.message);
}
test_25();