deep-copy-diagnostics/Tests/00-edge-cases.js

Ultra-fast definitive testing for deep copies and deep copy algorithms

const {deepEquivalent} = require("../deep-equivalent.js");

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

console.log('-----------------------------------------------------------------');
function test_Boolean()
{
    console.log("Test test_Boolean");
    const x = new Boolean(false)
    const y = Object.create(Boolean.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_Boolean();

console.log('-----------------------------------------------------------------');
function test_Number()
{
    console.log("Test test_Number");
    const x = new Number(7)
    const y = Object.create(Number.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_Number();

console.log('-----------------------------------------------------------------');
function test_String()
{
    console.log("Test test_String");
    const x = new String('cat')
    const y = Object.create(String.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_String();

console.log('-----------------------------------------------------------------');
function test_Date()
{
    console.log("Test test_Date");
    const x = new Date(7)
    const y = Object.create(Date.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_Date();

console.log('-----------------------------------------------------------------');
function test_RegExp()
{
    console.log("Test test_RegExp");
    const x = /abc/
    const y = Object.create(RegExp.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_RegExp();

console.log('-----------------------------------------------------------------');
function test_Error()
{
    console.log("Test test_Error");
    const x = new Error('msg')
    const y = Object.create(Error.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_Error();

console.log('-----------------------------------------------------------------');
function test_EvalError()
{
    console.log("Test test_EvalError");
    const x = new EvalError('msg')
    const y = Object.create(EvalError.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_EvalError();

console.log('-----------------------------------------------------------------');
function test_RangeError()
{
    console.log("Test test_RangeError");
    const x = new RangeError('msg')
    const y = Object.create(RangeError.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_RangeError();

console.log('-----------------------------------------------------------------');
function test_SyntaxError()
{
    console.log("Test test_SyntaxError");
    const x = new SyntaxError('msg')
    const y = Object.create(SyntaxError.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_SyntaxError();

console.log('-----------------------------------------------------------------');
function test_TypeError()
{
    console.log("Test test_TypeError");
    const x = new TypeError('msg')
    const y = Object.create(TypeError.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_TypeError();

console.log('-----------------------------------------------------------------');
function test_URIError()
{
    console.log("Test test_URIError");
    const x = new URIError('msg')
    const y = Object.create(URIError.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_URIError();

console.log('-----------------------------------------------------------------');
function test_Int8Array()
{
    console.log("Test test_Int8Array");
    const x = new Int8Array('msg')
    const y = Object.create(Int8Array.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_Int8Array();

console.log('-----------------------------------------------------------------');
function test_WeakSet()
{
    console.log("Test test_WeakSet");
    const x = new WeakSet()
    const y = Object.create(WeakSet.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_WeakSet();

console.log('-----------------------------------------------------------------');
function test_WeakMap()
{
    console.log("Test test_WeakMap");
    const x = new WeakMap()
    const y = Object.create(WeakMap.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_WeakMap();

console.log('-----------------------------------------------------------------');
function test_Set()
{
    console.log("Test test_Set");
    const x = new Set()
    const y = Object.create(Set.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_Set();

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

test_Map();

console.log('-----------------------------------------------------------------');
function test_ArrayBuffer()
{
    console.log("Test test_ArrayBuffer");
    const x = new ArrayBuffer(8)
    const y = Object.create(ArrayBuffer.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_ArrayBuffer();


console.log('-----------------------------------------------------------------');
function test_DataView()
{
    console.log("Test test_DataView");
    const x = new DataView(new ArrayBuffer(8))
    const y = Object.create(DataView.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_DataView();


console.log('-----------------------------------------------------------------');
function test_Buffer()
{
    console.log("Test test_Buffer");
    const x = Buffer.alloc(8)
    const y = Object.create(Buffer.prototype)
    claim(!deepEquivalent(x,y), '!deepEquivalent(x,y)')
}

test_Buffer();