From abba45e12040dc58de32ff55b58e76b735a66b5b Mon Sep 17 00:00:00 2001 From: Ruben Bridgewater Date: Fri, 10 Feb 2023 03:37:37 +0100 Subject: [PATCH] test: remove obsolete util.isDeepStrictEqual tests These tests are a copy of the assert tests that verify the deep equal comparison algorithm. There is no need to duplicate the tests as changing one would require to change the tests in two places without knowing which ones to actually rely upon. Signed-off-by: Ruben Bridgewater PR-URL: https://github.com/nodejs/node/pull/46593 Reviewed-By: Yagiz Nizipli Reviewed-By: James M Snell Reviewed-By: Matteo Collina --- test/parallel/test-util-isDeepStrictEqual.js | 419 ------------------- 1 file changed, 419 deletions(-) diff --git a/test/parallel/test-util-isDeepStrictEqual.js b/test/parallel/test-util-isDeepStrictEqual.js index da266fc84ce0bb..48b3116061932f 100644 --- a/test/parallel/test-util-isDeepStrictEqual.js +++ b/test/parallel/test-util-isDeepStrictEqual.js @@ -7,82 +7,6 @@ require('../common'); const assert = require('assert'); const util = require('util'); -class MyDate extends Date { - constructor(...args) { - super(...args); - this[0] = '1'; - } -} - -class MyRegExp extends RegExp { - constructor(...args) { - super(...args); - this[0] = '1'; - } -} - -{ - const arr = new Uint8Array([120, 121, 122, 10]); - const buf = Buffer.from(arr); - // They have different [[Prototype]] - assert.strictEqual(util.isDeepStrictEqual(arr, buf), false); - - const buf2 = Buffer.from(arr); - buf2.prop = 1; - - assert.strictEqual(util.isDeepStrictEqual(buf2, buf), false); - - const arr2 = new Uint8Array([120, 121, 122, 10]); - arr2.prop = 5; - assert.strictEqual(util.isDeepStrictEqual(arr, arr2), false); -} - -{ - const date = new Date('2016'); - - const date2 = new MyDate('2016'); - - // deepStrictEqual checks own properties - assert.strictEqual(util.isDeepStrictEqual(date, date2), false); - assert.strictEqual(util.isDeepStrictEqual(date2, date), false); -} - -{ - const re1 = new RegExp('test'); - const re2 = new MyRegExp('test'); - - // deepStrictEqual checks all properties - assert.strictEqual(util.isDeepStrictEqual(re1, re2), false); -} - -{ - // For these cases, deepStrictEqual should throw. - const similar = new Set([ - { 0: '1' }, // Object - { 0: 1 }, // Object - new String('1'), // Object - ['1'], // Array - [1], // Array - new MyDate('2016'), // Date with this[0] = '1' - new MyRegExp('test'), // RegExp with this[0] = '1' - new Int8Array([1]), // Int8Array - new Uint8Array([1]), // Uint8Array - new Int16Array([1]), // Int16Array - new Uint16Array([1]), // Uint16Array - new Int32Array([1]), // Int32Array - new Uint32Array([1]), // Uint32Array - Buffer.from([1]), // Buffer - ]); - - for (const a of similar) { - for (const b of similar) { - if (a !== b) { - assert.strictEqual(util.isDeepStrictEqual(a, b), false); - } - } - } -} - function utilIsDeepStrict(a, b) { assert.strictEqual(util.isDeepStrictEqual(a, b), true); assert.strictEqual(util.isDeepStrictEqual(b, a), true); @@ -93,345 +17,6 @@ function notUtilIsDeepStrict(a, b) { assert.strictEqual(util.isDeepStrictEqual(b, a), false); } -// es6 Maps and Sets -utilIsDeepStrict(new Set(), new Set()); -utilIsDeepStrict(new Map(), new Map()); - -utilIsDeepStrict(new Set([1, 2, 3]), new Set([1, 2, 3])); -notUtilIsDeepStrict(new Set([1, 2, 3]), new Set([1, 2, 3, 4])); -notUtilIsDeepStrict(new Set([1, 2, 3, 4]), new Set([1, 2, 3])); -utilIsDeepStrict(new Set(['1', '2', '3']), new Set(['1', '2', '3'])); -utilIsDeepStrict(new Set([[1, 2], [3, 4]]), new Set([[3, 4], [1, 2]])); - -{ - const a = [ 1, 2 ]; - const b = [ 3, 4 ]; - const c = [ 1, 2 ]; - const d = [ 3, 4 ]; - - utilIsDeepStrict( - { a: a, b: b, s: new Set([a, b]) }, - { a: c, b: d, s: new Set([d, c]) } - ); -} - -utilIsDeepStrict(new Map([[1, 1], [2, 2]]), new Map([[1, 1], [2, 2]])); -utilIsDeepStrict(new Map([[1, 1], [2, 2]]), new Map([[2, 2], [1, 1]])); -notUtilIsDeepStrict(new Map([[1, 1], [2, 2]]), new Map([[1, 2], [2, 1]])); -notUtilIsDeepStrict( - new Map([[[1], 1], [{}, 2]]), - new Map([[[1], 2], [{}, 1]]) -); - -notUtilIsDeepStrict(new Set([1]), [1]); -notUtilIsDeepStrict(new Set(), []); -notUtilIsDeepStrict(new Set(), {}); - -notUtilIsDeepStrict(new Map([['a', 1]]), { a: 1 }); -notUtilIsDeepStrict(new Map(), []); -notUtilIsDeepStrict(new Map(), {}); - -notUtilIsDeepStrict(new Set(['1']), new Set([1])); - -notUtilIsDeepStrict(new Map([['1', 'a']]), new Map([[1, 'a']])); -notUtilIsDeepStrict(new Map([['a', '1']]), new Map([['a', 1]])); -notUtilIsDeepStrict(new Map([['a', '1']]), new Map([['a', 2]])); - -utilIsDeepStrict(new Set([{}]), new Set([{}])); - -// Ref: https://github.com/nodejs/node/issues/13347 -notUtilIsDeepStrict( - new Set([{ a: 1 }, { a: 1 }]), - new Set([{ a: 1 }, { a: 2 }]) -); -notUtilIsDeepStrict( - new Set([{ a: 1 }, { a: 1 }, { a: 2 }]), - new Set([{ a: 1 }, { a: 2 }, { a: 2 }]) -); -notUtilIsDeepStrict( - new Map([[{ x: 1 }, 5], [{ x: 1 }, 5]]), - new Map([[{ x: 1 }, 5], [{ x: 2 }, 5]]) -); - -notUtilIsDeepStrict(new Set([3, '3']), new Set([3, 4])); -notUtilIsDeepStrict(new Map([[3, 0], ['3', 0]]), new Map([[3, 0], [4, 0]])); - -notUtilIsDeepStrict( - new Set([{ a: 1 }, { a: 1 }, { a: 2 }]), - new Set([{ a: 1 }, { a: 2 }, { a: 2 }]) -); - -// Mixed primitive and object keys -utilIsDeepStrict( - new Map([[1, 'a'], [{}, 'a']]), - new Map([[1, 'a'], [{}, 'a']]) -); -utilIsDeepStrict( - new Set([1, 'a', [{}, 'a']]), - new Set([1, 'a', [{}, 'a']]) -); - -// This is an awful case, where a map contains multiple equivalent keys: -notUtilIsDeepStrict( - new Map([[1, 'a'], ['1', 'b']]), - new Map([['1', 'a'], [true, 'b']]) -); -notUtilIsDeepStrict( - new Set(['a']), - new Set(['b']) -); -utilIsDeepStrict( - new Map([[{}, 'a'], [{}, 'b']]), - new Map([[{}, 'b'], [{}, 'a']]) -); -notUtilIsDeepStrict( - new Map([[true, 'a'], ['1', 'b'], [1, 'a']]), - new Map([['1', 'a'], [1, 'b'], [true, 'a']]) -); -notUtilIsDeepStrict( - new Map([[true, 'a'], ['1', 'b'], [1, 'c']]), - new Map([['1', 'a'], [1, 'b'], [true, 'a']]) -); - -// Similar object keys -notUtilIsDeepStrict( - new Set([{}, {}]), - new Set([{}, 1]) -); -notUtilIsDeepStrict( - new Set([[{}, 1], [{}, 1]]), - new Set([[{}, 1], [1, 1]]) -); -notUtilIsDeepStrict( - new Map([[{}, 1], [{}, 1]]), - new Map([[{}, 1], [1, 1]]) -); -notUtilIsDeepStrict( - new Map([[{}, 1], [true, 1]]), - new Map([[{}, 1], [1, 1]]) -); - -// Similar primitive key / values -notUtilIsDeepStrict( - new Set([1, true, false]), - new Set(['1', 0, '0']) -); -notUtilIsDeepStrict( - new Map([[1, 5], [true, 5], [false, 5]]), - new Map([['1', 5], [0, 5], ['0', 5]]) -); - -// Undefined value in Map -utilIsDeepStrict( - new Map([[1, undefined]]), - new Map([[1, undefined]]) -); -notUtilIsDeepStrict( - new Map([[1, null]]), - new Map([['1', undefined]]) -); -notUtilIsDeepStrict( - new Map([[1, undefined]]), - new Map([[2, undefined]]) -); - -// null as key -utilIsDeepStrict( - new Map([[null, 3]]), - new Map([[null, 3]]) -); -notUtilIsDeepStrict( - new Map([[null, undefined]]), - new Map([[undefined, null]]) -); -notUtilIsDeepStrict( - new Set([null]), - new Set([undefined]) -); - -// GH-6416. Make sure circular refs don't throw. -{ - const b = {}; - b.b = b; - const c = {}; - c.b = c; - - utilIsDeepStrict(b, c); - - const d = {}; - d.a = 1; - d.b = d; - const e = {}; - e.a = 1; - e.b = {}; - - notUtilIsDeepStrict(d, e); -} - -// GH-14441. Circular structures should be consistent -{ - const a = {}; - const b = {}; - a.a = a; - b.a = {}; - b.a.a = a; - utilIsDeepStrict(a, b); -} - -{ - const a = new Set(); - const b = new Set(); - const c = new Set(); - a.add(a); - b.add(b); - c.add(a); - utilIsDeepStrict(b, c); -} - -// GH-7178. Ensure reflexivity of deepEqual with `arguments` objects. -{ - const args = (function() { return arguments; })(); - notUtilIsDeepStrict([], args); -} - -// More checking that arguments objects are handled correctly -{ - // eslint-disable-next-line func-style - const returnArguments = function() { return arguments; }; - - const someArgs = returnArguments('a'); - const sameArgs = returnArguments('a'); - const diffArgs = returnArguments('b'); - - notUtilIsDeepStrict(someArgs, ['a']); - notUtilIsDeepStrict(someArgs, { '0': 'a' }); - notUtilIsDeepStrict(someArgs, diffArgs); - utilIsDeepStrict(someArgs, sameArgs); -} - -{ - const values = [ - 123, - Infinity, - 0, - null, - undefined, - false, - true, - {}, - [], - () => {}, - ]; - utilIsDeepStrict(new Set(values), new Set(values)); - utilIsDeepStrict(new Set(values), new Set(values.reverse())); - - const mapValues = values.map((v) => [v, { a: 5 }]); - utilIsDeepStrict(new Map(mapValues), new Map(mapValues)); - utilIsDeepStrict(new Map(mapValues), new Map(mapValues.reverse())); -} - -{ - const s1 = new Set(); - const s2 = new Set(); - s1.add(1); - s1.add(2); - s2.add(2); - s2.add(1); - utilIsDeepStrict(s1, s2); -} - -{ - const m1 = new Map(); - const m2 = new Map(); - const obj = { a: 5, b: 6 }; - m1.set(1, obj); - m1.set(2, 'hi'); - m1.set(3, [1, 2, 3]); - - m2.set(2, 'hi'); // different order - m2.set(1, obj); - m2.set(3, [1, 2, 3]); // Deep equal, but not reference equal. - - utilIsDeepStrict(m1, m2); -} - -{ - const m1 = new Map(); - const m2 = new Map(); - - // m1 contains itself. - m1.set(1, m1); - m2.set(1, new Map()); - - notUtilIsDeepStrict(m1, m2); -} - -{ - const map1 = new Map([[1, 1]]); - const map2 = new Map([[1, '1']]); - assert.strictEqual(util.isDeepStrictEqual(map1, map2), false); -} - -{ - // Two equivalent sets / maps with different key/values applied shouldn't be - // the same. This is a terrible idea to do in practice, but deepEqual should - // still check for it. - const s1 = new Set(); - const s2 = new Set(); - s1.x = 5; - notUtilIsDeepStrict(s1, s2); - - const m1 = new Map(); - const m2 = new Map(); - m1.x = 5; - notUtilIsDeepStrict(m1, m2); -} - -{ - // Circular references. - const s1 = new Set(); - s1.add(s1); - const s2 = new Set(); - s2.add(s2); - utilIsDeepStrict(s1, s2); - - const m1 = new Map(); - m1.set(2, m1); - const m2 = new Map(); - m2.set(2, m2); - utilIsDeepStrict(m1, m2); - - const m3 = new Map(); - m3.set(m3, 2); - const m4 = new Map(); - m4.set(m4, 2); - utilIsDeepStrict(m3, m4); -} - -// Handle sparse arrays -/* eslint-disable no-sparse-arrays */ -utilIsDeepStrict([1, , , 3], [1, , , 3]); -notUtilIsDeepStrict([1, , , 3], [1, , , 3, , , ]); -/* eslint-enable no-sparse-arrays */ - -// Handle different error messages -{ - const err1 = new Error('foo1'); - const err2 = new Error('foo2'); - const err3 = new TypeError('foo1'); - notUtilIsDeepStrict(err1, err2, assert.AssertionError); - notUtilIsDeepStrict(err1, err3, assert.AssertionError); - notUtilIsDeepStrict(err1, {}, assert.AssertionError); -} - -// Handle NaN -assert.strictEqual(util.isDeepStrictEqual(NaN, NaN), true); -assert.strictEqual(util.isDeepStrictEqual({ a: NaN }, { a: NaN }), true); -assert.strictEqual( - util.isDeepStrictEqual([ 1, 2, NaN, 4 ], [ 1, 2, NaN, 4 ]), - true -); - // Handle boxed primitives { const boxedString = new String('test'); @@ -478,10 +63,6 @@ assert.strictEqual( notUtilIsDeepStrict(symbolish, new String('fhqwhgads')); } -// Minus zero -notUtilIsDeepStrict(0, -0); -utilIsDeepStrict(-0, -0); - // Handle symbols (enumerable only) { const symbol1 = Symbol();