deep-equal-diagnostics/Tests/05-test-circles.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 1");
    // `Err #7 source${path} = source${xSeenPath} but target${path} != target${xSeenPath}`
    const x = {a:{b:{c:1}}}
    const y = {a:{b:{c:1}}}
    x.a.b.d = x.a
    y.a.b.d = x.a //{}
    claim(deepStrictEqual(x,y) === assertEqual(x,y),'deepStrictEqual(x,y) === assertEqual(x,y)')

}
test_1();
console.log('-----------------------------------------------------------------');
function test_2()
{
    console.log("Test 2");
    // `Err #7 source${path} = source${xSeenPath} but target${path} != target${xSeenPath}`
    //const x = {a:{b:{c:1}}}
    //const y = {a:{b:{c:1}}}
    const x = {}
    x.a = {}
    x.a.a = x
    const y = {}
    y.a = {}
    y.a.a = {}
    y.a.a.a = y
    claim(deepStrictEqual(x,y) === assertEqual(x,y),'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_2();

console.log('-----------------------------------------------------------------');
function test_3()
{
    console.log("Test 3");
    // `Err #7 source${path} = source${xSeenPath} but target${path} != target${xSeenPath}`
    //const x = {a:{b:{c:1}}}
    //const y = {a:{b:{c:1}}}
    const x = {}
    x.a = {}
    x.a.a = x
    const y = {}
    y.a = {}
    y.a.a = {}
    y.a.a.a = y.a
    claim(deepStrictEqual(x,y) === assertEqual(x,y),'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_3();

console.log('-----------------------------------------------------------------');
function test_4()
{
    console.log("Test 4");
    // `Err #7 source${path} = source${xSeenPath} but target${path} != target${xSeenPath}`
    const x = {}
    x.a = {}
    x.a.a = x
    const y = {}
    y.a = {}
    y.a.a = {}
    y.a.a.a = y.a.a
    claim(deepStrictEqual(x,y) === assertEqual(x,y),'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_4();

console.log('-----------------------------------------------------------------');
function test_5()
{
    console.log("Test 5");
    // `Err #8 source${path} = source${xSeenPath} but target${path} = target${ySeenPath}`
    const x = {a:{b:{c:+Infinity}}}
    const y = {a:{b:{c:+Infinity}}}
    x.a.b.d = x.a
    y.a.b.d = y
    claim(deepStrictEqual(x,y) === assertEqual(x,y),'deepStrictEqual(x,y) === assertEqual(x,y)')

}
test_5();

console.log('-----------------------------------------------')
function test_Circular()
{
    console.log("Test test_Circular");
    // `Err #7 source${path} = source${xSeenPath} but target${path} != target${xSeenPath}`
    const x = {a:{b:{c:1}}}
    const y = {a:{b:{c:1}}}
    x.a.b.d = x
    y.a.b.d = x
    console.log('assertEqual(x,y) is ' + assertEqual(x,y))
    claim(deepStrictEqual(x,y) === assertEqual(x,y),'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_Circular();

console.log('-----------------------------------------------')
function test_Circularb()
{
    console.log("Test test_Circularb");
    // `Err #7 source${path} = source${xSeenPath} but target${path} != target${xSeenPath}`
    const x = {a:{b:{c:1}}}
    const y = {a:{b:{c:1}}}
    x.a.b.d = x
    y.a.b.d = y
    claim(deepStrictEqual(x,y) === assertEqual(x,y),'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_Circularb();

console.log('-----------------------------------------------')
function test_Duplicate()
{
    console.log("Test test_Duplicate");
    // `Err #7 source${path} = source${xSeenPath} but target${path} != target${xSeenPath}`
    const x = {}
    const y = {}
    x.a = {}
    x.a.a = {}
    x.a.a.a = {}
    x.b = {}
    x.b.b = {}
    x.b.b.b = x.a.a.a

    y.a = {}
    y.a.a = {}
    y.a.a.a = {}
    y.b = {}
    y.b.b = {}
    y.b.b.b = {}
    claim(deepStrictEqual(x,y) === assertEqual(x,y),'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_Duplicate();

console.log('-----------------------------------------------')
function test_Circle_In_Map() {
    console.log("test_Circle_In_Map");

    const ax = { a: 1 }
    const bx = { b: 2 }
    const cx = { c: 2 }
    const x = new Map()
    x.set(ax, bx)
    x.set(bx, ax)
    const ay = { a: 1 }
    const by = { b: 2 }
    const cy = { c: 2 }
    const y = new Map()
    x.set(ax, bx)
    x.set(bx, ax)
    y.set(ay, by)
    y.set(by, cy)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_Circle_In_Map();

console.log('-----------------------------------------------')
function test_Circle_In_Map_Set() {
    console.log("test_Circle_In_Map_Set");
    const ax = { a: 1 }
    const bx = { b: 2 }
    const cx = { c: 2 }
    const x = { p: new Set([ax, bx, cx]), q: new Map([[cx, bx]]) }
    const ay = { a: 1 }
    const by = { b: 2 }
    const cy = { c: 2 }
    const y = { p: new Set([ay, by, cy]), q: new Map([[cy, ay]]) }
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'deepStrictEqual(x,y) === assertEqual(x,y)')
}
test_Circle_In_Map_Set();