deep-equal-diagnostics/Tests/01-not-equal-tests.js

Ultra-fast robust diagnostic testing for strict deep equality

const {deepStrictEqual, deepEquivalent} = 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('-----------------------------------------------------------------');
function test_1()
{
    console.log("Test 1");
    // `Err #1 source is NaN but target is not`
    const x = {a:{b:{c:NaN}}}
    const y = {a:{b:{c:Infinity}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
    console.log(deepStrictEqual.message)
}
test_1();


console.log('-----------------------------------------------------------------');
function test_2()
{
    console.log("Test 2");
    // 'Err #2 source is -0, 0, or +0 but target is not'
    const x = {a:{b:{c:+0}}}
    const y = {a:{b:{c:Infinity}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
    console.log(deepStrictEqual.message)
}
test_2();


console.log('-----------------------------------------------------------------');
function test_2a()
{
    console.log("Test 2a");
    const x = {a:{b:{c:+0}}}
    const y = {a:{b:{c:-0}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_2a()


console.log('-----------------------------------------------------------------');
function test_3()
{
    console.log("Test 3");
    // `Err #3 source is ${x}, but target is not equal to it`
    const x = {a:{b:{c:+Infinity}}}
    const y = {a:{b:{c:Infinity}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(deepStrictEqual(x,y), 'strictEqual(x,y)')
}
test_3();


console.log('-----------------------------------------------------------------');
function test_3a()
{
    console.log("Test 3a");
    // `Err #3 source is ${x}, but target is not equal to it`
    const x = {a:{b:{c:+Infinity}}}
    const y = {a:{b:{c:-Infinity}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_3a();


console.log('-----------------------------------------------------------------');
function test_4()
{
    console.log("Test 4");
    // `Err #4 target is NaN but target is not`
    const x = {a:{b:{c:new Boolean(true)}}}
    const y = {a:{b:{c:NaN}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_4();


console.log('-----------------------------------------------------------------');
function test_5()
{
    console.log("Test 5");
    // `Err #5 target is -0, 0, or +0 but source is not`
    const x = {a:{b:{c:new Boolean(true)}}}
    const y = {a:{b:{c:-0}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_5();


console.log('-----------------------------------------------------------------');
function test_6()
{
    console.log("Test 6");
    // `Err #6 target is ${x}, but source is not equal to it`
    const x = {a:{b:{c:new Boolean(true)}}}
    const y = {a:{b:{c:"cat"}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
    console.log(deepStrictEqual.message)
}
test_6();

console.log('-----------------------------------------------------------------');
function test_6a()
{
    console.log("Test 6a");
    // `Err #6 target is ${x}, but source is not equal to it`
    const x = {a:{b:{c:new Boolean(true)}}}
    const y = {a:{b:{c:Object.create(Boolean.prototype)}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
    console.log(deepStrictEqual.message)
}
test_6a();


console.log('-----------------------------------------------------------------');
function test_7()
{
    console.log("Test 7");
    // `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 = {}
    console.log('assertEqual(x,y) is ' + assertEqual(x,y))
    console.log('deepStrictEqual(x,y) is ' + deepStrictEqual(x,y))

    //claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    //claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
    //console.log(deepStrictEqual.message)
}
test_7();


console.log('-----------------------------------------------------------------');
function test_8()
{
    console.log("Test 8");
    // `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), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')

}
test_8();

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



console.log('-----------------------------------------------------------------');
function test_10()
{
    console.log("Test 10");
    // `Err #10 source and target are reference equal but shouldn't be`
    const b = new Boolean(true)
    const x = {a:{b:{c:b}}}
    const y = {a:{b:{c:b}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(deepStrictEqual(x,y), 'strictEqual(x,y)')
}
test_10();


console.log('-----------------------------------------------------------------');
function test_11()
{
    console.log("Test 11");
    // `Err #11 source and target have different native types`
    const x = {a:{b:{c:new Boolean(true)}}}
    const y = {a:{b:{c:Object.create(Boolean.prototype)}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_11();


console.log('-----------------------------------------------------------------');
function test_12()
{
    console.log("Test 12");
    // `Err #12 source and target have different internal prototypes`
    const x = Object.create(Object.create(null))
    const y = Object.create(Object.create(null))
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_12();


console.log('-----------------------------------------------------------------');
function test_13()
{
    console.log("Test 13");
    // `Err #13 source and target have a different number of properties`
    const x = {a:{b:{c:{d:1}}}}
    const y = {a:{b:{c:{d:1,e:2}}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_13();


console.log('-----------------------------------------------------------------');
function test_14()
{
    console.log("Test 14");
    // `Err #14 source has property ${p} but target doesn't`
    const x = {a:{b:{c:{d:1}}}}
    const y = {a:{b:{c:{e:2}}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_14();

console.log('-----------------------------------------------------------------');
function test_15()
{
    console.log("Test 15");
    // `Err #15 property ${p} a getter/setter in target but not in source`
    const x = {a:{b:{c:{d:2}}}}
    const y = {a:{b:{c:{get d(){return 2}}}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
   // claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_15();





console.log('-----------------------------------------------------------------');
function test_17()
{
    console.log("Test 17");
    // `Err #17 property ${p} is a getter in source but not in target`
    const x = {a:{b:{c:{get d(){return 1}}}}}
    const y = {a:{b:{c:{d:1}}}}
    console.log('assertEqual(x,y) is' + assertEqual(x,y))
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
   // claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
    console.log(deepStrictEqual.message)
}
test_17();


console.log('-----------------------------------------------------------------');
function test_18()
{
    console.log("Test 18");
    // `Err #18 getter property ${p} has different bodies in source and target`
    const x = {a:{b:{c:{get d(){return 1}}}}}
    const y = {a:{b:{c:{get d(){return 0 + 1}}}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}
test_18();


console.log('-----------------------------------------------------------------');
function test_19()
{
    console.log("Test 19");
    // `Err #19 property ${p} is a setter in source but not in target`
    const x = {a:{b:{c:{get d(){return 1}, set d(value){}}}}}
    const y = {a:{b:{c:{get d(){return 1}}}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}
test_19();


console.log('-----------------------------------------------------------------');
function test_20()
{
    console.log("Test 20");
    // `Err #20 setter property ${p} has different bodies in source and target` ?? ASSERT??
    const x = {a:{b:{c:{get d(){return 1}, set d(value){}}}}}
    const y = {a:{b:{c:{get d(){return 1}, set d(value){const zebra = value}}}}}
    console.log('assertEqual(x,y) is ' + assertEqual(x,y))
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}
test_20();


console.log('-----------------------------------------------------------------');
function test_21()
{
    console.log("Test 21");
    // `Err #21 property ${p} enumerability in source and target is ${pdX.enumerable} and ${pdY.enumerable}`
    //let x = {a:{b:{c:{d: 1}}}}
    //let y = {a:{b:{c:{d:1}}}} // d:1 proves javascript bug
    let x = {a:1}
    let y = {a:1}
    Object.defineProperty(y, 'a',
        {
            value:1,
            configurable:true,
            writable:true,
        })
    console.log('assertEqual(x,y) is' + assertEqual(x,y))
    console.log('deepStrictEqual(x,y) is' + deepStrictEqual(x,y))
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    //claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_21();


console.log('-----------------------------------------------------------------');
function test_22()
{
    console.log("Test 22");
    // `Err #22 property ${p} configurability in source and target is ${pdX.configurable} and ${pdY.configurable}`
    let x = {a:{b:{c:{d:1}}}}
    let y = {a:{b:{c:{d:1}}}}
    Object.defineProperty(y.a.b.c, 'd',
        {
            value:1,
            configurable:false,
            writable:true,
        })
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}

test_22()
console.log('-----------------------------------------------------------------');
function test_23()
{
    console.log("Test 23");
    // `Err #23 source ${x.constructor.name} is ${x.valueOf()} but target ${x.constructor.name} is ${y.valueOf()}}`
    const x = new Boolean(true)
    const y = new Boolean(false)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_23();


console.log('-----------------------------------------------------------------');
function test_24()
{
    console.log("Test 24");
    // `Err #24 source RegExp is ${x.toString()} but target RegExp is ${y.toString()}`
    const x = /abc/g
    const y = /abc/
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_24();


console.log('-----------------------------------------------------------------');
function test_25()
{
    console.log("Test 25");
    // `Err #25 source and target Functions have different toStrings()}`
    const x = function x(){}
    const y = function y(){}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_25();


console.log('-----------------------------------------------------------------');
function test_26()
{
    console.log("Test 26: Warning! Assert bug ");
    // `Err #26 source is WeakSet[Object] but target is WeakSet`
    const x = Object.create(WeakSet.prototype)
    const y = new WeakSet()
    //claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}

test_26()

console.log('-----------------------------------------------------------------');
function test_27()
{
    console.log("Test 27 Error #27 preempted by Error #10");
    // `Err #27 source and target WeakSet[Object]s are reference equal`
    const wso = Object.create(WeakSet.prototype)
    let x = {a:{b:{c:{d:wso}}}}
    let y = {a:{b:{c:{d:wso}}}}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(deepStrictEqual(x,y), 'strictEqual(x,y)')
}
test_27();


console.log('-----------------------------------------------------------------');
function test_28() //ASSERTDEEPSTRICTEQUAL  thins two WeakSets are equivalent
{
    console.log("Test 28");
    // `Err #28 source is WeakSet but target not reference equal`
    const x = new WeakSet()
    const y = new WeakSet()
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
}
test_28()

console.log('-----------------------------------------------------------------');
function test_29()
{
    console.log("Test 29: Warning! Assert bug");
    // `Err #29 source is WeakMap[Object] but target is WeakMap`
    const x = Object.create(WeakMap.prototype)
    const y = new WeakMap()
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_29();

console.log('-----------------------------------------------------------------');
function test_30()
{
    console.log("Test 30 Error #30 preempted by Error #10");
    // `Err #30 source and target WeakMap[Object]s are reference equal`
    const x = Object.create(WeakMap.prototype)
    const y = x
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(deepStrictEqual(x,y), 'strictEqual(x,y)')
}
test_30();


console.log('-----------------------------------------------------------------');
function test_31()
{// DeepStrictEqual Failed
    console.log("Test 31: Warning! Assert bug");
    // `Err #31 source is  WeakMap but target not reference equal`
    const x = new WeakMap()
    const y = Object.create(WeakMap.prototype)
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_31();


console.log('-----------------------------------------------------------------');
function test_32()
{
    console.log("Test 32");
    // `Err #32 source is Set[Object] but target is Set`

    const x = Object.create(Set.prototype)
    const y = new Set()
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_32();



console.log('-----------------------------------------------------------------');
function test_33()
{
    console.log("Test 33 Error #30 preempted by Error #10");
    // `Err #33 source and target Set[Object]s are reference equal`
    const x = Object.create(Set.prototype)
    const y = x
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(deepStrictEqual(x,y), 'strictEqual(x,y)')
}
test_33();


console.log('-----------------------------------------------------------------');
function test_34()
{
    console.log("Test 34");
    // `Err #34 source and target d-types differ`
    const x = new Set()
    const y = Object.create(Set.prototype)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_34();


console.log('-----------------------------------------------------------------');
function test_35()
{
    console.log("Test 35 Error ");
    // `Err #35 source Set has more members than target Set`
    const x = new Set([1,2,3,4])
    const y = new Set([1,2,3])
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_35();


console.log('-----------------------------------------------------------------');
function test_36()
{
    console.log("Test 36");
    // `Err #36 source Set has fewer members than target Set`
    const x = new Set([1,2,3,4])
    const y = new Set([1,2,3,4,5])
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_36();


console.log('-----------------------------------------------------------------');
function test_37()
{
    console.log("Test 37");
    // `Err #37 source is Map[Object] but target is Map`
    const x = {a:Object.create(Map.prototype)}
    const y = {a:new Map()}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_37();


console.log('-----------------------------------------------------------------');
function test_38()
{
    console.log("Test 38 Error #38 preempted by Error #10");
    // `Err #38 source and target Map[Object]s are reference equal`
    const mo = Object.create(Map.prototype)
    const x = {a:mo}
    const y = {a:mo}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(deepStrictEqual(x,y), 'strictEqual(x,y)')
}

test_38();


console.log('-----------------------------------------------------------------');
function test_39()
{
    console.log("Test 39");
    // `Err #39 source and target d-types differ`
    const x = {a:new Map()}
    const y = {a:Object.create(Map.prototype)}
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_39();


console.log('-----------------------------------------------------------------');
function test_40()
{
    console.log("Test 40");
    // `Err #40 source Map has more key-value pairs than target Map`
    const x = new Map([["cat",1], ["dog", 2], ["hamster", 3]])
    const y = new Map([["cat",1], ["dog", 2]])
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_40();


console.log('-----------------------------------------------------------------');
function test_41()
{
    console.log("Test 41");
    // `Err #41 source Map has fewer key-value pairs than target Map`
    const x = new Map([["cat",1], ["dog", 2]])
    const y = new Map([["cat",1], ["dog", 2], ["hamster", 3]])
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_41();


console.log('-----------------------------------------------------------------');
function test_42()
{
    console.log("Test 42");
    // `Err #42 source is ArrayBuffer[Object] but target is ArrayBuffer`

    const x = Object.create(ArrayBuffer.prototype)
    const y = new ArrayBuffer(8)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')

}
test_42();


console.log('-----------------------------------------------------------------');
function test_43()
{
    console.log("Test 43 Error #43 preempted by Error #10");
    // `Err #43 source and target ArrayBuffer[Object]s are reference equal`
    const x = Object.create(ArrayBuffer.prototype)
    const y = x
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(deepStrictEqual(x,y), 'strictEqual(x,y)')
}
test_43();


console.log('-----------------------------------------------------------------');
function test_44()
{
    console.log("Test 44");
    // `Err #44 source and target d-types differ`
    const x = new ArrayBuffer(4)
    const y = Object.create(ArrayBuffer.prototype)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_44();


console.log('-----------------------------------------------------------------');
function test_45()
{
    console.log("Test 45");
    // `Err #45 source.byteLength = ${x.byteLength} but target.byteLength = ${y.byteLength}`
    const x = new ArrayBuffer(4)
    const y = new ArrayBuffer(8)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_45();


console.log('-----------------------------------------------------------------');
function test_46()
{
    console.log("Test 46");
    // `Err #46 source[i] = ${xView[i]} but target[i] = ${yView[i]}}`
    const x = new Uint8Array([1,2,3,4]).buffer
    const y = new Uint8Array([1,2,30,4]).buffer
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_46();


console.log('-----------------------------------------------------------------');
function test_47()
{
    console.log("Test 47");
    // `Err #47 source is DataView[Object] but target is DataView`
    const x = Object.create(DataView.prototype)
    const y = new DataView(new Uint8Array([1,2,3]).buffer)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_47();


console.log('-----------------------------------------------------------------');
function test_48()
{
    console.log("Test 48 Error #48 preempted by Error #10");
    // `Err #48 source and target DataView[Object]s are reference equal`
    const x = Object.create(DataView.prototype)
    const y = x
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(deepStrictEqual(x,y), 'strictEqual(x,y)')
}
test_48();


console.log('-----------------------------------------------------------------');
function test_49()
{
    console.log("Test 49");
    // `Err #49 source and target d-types differ`
    const x = new DataView(new Uint8Array([1,2,3]).buffer)
    const y = Object.create(DataView.prototype)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_49();


console.log('-----------------------------------------------------------------');
function test_50()
{
    console.log("Test 50");
    // `Err #50 source.byteOffset = ${x.byteOffset} but target.byteOffset = ${y.byteOffset}`
    const buffer1 = new Uint8Array([1,2,3,4,5,6,7,8,9,10]).buffer
    const buffer2 = new Uint8Array([1,2,3,4,5,6,7,8,9,10]).buffer
    const x = new DataView(buffer1, 1)
    const y = new DataView(buffer2, 2)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_50();


console.log('-----------------------------------------------------------------');
function test_50a()
{
    console.log("Test 50a");
    // `Err #50 source.byteOffset = ${x.byteOffset} but target.byteOffset = ${y.byteOffset}`
    const buffer = new Uint8Array([1,2,3,4,5,6,7,8,9,10]).buffer
    const x = new DataView(buffer, 1)
    const y = new DataView(buffer, 2)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_50a();


console.log('-----------------------------------------------------------------');
function test_51()
{
    console.log("Test 51");
    // `Err #51 source.byteLength = ${x.byteLength} but target.byteLength = ${y.byteLength}`
    const buffer1 = new Uint8Array([1,2,3,4,5,6,7,8,9,10]).buffer
    const buffer2 = new Uint8Array([1,2,3,4,5,6,7,8,9,10]).buffer
    const x = new DataView(buffer1, 1,3)
    const y = new DataView(buffer2, 1,4)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_51();


console.log('-----------------------------------------------------------------');
function test_52()
{
    console.log("Test 52");
    // `Err #52 source.byteOffset = ${x.byteOffset} but target.byteOffset = ${y.byteOffset}`
    const buffer1 = new Uint8Array([1,2,3,4,5,6,7,8]).buffer
    const buffer2 = new Uint8Array([1,2,3,4,5,6,7,8]).buffer
    const x = new Uint8Array(buffer1, 1)
    const y = new Uint8Array(buffer2, 2)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_52();


console.log('-----------------------------------------------------------------');
function test_53()
{
    console.log("Test 53");
    // `Err #53 source.byteLength = ${x.byteLength} but target.byteLength = ${y.byteLength}`
    const buffer1 = new Uint8Array([1,2,3,4,5,6,7,8]).buffer
    const buffer2 = new Uint8Array([1,2,3,4,5,6,7,8]).buffer
    const x = new Uint8Array(buffer1, 1,3)
    const y = new Uint8Array(buffer2, 1,4)
    claim(deepStrictEqual(x,y) === assertEqual(x,y), 'strictEqual(x,y) === assertEqual(x,y)')
    claim(!deepStrictEqual(x,y), '!strictEqual(x,y)')
}
test_53();