assert: implement partial error comparison

assert.partialDeepStrictEqual now also handled error properties as
expected. On top of that, the main implementation also handles
non-string `name` and `message` properties and the comparison is a
tad faster by removing duplicated comparison steps.
As a drive-by fix this also cleans up some code by abstracting code
and renaming variables for clarity.
PR-URL: #57370
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: Vinícius Lourenço Claro Cardoso <contact@viniciusl.com.br>

Author: BridgeAR

lib/internal/util/comparisons.js

@@ -10,17 +10,17 @@ const {
  Error,
  NumberIsNaN,
  NumberPrototypeValueOf,
- ObjectGetOwnPropertySymbols,
+ObjectGetOwnPropertySymbols: getOwnSymbols,
  ObjectGetPrototypeOf,
  ObjectIs,
  ObjectKeys,
- ObjectPrototypeHasOwnProperty,
- ObjectPrototypePropertyIsEnumerable,
+ObjectPrototypeHasOwnProperty: hasOwn,
+ObjectPrototypePropertyIsEnumerable: hasEnumerable,
  ObjectPrototypeToString,
  SafeSet,
  StringPrototypeValueOf,
  SymbolPrototypeValueOf,
- TypedArrayPrototypeGetByteLength,
+TypedArrayPrototypeGetByteLength: getByteLength,
  TypedArrayPrototypeGetSymbolToStringTag,
  Uint8Array,
 }=primordials;
@@ -78,8 +78,8 @@ function areSimilarRegExps(a, b) {
 }
 
 functionisPartialUint8Array(a,b){
-constlenA=TypedArrayPrototypeGetByteLength(a);
-constlenB=TypedArrayPrototypeGetByteLength(b);
+constlenA=getByteLength(a);
+constlenB=getByteLength(b);
 if(lenA<lenB){
 returnfalse;
 }
@@ -107,10 +107,10 @@ function isPartialArrayBufferView(a, b) {
 }
 
 functionareSimilarFloatArrays(a,b){
-if(a.byteLength!==b.byteLength){
+constlen=getByteLength(a);
+if(len!==getByteLength(b)){
 returnfalse;
 }
-constlen=TypedArrayPrototypeGetByteLength(a);
 for(letoffset=0;offset<len;offset++){
 if(a[offset]!==b[offset]){
 returnfalse;
@@ -158,6 +158,12 @@ function isEqualBoxedPrimitive(val1, val2) {
 assert.fail(`Unknown boxed type ${val1}`);
 }
 
+functionisEnumerableOrIdentical(val1,val2,prop,mode,memos,method){
+returnhasEnumerable(val2,prop)||// This is handled by Object.keys()
+(mode===kPartial&&(val2[prop]===undefined||(prop==='message'&&val2[prop]==='')))||
+innerDeepEqual(val1[prop],val2[prop],mode,memos);
+}
+
 // Notes: Type tags are historical [[Class]] properties that can be set by
 // FunctionTemplate::SetClassName() in C++ or Symbol.toStringTag in JS
 // and retrieved using Object.prototype.toString.call(obj) in JS
@@ -263,8 +269,7 @@ function innerDeepEqual(val1, val2, mode, memos) {
 (val1.size!==val2.size&&(mode!==kPartial||val1.size<val2.size))){
 returnfalse;
 }
-constresult=keyCheck(val1,val2,mode,memos,kIsSet);
-returnresult;
+returnkeyCheck(val1,val2,mode,memos,kIsSet);
 }elseif(isMap(val1)){
 if(!isMap(val2)||
 (val1.size!==val2.size&&(mode!==kPartial||val1.size<val2.size))){
@@ -285,26 +290,15 @@ function innerDeepEqual(val1, val2, mode, memos) {
 }elseif(isError(val1)){
 // Do not compare the stack as it might differ even though the error itself
 // is otherwise identical.
-if(!isError(val2)){
+if(!isError(val2)||
+!isEnumerableOrIdentical(val1,val2,'message',mode,memos)||
+!isEnumerableOrIdentical(val1,val2,'name',mode,memos)||
+!isEnumerableOrIdentical(val1,val2,'cause',mode,memos)||
+!isEnumerableOrIdentical(val1,val2,'errors',mode,memos)){
 returnfalse;
 }
-
-constmessage1Enumerable=ObjectPrototypePropertyIsEnumerable(val1,'message');
-constname1Enumerable=ObjectPrototypePropertyIsEnumerable(val1,'name');
-// TODO(BridgeAR): Adjust cause and errors properties for partial mode.
-constcause1Enumerable=ObjectPrototypePropertyIsEnumerable(val1,'cause');
-consterrors1Enumerable=ObjectPrototypePropertyIsEnumerable(val1,'errors');
-
-if((message1Enumerable!==ObjectPrototypePropertyIsEnumerable(val2,'message')||
-(!message1Enumerable&&val1.message!==val2.message))||
-(name1Enumerable!==ObjectPrototypePropertyIsEnumerable(val2,'name')||
-(!name1Enumerable&&val1.name!==val2.name))||
-(cause1Enumerable!==ObjectPrototypePropertyIsEnumerable(val2,'cause')||
-(!cause1Enumerable&&(
-ObjectPrototypeHasOwnProperty(val1,'cause')!==ObjectPrototypeHasOwnProperty(val2,'cause')||
-!innerDeepEqual(val1.cause,val2.cause,mode,memos))))||
-(errors1Enumerable!==ObjectPrototypePropertyIsEnumerable(val2,'errors')||
-(!errors1Enumerable&&!innerDeepEqual(val1.errors,val2.errors,mode,memos)))){
+consthasOwnVal2Cause=hasOwn(val2,'cause');
+if((hasOwnVal2Cause!==hasOwn(val1,'cause')&&(mode!==kPartial||hasOwnVal2Cause))){
 returnfalse;
 }
 }elseif(isBoxedPrimitive(val1)){
@@ -348,10 +342,7 @@ function innerDeepEqual(val1, val2, mode, memos) {
 }
 
 functiongetEnumerables(val,keys){
-returnArrayPrototypeFilter(
-keys,
-(k)=>ObjectPrototypePropertyIsEnumerable(val,k),
-);
+returnArrayPrototypeFilter(keys,(key)=>hasEnumerable(val,key));
 }
 
 functionkeyCheck(val1,val2,mode,memos,iterationType,keys2){
@@ -371,7 +362,7 @@ function keyCheck(val1, val2, mode, memos, iterationType, keys2) {
 // Cheap key test
 if(keys2.length>0){
 for(constkeyofkeys2){
-if(!ObjectPrototypePropertyIsEnumerable(val1,key)){
+if(!hasEnumerable(val1,key)){
 returnfalse;
 }
 }
@@ -380,11 +371,11 @@ function keyCheck(val1, val2, mode, memos, iterationType, keys2) {
 if(!isArrayLikeObject){
 // The pair must have the same number of owned properties.
 if(mode===kPartial){
-constsymbolKeys=ObjectGetOwnPropertySymbols(val2);
+constsymbolKeys=getOwnSymbols(val2);
 if(symbolKeys.length!==0){
 for(constkeyofsymbolKeys){
-if(ObjectPrototypePropertyIsEnumerable(val2,key)){
-if(!ObjectPrototypePropertyIsEnumerable(val1,key)){
+if(hasEnumerable(val2,key)){
+if(!hasEnumerable(val1,key)){
 returnfalse;
 }
 ArrayPrototypePush(keys2,key);
@@ -396,27 +387,27 @@ function keyCheck(val1, val2, mode, memos, iterationType, keys2) {
 }
 
 if(mode===kStrict){
-constsymbolKeysA=ObjectGetOwnPropertySymbols(val1);
+constsymbolKeysA=getOwnSymbols(val1);
 if(symbolKeysA.length!==0){
 letcount=0;
 for(constkeyofsymbolKeysA){
-if(ObjectPrototypePropertyIsEnumerable(val1,key)){
-if(!ObjectPrototypePropertyIsEnumerable(val2,key)){
+if(hasEnumerable(val1,key)){
+if(!hasEnumerable(val2,key)){
 returnfalse;
 }
 ArrayPrototypePush(keys2,key);
 count++;
-}elseif(ObjectPrototypePropertyIsEnumerable(val2,key)){
+}elseif(hasEnumerable(val2,key)){
 returnfalse;
 }
 }
-constsymbolKeysB=ObjectGetOwnPropertySymbols(val2);
+constsymbolKeysB=getOwnSymbols(val2);
 if(symbolKeysA.length!==symbolKeysB.length&&
 getEnumerables(val2,symbolKeysB).length!==count){
 returnfalse;
 }
 }else{
-constsymbolKeysB=ObjectGetOwnPropertySymbols(val2);
+constsymbolKeysB=getOwnSymbols(val2);
 if(symbolKeysB.length!==0&&
 getEnumerables(val2,symbolKeysB).length!==0){
 returnfalse;
@@ -441,7 +432,6 @@ function keyCheck(val1, val2, mode, memos, iterationType, keys2) {
 c: undefined,
 d: undefined,
 deep: false,
-deleteFailures: false,
 };
 returnobjEquiv(val1,val2,mode,keys2,memos,iterationType);
 }
@@ -476,27 +466,21 @@ function keyCheck(val1, val2, mode, memos, iterationType, keys2) {
 
 constareEq=objEquiv(val1,val2,mode,keys2,memos,iterationType);
 
-if(areEq||memos.deleteFailures){
-set.delete(val1);
-set.delete(val2);
-}
+set.delete(val1);
+set.delete(val2);
 
 returnareEq;
 }
 
 functionsetHasEqualElement(set,val1,mode,memo){
-const{ deleteFailures }=memo;
-memo.deleteFailures=true;
 for(constval2ofset){
 if(innerDeepEqual(val1,val2,mode,memo)){
 // Remove the matching element to make sure we do not check that again.
 set.delete(val2);
-memo.deleteFailures=deleteFailures;
 returntrue;
 }
 }
 
-memo.deleteFailures=deleteFailures;
 returnfalse;
 }
 
@@ -557,6 +541,8 @@ function partialObjectSetEquiv(a, b, mode, set, memo) {
 returnfalse;
 }
 }
+/* c8 ignore next */
+assert.fail('Unreachable code');
 }
 
 functionsetObjectEquiv(a,b,mode,set,memo){
@@ -623,18 +609,14 @@ function mapHasEqualEntry(set, map, key1, item1, mode, memo) {
 // To be able to handle cases like:
 // Map([[{}, 'a'], [{}, 'b']]) vs Map([[{}, 'b'], [{}, 'a']])
 // ... we need to consider *all* matching keys, not just the first we find.
-const{ deleteFailures }=memo;
-memo.deleteFailures=true;
 for(constkey2ofset){
 if(innerDeepEqual(key1,key2,mode,memo)&&
 innerDeepEqual(item1,map.get(key2),mode,memo)){
 set.delete(key2);
-memo.deleteFailures=deleteFailures;
 returntrue;
 }
 }
 
-memo.deleteFailures=deleteFailures;
 returnfalse;
 }
 
@@ -652,6 +634,8 @@ function partialObjectMapEquiv(a, b, mode, set, memo) {
 returnfalse;
 }
 }
+/* c8 ignore next */
+assert.fail('Unreachable code');
 }
 
 functionmapObjectEquivalence(a,b,mode,set,memo){
@@ -747,11 +731,11 @@ function partialSparseArrayEquiv(a, b, mode, memos, startA, startB) {
 functionpartialArrayEquiv(a,b,mode,memos){
 letaPos=0;
 for(leti=0;i<b.length;i++){
-letisSparse=b[i]===undefined&&!ObjectPrototypeHasOwnProperty(b,i);
+letisSparse=b[i]===undefined&&!hasOwn(b,i);
 if(isSparse){
 returnpartialSparseArrayEquiv(a,b,mode,memos,aPos,i);
 }
-while(!(isSparse=a[aPos]===undefined&&!ObjectPrototypeHasOwnProperty(a,aPos))&&
+while(!(isSparse=a[aPos]===undefined&&!hasOwn(a,aPos))&&
 !innerDeepEqual(a[aPos],b[i],mode,memos)){
 aPos++;
 if(aPos>a.length-b.length+i){
@@ -776,8 +760,7 @@ function sparseArrayEquiv(a, b, mode, memos, i) {
 }
 for(;i<keysA.length;i++){
 constkey=keysA[i];
-if(!ObjectPrototypeHasOwnProperty(b,key)||
-!innerDeepEqual(a[key],b[key],mode,memos)){
+if(!hasOwn(b,key)||!innerDeepEqual(a[key],b[key],mode,memos)){
 returnfalse;
 }
 }
@@ -802,8 +785,8 @@ function objEquiv(a, b, mode, keys2, memos, iterationType) {
 if(!innerDeepEqual(a[i],b[i],mode,memos)){
 returnfalse;
 }
-constisSparseA=a[i]===undefined&&!ObjectPrototypeHasOwnProperty(a,i);
-constisSparseB=b[i]===undefined&&!ObjectPrototypeHasOwnProperty(b,i);
+constisSparseA=a[i]===undefined&&!hasOwn(a,i);
+constisSparseB=b[i]===undefined&&!hasOwn(b,i);
 if(isSparseA!==isSparseB){
 returnfalse;
 }

test/parallel/test-assert-deep-with-error.js

@@ -3,6 +3,13 @@ require('../common');
 constassert=require('assert');
 const{ test }=require('node:test');
 
+// Disable colored output to prevent color codes from breaking assertion
+// message comparisons. This should only be an issue when process.stdout
+// is a TTY.
+if(process.stdout.isTTY){
+process.env.NODE_DISABLE_COLORS='1';
+}
+
 constdefaultStartMessage='Expected values to be strictly deep-equal:\n'+
 '+ actual - expected\n'+
 '\n';

test/parallel/test-assert-partial-deep-equal.js

@@ -176,10 +176,32 @@ describe('Object Comparison Tests', () => {
 },
 {
 description:
-'throws when comparing two objects with different Error instances',
+'throws when comparing two objects with different Error message',
 actual: {error: newError('Test error 1')},
 expected: {error: newError('Test error 2')},
 },
+{
+description:
+'throws when comparing two objects with missing cause on the actual Error',
+actual: {error: newError('Test error 1')},
+expected: {error: newError('Test error 1',{cause: 42})},
+},
+{
+description:
+'throws when comparing two objects with missing message on the actual Error',
+actual: {error: newError()},
+expected: {error: newError('Test error 1')},
+},
+{
+description: 'throws when comparing two Errors with missing cause on the actual Error',
+actual: {error: newError('Test error 1')},
+expected: {error: newError('Test error 1',{cause: undefined})},
+},
+{
+description: 'throws when comparing two AggregateErrors with missing message on the actual Error',
+actual: {error: newAggregateError([],'Test error 1')},
+expected: {error: newAggregateError([newError()],'Test error 1')},
+},
 {
 description:
 'throws when comparing two objects with different TypedArray instances and content',
@@ -1105,6 +1127,26 @@ describe('Object Comparison Tests', () => {
 }
 }]
 },
+{
+description: 'comparing two Errors with missing cause on the expected Error',
+actual: {error: newError('Test error 1',{cause: 42})},
+expected: {error: newError('Test error 1')},
+},
+{
+description: 'comparing two Errors with cause set to undefined on the actual Error',
+actual: {error: newError('Test error 1',{cause: undefined})},
+expected: {error: newError('Test error 1')},
+},
+{
+description: 'comparing two Errors with missing message on the expected Error',
+actual: {error: newError('Test error 1')},
+expected: {error: newError()},
+},
+{
+description: 'comparing two AggregateErrors with no message or errors on the expected Error',
+actual: {error: newAggregateError([newError(),123])},
+expected: {error: newAggregateError([])},
+},
 ].forEach(({ description, actual, expected })=>{
 it(description,()=>{
 assert.partialDeepStrictEqual(actual,expected);