Skip to content

Commit 8da49c1

Browse files
BridgeARaddaleax
BridgeAR
authored and
addaleax
committed
assert: use Same-value equality in deepStrictEqual
PR-URL: nodejs/node#15398 Reviewed-By: James M Snell <jasnell@gmail.com> Reviewed-By: Colin Ihrig <cjihrig@gmail.com> Reviewed-By: Anna Henningsen <anna@addaleax.net> Reviewed-By: Rich Trott <rtrott@gmail.com>
1 parent 6739dc6 commit 8da49c1

4 files changed

Lines changed: 48 additions & 17 deletions

File tree

‎doc/api/assert.md‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -142,6 +142,7 @@ Generally identical to `assert.deepEqual()` with a few exceptions:
142142
the [Strict Equality Comparison][] too.
143143
3. [Type tags][Object.prototype.toString()] of objects should be the same.
144144
4. [Object wrappers][] are compared both as objects and unwrapped values.
145+
5. `0` and `-0` are not considered equal.
145146

146147
```js
147148
const assert = require('assert');
@@ -179,6 +180,11 @@ assert.deepStrictEqual(new Number(1), new Number(2));
179180
// Fails because the wrapped number is unwrapped and compared as well.
180181
assert.deepStrictEqual(new String('foo'), Object('foo'));
181182
// OK because the object and the string are identical when unwrapped.
183+
184+
assert.deepStrictEqual(-0, -0);
185+
// OK
186+
assert.deepStrictEqual(0, -0);
187+
// AssertionError: 0 deepStrictEqual -0
182188
```
183189

184190
If the values are not equal, an `AssertionError` is thrown with a `message`
@@ -438,6 +444,9 @@ parameter is an instance of an `Error` then it will be thrown instead of the
438444
<!-- YAML
439445
added: v1.2.0
440446
changes:
447+
- version: REPLACEME
448+
pr-url: https://github.com/nodejs/node/pull/REPLACEME
449+
description: -0 and +0 are not considered equal anymore.
441450
- version: REPLACEME
442451
pr-url: https://github.com/nodejs/node/pull/15036
443452
description: NaN is now compared using the [SameValueZero][] comparison.

‎lib/assert.js‎

Lines changed: 13 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -118,12 +118,12 @@ function areSimilarRegExps(a, b) {
118118
// For small buffers it's faster to compare the buffer in a loop. The c++
119119
// barrier including the Uint8Array operation takes the advantage of the faster
120120
// binary compare otherwise. The break even point was at about 300 characters.
121-
function areSimilarTypedArrays(a, b) {
121+
function areSimilarTypedArrays(a, b, max) {
122122
const len = a.byteLength;
123123
if (len !== b.byteLength) {
124124
return false;
125125
}
126-
if (len < 300) {
126+
if (len < max) {
127127
for (var offset = 0; offset < len; offset++) {
128128
if (a[offset] !== b[offset]) {
129129
return false;
@@ -160,10 +160,7 @@ function isObjectOrArrayTag(tag) {
160160
// reasonable to interpret their underlying memory in the same way,
161161
// which is checked by comparing their type tags.
162162
// (e.g. a Uint8Array and a Uint16Array with the same memory content
163-
// could still be different because they will be interpreted differently)
164-
// Never perform binary comparisons for Float*Arrays, though,
165-
// since e.g. +0 === -0 is true despite the two values' bit patterns
166-
// not being identical.
163+
// could still be different because they will be interpreted differently).
167164
//
168165
// For strict comparison, objects should have
169166
// a) The same built-in type tags
@@ -211,8 +208,9 @@ function strictDeepEqual(actual, expected) {
211208
if (actual.message !== expected.message) {
212209
return false;
213210
}
214-
} else if (!isFloatTypedArrayTag(actualTag) && ArrayBuffer.isView(actual)) {
215-
if (!areSimilarTypedArrays(actual, expected)) {
211+
} else if (ArrayBuffer.isView(actual)) {
212+
if (!areSimilarTypedArrays(actual, expected,
213+
isFloatTypedArrayTag(actualTag) ? 0 : 300)) {
216214
return false;
217215
}
218216
// Buffer.compare returns true, so actual.length === expected.length
@@ -266,9 +264,10 @@ function looseDeepEqual(actual, expected) {
266264
const actualTag = objectToString(actual);
267265
const expectedTag = objectToString(expected);
268266
if (actualTag === expectedTag) {
269-
if (!isObjectOrArrayTag(actualTag) && !isFloatTypedArrayTag(actualTag) &&
270-
ArrayBuffer.isView(actual)) {
271-
return areSimilarTypedArrays(actual, expected);
267+
if (!isObjectOrArrayTag(actualTag) && ArrayBuffer.isView(actual)) {
268+
return areSimilarTypedArrays(actual, expected,
269+
isFloatTypedArrayTag(actualTag) ?
270+
Infinity : 300);
272271
}
273272
// Ensure reflexivity of deepEqual with `arguments` objects.
274273
// See https://github.com/nodejs/node-v0.x-archive/pull/7178
@@ -280,7 +279,9 @@ function looseDeepEqual(actual, expected) {
280279
function innerDeepEqual(actual, expected, strict, memos) {
281280
// All identical values are equivalent, as determined by ===.
282281
if (actual === expected) {
283-
return true;
282+
if (actual !== 0)
283+
return true;
284+
return strict ? Object.is(actual, expected) : true;
284285
}
285286

286287
// Returns a boolean if (not) equal and undefined in case we have to check

‎test/parallel/test-assert-deep.js‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -507,5 +507,8 @@ assert.doesNotThrow(
507507
boxedSymbol.slow = true;
508508
assertNotDeepOrStrict(boxedSymbol, {});
509509
}
510+
// Minus zero
511+
assertOnlyDeepEqual(0, -0);
512+
assertDeepAndStrictEqual(-0, -0);
510513

511514
/* eslint-enable */

‎test/parallel/test-assert-typedarray-deepequal.js‎

Lines changed: 23 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -20,16 +20,20 @@ const equalArrayPairs = [
2020
[new Int32Array(1e5), new Int32Array(1e5)],
2121
[new Float32Array(1e5), new Float32Array(1e5)],
2222
[new Float64Array(1e5), new Float64Array(1e5)],
23-
[new Int16Array(256), new Uint16Array(256)],
24-
[new Int16Array([256]), new Uint16Array([256])],
25-
[new Float32Array([+0.0]), new Float32Array([-0.0])],
26-
[new Float64Array([+0.0]), new Float32Array([-0.0])],
27-
[new Float64Array([+0.0]), new Float64Array([-0.0])],
23+
[new Float32Array([+0.0]), new Float32Array([+0.0])],
2824
[new Uint8Array([1, 2, 3, 4]).subarray(1), new Uint8Array([2, 3, 4])],
2925
[new Uint16Array([1, 2, 3, 4]).subarray(1), new Uint16Array([2, 3, 4])],
3026
[new Uint32Array([1, 2, 3, 4]).subarray(1, 3), new Uint32Array([2, 3])]
3127
];
3228

29+
const looseEqualArrayPairs = [
30+
[new Float64Array([+0.0]), new Float32Array([-0.0])],
31+
[new Int16Array(256), new Uint16Array(256)],
32+
[new Int16Array([256]), new Uint16Array([256])],
33+
[new Float32Array([+0.0]), new Float32Array([-0.0])],
34+
[new Float64Array([+0.0]), new Float64Array([-0.0])]
35+
];
36+
3337
const notEqualArrayPairs = [
3438
[new Uint8Array(2), new Uint8Array(3)],
3539
[new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6])],
@@ -46,6 +50,16 @@ const notEqualArrayPairs = [
4650
equalArrayPairs.forEach((arrayPair) => {
4751
// eslint-disable-next-line no-restricted-properties
4852
assert.deepEqual(arrayPair[0], arrayPair[1]);
53+
assert.deepStrictEqual(arrayPair[0], arrayPair[1]);
54+
});
55+
56+
looseEqualArrayPairs.forEach((arrayPair) => {
57+
// eslint-disable-next-line no-restricted-properties
58+
assert.deepEqual(arrayPair[0], arrayPair[1]);
59+
assert.throws(
60+
makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]),
61+
assert.AssertionError
62+
);
4963
});
5064

5165
notEqualArrayPairs.forEach((arrayPair) => {
@@ -54,4 +68,8 @@ notEqualArrayPairs.forEach((arrayPair) => {
5468
makeBlock(assert.deepEqual, arrayPair[0], arrayPair[1]),
5569
assert.AssertionError
5670
);
71+
assert.throws(
72+
makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]),
73+
assert.AssertionError
74+
);
5775
});

0 commit comments

Comments
 (0)