deep-equal-diagnostics/Tests/00-test-common.js

Ultra-fast robust diagnostic testing for strict deep equality

const {deepStrictEqual} = require("../deep-strict-equal.js");
const strictEqual = deepStrictEqual
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('-----------------------------------------------')
function testEnumerable()
{
    console.log('testEnumerable')
    const x = {a:{b:{c:{d:1}}}}
    const y = {a:{b:{c:{d:1}}}}

    x.Q = 7
    Object.defineProperty(y, 'Q',
        {
            value:7,
            enumerable:true
        })

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

testEnumerable()

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

    x.Q = 7
    Object.defineProperty(y, 'Q',
        {
            value:7,
        })

    claim(strictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}
testEnumerable_a();


console.log('-----------------------------------------------')
function testProperties()
{
    console.log("Test testProperties");
    console.log('testProperties')
    const x = new Set([1,2,3,4])
    x.a = 7
    const y = new Set([1,2,3,4])
    claim(strictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}

testProperties()

console.log('-----------------------------------------------')
function testEdgeCase()
{
    console.log("Test testEdgeCase");
    const x = new Map()
    const y = Object.create(Map.prototype)
    claim(strictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}
testEdgeCase()

console.log('-----------------------------------------------')
function testEdgeCase_a()
{
    console.log("Test testEdgeCase_a");
    const x = new Boolean(true)
    const y = Object.create(Boolean.prototype)
    claim(strictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}
testEdgeCase_a()

console.log('-----------------------------------------------')
function testSecondaryNullObjects()
{
    console.log("Test testSecondaryNullObjects");
    const x = Object.create(null)
    const y = Object.create(x)
    claim(strictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}
testSecondaryNullObjects()

console.log('-----------------------------------------------')
function testInternalPrototypes()
{
    console.log("Test testInternalPrototypes");
    const x = Object.create({})
    const y = Object.create({})
    claim(strictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}
testInternalPrototypes()

console.log('-----------------------------------------------')
function testNumberVariants()
{
    console.log("Test testNumberVariants");
    const x = {a:+0}
    const y = {a:-0}
    console.log('assertEqual(x,y) is ' + assertEqual(x,y))
    claim(strictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}

testNumberVariants()

console.log('-----------------------------------------------')
function testNumberVariants_a()
{
    console.log("Test testNumberVariants_a");
    const x = {a:+Infinity}
    const y = {a:-Infinity}
    claim(strictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}

testNumberVariants_a()

console.log('-----------------------------------------------')
function testWeakSets()
{
    console.log("Test testWeakSets");
    const x = {a: new WeakSet()}
    const y = {a: new WeakSet}
    claim(strictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}

testWeakSets()

console.log('-----------------------------------------------')
function testWeakMaps()
{
    console.log("Test testWeakMaps");
    const x = {a: new WeakMap()}
    const y = {a: new WeakMap()}
    claim(strictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}

testWeakMaps()