assert: make partialDeepStrictEqual work with ArrayBuffers

Fixes: #56097 PR-URL: #56098 Reviewed-By: Antoine du Hamel <[email protected]>

Author: Giovanni Bucci

lib/assert.js

@@ -21,35 +21,44 @@
 'use strict';
 
 const{
+ ArrayBufferIsView,
+ ArrayBufferPrototypeGetByteLength,
  ArrayFrom,
  ArrayIsArray,
  ArrayPrototypeIndexOf,
  ArrayPrototypeJoin,
  ArrayPrototypePush,
  ArrayPrototypeSlice,
+ DataViewPrototypeGetBuffer,
+ DataViewPrototypeGetByteLength,
+ DataViewPrototypeGetByteOffset,
  Error,
  FunctionPrototypeCall,
- MapPrototypeDelete,
  MapPrototypeGet,
+ MapPrototypeGetSize,
  MapPrototypeHas,
- MapPrototypeSet,
  NumberIsNaN,
  ObjectAssign,
  ObjectIs,
  ObjectKeys,
  ObjectPrototypeIsPrototypeOf,
+ ObjectPrototypeToString,
  ReflectApply,
  ReflectHas,
  ReflectOwnKeys,
  RegExpPrototypeExec,
+ SafeArrayIterator,
  SafeMap,
  SafeSet,
  SafeWeakSet,
+ SetPrototypeGetSize,
  String,
  StringPrototypeIndexOf,
  StringPrototypeSlice,
  StringPrototypeSplit,
  SymbolIterator,
+ TypedArrayPrototypeGetLength,
+ Uint8Array,
 }=primordials;
 
 const{
@@ -65,6 +74,8 @@ const AssertionError = require('internal/assert/assertion_error');
 const{ inspect }=require('internal/util/inspect');
 const{ Buffer }=require('buffer');
 const{
+ isArrayBuffer,
+ isDataView,
  isKeyObject,
  isPromise,
  isRegExp,
@@ -73,6 +84,8 @@ const{
  isDate,
  isWeakSet,
  isWeakMap,
+ isSharedArrayBuffer,
+ isAnyArrayBuffer,
 }=require('internal/util/types');
 const{ isError, deprecate, emitExperimentalWarning }=require('internal/util');
 const{ innerOk }=require('internal/assert/utils');
@@ -369,9 +382,161 @@ function isSpecial(obj){
 }
 
 consttypesToCallDeepStrictEqualWith=[
-isKeyObject,isWeakSet,isWeakMap,Buffer.isBuffer,
+isKeyObject,isWeakSet,isWeakMap,Buffer.isBuffer,isSharedArrayBuffer,
 ];
 
+functioncompareMaps(actual,expected,comparedObjects){
+if(MapPrototypeGetSize(actual)!==MapPrototypeGetSize(expected)){
+returnfalse;
+}
+constsafeIterator=FunctionPrototypeCall(SafeMap.prototype[SymbolIterator],actual);
+
+comparedObjects??=newSafeWeakSet();
+
+for(const{0: key,1: val}ofsafeIterator){
+if(!MapPrototypeHas(expected,key)){
+returnfalse;
+}
+if(!compareBranch(val,MapPrototypeGet(expected,key),comparedObjects)){
+returnfalse;
+}
+}
+returntrue;
+}
+
+functionpartiallyCompareArrayBuffersOrViews(actual,expected){
+letactualView,expectedView,expectedViewLength;
+
+if(!ArrayBufferIsView(actual)){
+letactualViewLength;
+
+if(isArrayBuffer(actual)&&isArrayBuffer(expected)){
+actualViewLength=ArrayBufferPrototypeGetByteLength(actual);
+expectedViewLength=ArrayBufferPrototypeGetByteLength(expected);
+}elseif(isSharedArrayBuffer(actual)&&isSharedArrayBuffer(expected)){
+actualViewLength=actual.byteLength;
+expectedViewLength=expected.byteLength;
+}else{
+// Cannot compare ArrayBuffers with SharedArrayBuffers
+returnfalse;
+}
+
+if(expectedViewLength>actualViewLength){
+returnfalse;
+}
+actualView=newUint8Array(actual);
+expectedView=newUint8Array(expected);
+
+}elseif(isDataView(actual)){
+if(!isDataView(expected)){
+returnfalse;
+}
+constactualByteLength=DataViewPrototypeGetByteLength(actual);
+expectedViewLength=DataViewPrototypeGetByteLength(expected);
+if(expectedViewLength>actualByteLength){
+returnfalse;
+}
+
+actualView=newUint8Array(
+DataViewPrototypeGetBuffer(actual),
+DataViewPrototypeGetByteOffset(actual),
+actualByteLength,
+);
+expectedView=newUint8Array(
+DataViewPrototypeGetBuffer(expected),
+DataViewPrototypeGetByteOffset(expected),
+expectedViewLength,
+);
+}else{
+if(ObjectPrototypeToString(actual)!==ObjectPrototypeToString(expected)){
+returnfalse;
+}
+actualView=actual;
+expectedView=expected;
+expectedViewLength=TypedArrayPrototypeGetLength(expected);
+
+if(expectedViewLength>TypedArrayPrototypeGetLength(actual)){
+returnfalse;
+}
+}
+
+for(leti=0;i<expectedViewLength;i++){
+if(actualView[i]!==expectedView[i]){
+returnfalse;
+}
+}
+
+returntrue;
+}
+
+functionpartiallyCompareSets(actual,expected,comparedObjects){
+if(SetPrototypeGetSize(expected)>SetPrototypeGetSize(actual)){
+returnfalse;// `expected` can't be a subset if it has more elements
+}
+
+if(isDeepEqual===undefined)lazyLoadComparison();
+
+constactualArray=ArrayFrom(FunctionPrototypeCall(SafeSet.prototype[SymbolIterator],actual));
+constexpectedIterator=FunctionPrototypeCall(SafeSet.prototype[SymbolIterator],expected);
+constusedIndices=newSafeSet();
+
+ expectedIteration: for(constexpectedItemofexpectedIterator){
+for(letactualIdx=0;actualIdx<actualArray.length;actualIdx++){
+if(!usedIndices.has(actualIdx)&&isDeepStrictEqual(actualArray[actualIdx],expectedItem)){
+usedIndices.add(actualIdx);
+continue expectedIteration;
+}
+}
+returnfalse;
+}
+
+returntrue;
+}
+
+functionpartiallyCompareArrays(actual,expected,comparedObjects){
+if(expected.length>actual.length){
+returnfalse;
+}
+
+if(isDeepEqual===undefined)lazyLoadComparison();
+
+// Create a map to count occurrences of each element in the expected array
+constexpectedCounts=newSafeMap();
+for(constexpectedItemofexpected){
+letfound=false;
+for(const{0: key,1: count}ofexpectedCounts){
+if(isDeepStrictEqual(key,expectedItem)){
+expectedCounts.set(key,count+1);
+found=true;
+break;
+}
+}
+if(!found){
+expectedCounts.set(expectedItem,1);
+}
+}
+
+constsafeActual=newSafeArrayIterator(actual);
+
+// Create a map to count occurrences of relevant elements in the actual array
+for(constactualItemofsafeActual){
+for(const{0: key,1: count}ofexpectedCounts){
+if(isDeepStrictEqual(key,actualItem)){
+if(count===1){
+expectedCounts.delete(key);
+}else{
+expectedCounts.set(key,count-1);
+}
+break;
+}
+}
+}
+
+const{ size }=expectedCounts;
+expectedCounts.clear();
+returnsize===0;
+}
+
 /**
  * Compares two objects or values recursively to check if they are equal.
  * @param{any} actual - The actual value to compare.
@@ -388,22 +553,16 @@ function compareBranch(
 ){
 // Check for Map object equality
 if(isMap(actual)&&isMap(expected)){
-if(actual.size!==expected.size){
-returnfalse;
-}
-constsafeIterator=FunctionPrototypeCall(SafeMap.prototype[SymbolIterator],actual);
-
-comparedObjects??=newSafeWeakSet();
+returncompareMaps(actual,expected,comparedObjects);
+}
 
-for(const{0: key,1: val}ofsafeIterator){
-if(!MapPrototypeHas(expected,key)){
-returnfalse;
-}
-if(!compareBranch(val,MapPrototypeGet(expected,key),comparedObjects)){
-returnfalse;
-}
-}
-returntrue;
+if(
+ArrayBufferIsView(actual)||
+isAnyArrayBuffer(actual)||
+ArrayBufferIsView(expected)||
+isAnyArrayBuffer(expected)
+){
+returnpartiallyCompareArrayBuffersOrViews(actual,expected);
 }
 
 for(consttypeoftypesToCallDeepStrictEqualWith){
@@ -415,68 +574,12 @@ function compareBranch(
 
 // Check for Set object equality
 if(isSet(actual)&&isSet(expected)){
-if(expected.size>actual.size){
-returnfalse;// `expected` can't be a subset if it has more elements
-}
-
-if(isDeepEqual===undefined)lazyLoadComparison();
-
-constactualArray=ArrayFrom(FunctionPrototypeCall(SafeSet.prototype[SymbolIterator],actual));
-constexpectedIterator=FunctionPrototypeCall(SafeSet.prototype[SymbolIterator],expected);
-constusedIndices=newSafeSet();
-
- expectedIteration: for(constexpectedItemofexpectedIterator){
-for(letactualIdx=0;actualIdx<actualArray.length;actualIdx++){
-if(!usedIndices.has(actualIdx)&&isDeepStrictEqual(actualArray[actualIdx],expectedItem)){
-usedIndices.add(actualIdx);
-continue expectedIteration;
-}
-}
-returnfalse;
-}
-
-returntrue;
+returnpartiallyCompareSets(actual,expected,comparedObjects);
 }
 
 // Check if expected array is a subset of actual array
 if(ArrayIsArray(actual)&&ArrayIsArray(expected)){
-if(expected.length>actual.length){
-returnfalse;
-}
-
-if(isDeepEqual===undefined)lazyLoadComparison();
-
-// Create a map to count occurrences of each element in the expected array
-constexpectedCounts=newSafeMap();
-for(constexpectedItemofexpected){
-letfound=false;
-for(const{0: key,1: count}ofexpectedCounts){
-if(isDeepStrictEqual(key,expectedItem)){
-MapPrototypeSet(expectedCounts,key,count+1);
-found=true;
-break;
-}
-}
-if(!found){
-MapPrototypeSet(expectedCounts,expectedItem,1);
-}
-}
-
-// Create a map to count occurrences of relevant elements in the actual array
-for(constactualItemofactual){
-for(const{0: key,1: count}ofexpectedCounts){
-if(isDeepStrictEqual(key,actualItem)){
-if(count===1){
-MapPrototypeDelete(expectedCounts,key);
-}else{
-MapPrototypeSet(expectedCounts,key,count-1);
-}
-break;
-}
-}
-}
-
-return!expectedCounts.size;
+returnpartiallyCompareArrays(actual,expected,comparedObjects);
 }
 
 // Comparison done when at least one of the values is not an object