benchmark: improve assert benchmarks

This reduces the runtime and makes sure the strict and loose options can be tested individually. Besides that a couple of redundant cases were removed. PR-URL: #22211 Reviewed-By: Anatoli Papirovski <[email protected]> Reviewed-By: Benjamin Gruenbaum <[email protected]> Reviewed-By: Matteo Collina <[email protected]> Reviewed-By: Trivikram Kamat <[email protected]> Reviewed-By: James M Snell <[email protected]>

Author: BridgeAR

benchmark/assert/deepequal-buffer.js

@@ -3,17 +3,16 @@ const common = require('../common.js');
 constassert=require('assert');
 
 constbench=common.createBenchmark(main,{
-n: [1e5],
-len: [1e2,1e4],
+n: [2e4],
+len: [1e2,1e3],
+strict: [0,1],
 method: [
 'deepEqual',
-'deepStrictEqual',
-'notDeepEqual',
-'notDeepStrictEqual'
+'notDeepEqual'
 ]
 });
 
-functionmain({ len, n, method }){
+functionmain({ len, n, method, strict}){
 if(!method)
 method='deepEqual';
 constdata=Buffer.allocUnsafe(len+1);
@@ -24,6 +23,9 @@ function main({len, n, method }){
 data.copy(expected);
 data.copy(expectedWrong);
 
+if(strict){
+method=method.replace('eep','eepStrict');
+}
 constfn=assert[method];
 constvalue2=method.includes('not') ? expectedWrong : expected;
 

benchmark/assert/deepequal-map.js

@@ -7,21 +7,14 @@ const{deepEqual, deepStrictEqual, notDeepEqual, notDeepStrictEqual } =
 constbench=common.createBenchmark(main,{
 n: [5e2],
 len: [5e2],
+strict: [0,1],
 method: [
 'deepEqual_primitiveOnly',
-'deepStrictEqual_primitiveOnly',
 'deepEqual_objectOnly',
-'deepStrictEqual_objectOnly',
 'deepEqual_mixed',
-'deepStrictEqual_mixed',
-'deepEqual_looseMatches',
 'notDeepEqual_primitiveOnly',
-'notDeepStrictEqual_primitiveOnly',
 'notDeepEqual_objectOnly',
-'notDeepStrictEqual_objectOnly',
-'notDeepEqual_mixed',
-'notDeepStrictEqual_mixed',
-'notDeepEqual_looseMatches',
+'notDeepEqual_mixed'
 ]
 });
 
@@ -37,7 +30,7 @@ function benchmark(method, n, values, values2){
 bench.end(n);
 }
 
-functionmain({ n, len, method }){
+functionmain({ n, len, method, strict}){
 constarray=Array(len).fill(1);
 varvalues,values2;
 
@@ -46,74 +39,33 @@ function main({n, len, method }){
 // Empty string falls through to next line as default, mostly for tests.
 case'deepEqual_primitiveOnly':
 values=array.map((_,i)=>[`str_${i}`,123]);
-benchmark(deepEqual,n,values);
-break;
-case'deepStrictEqual_primitiveOnly':
-values=array.map((_,i)=>[`str_${i}`,123]);
-benchmark(deepStrictEqual,n,values);
+benchmark(strict ? deepStrictEqual : deepEqual,n,values);
 break;
 case'deepEqual_objectOnly':
 values=array.map((_,i)=>[[`str_${i}`,1],123]);
-benchmark(deepEqual,n,values);
-break;
-case'deepStrictEqual_objectOnly':
-values=array.map((_,i)=>[[`str_${i}`,1],123]);
-benchmark(deepStrictEqual,n,values);
+benchmark(strict ? deepStrictEqual : deepEqual,n,values);
 break;
 case'deepEqual_mixed':
 values=array.map((_,i)=>[i%2 ? [`str_${i}`,1] : `str_${i}`,123]);
-benchmark(deepEqual,n,values);
-break;
-case'deepStrictEqual_mixed':
-values=array.map((_,i)=>[i%2 ? [`str_${i}`,1] : `str_${i}`,123]);
-benchmark(deepStrictEqual,n,values);
-break;
-case'deepEqual_looseMatches':
-values=array.map((_,i)=>[i,i]);
-values2=values.slice().map((v)=>[String(v[0]),String(v[1])]);
-benchmark(deepEqual,n,values,values2);
+benchmark(strict ? deepStrictEqual : deepEqual,n,values);
 break;
 case'notDeepEqual_primitiveOnly':
 values=array.map((_,i)=>[`str_${i}`,123]);
 values2=values.slice(0);
 values2[Math.floor(len/2)]=['w00t',123];
-benchmark(notDeepEqual,n,values,values2);
-break;
-case'notDeepStrictEqual_primitiveOnly':
-values=array.map((_,i)=>[`str_${i}`,123]);
-values2=values.slice(0);
-values2[Math.floor(len/2)]=['w00t',123];
-benchmark(notDeepStrictEqual,n,values,values2);
+benchmark(strict ? notDeepStrictEqual : notDeepEqual,n,values,values2);
 break;
 case'notDeepEqual_objectOnly':
 values=array.map((_,i)=>[[`str_${i}`,1],123]);
 values2=values.slice(0);
 values2[Math.floor(len/2)]=[['w00t'],123];
-benchmark(notDeepEqual,n,values,values2);
-break;
-case'notDeepStrictEqual_objectOnly':
-values=array.map((_,i)=>[[`str_${i}`,1],123]);
-values2=values.slice(0);
-values2[Math.floor(len/2)]=[['w00t'],123];
-benchmark(notDeepStrictEqual,n,values,values2);
+benchmark(strict ? notDeepStrictEqual : notDeepEqual,n,values,values2);
 break;
 case'notDeepEqual_mixed':
 values=array.map((_,i)=>[i%2 ? [`str_${i}`,1] : `str_${i}`,123]);
 values2=values.slice(0);
 values2[0]=['w00t',123];
-benchmark(notDeepEqual,n,values,values2);
-break;
-case'notDeepStrictEqual_mixed':
-values=array.map((_,i)=>[i%2 ? [`str_${i}`,1] : `str_${i}`,123]);
-values2=values.slice(0);
-values2[0]=['w00t',123];
-benchmark(notDeepStrictEqual,n,values,values2);
-break;
-case'notDeepEqual_looseMatches':
-values=array.map((_,i)=>[i,i]);
-values2=values.slice().map((v)=>[String(v[0]),String(v[1])]);
-values2[len-1]=[String(len+1),String(len+1)];
-benchmark(notDeepEqual,n,values,values2);
+benchmark(strict ? notDeepStrictEqual : notDeepEqual,n,values,values2);
 break;
 default:
 thrownewError(`Unsupported method ${method}`);

benchmark/assert/deepequal-object.js

@@ -4,13 +4,12 @@ const common = require('../common.js');
 constassert=require('assert');
 
 constbench=common.createBenchmark(main,{
-n: [1e6],
-size: [1e2,1e3,1e4],
+n: [5e3],
+size: [1e2,1e3,5e4],
+strict: [0,1],
 method: [
 'deepEqual',
-'deepStrictEqual',
-'notDeepEqual',
-'notDeepStrictEqual'
+'notDeepEqual'
 ]
 });
 
@@ -20,14 +19,16 @@ function createObj(source, add = ''){
 nope: {
 bar: `123${add}`,
 a: [1,2,3],
-baz: n
+baz: n,
+c: {},
+b: []
 }
 }));
 }
 
-functionmain({ size, n, method }){
+functionmain({ size, n, method, strict}){
 // TODO: Fix this "hack". `n` should not be manipulated.
-n=n/size;
+n=Math.min(Math.ceil(n/size),20);
 
 if(!method)
 method='deepEqual';
@@ -37,6 +38,9 @@ function main({size, n, method }){
 constexpected=createObj(source);
 constexpectedWrong=createObj(source,'4');
 
+if(strict){
+method=method.replace('eep','eepStrict');
+}
 constfn=assert[method];
 constvalue2=method.includes('not') ? expectedWrong : expected;
 

benchmark/assert/deepequal-prims-and-objs-big-array-set.js

@@ -5,29 +5,22 @@ const{deepEqual, deepStrictEqual, notDeepEqual, notDeepStrictEqual } =
 require('assert');
 
 constprimValues={
-'null': null,
-'undefined': undefined,
 'string': 'a',
 'number': 1,
-'boolean': true,
 'object': {0: 'a'},
-'array': [1,2,3],
-'new-array': newArray([1,2,3])
+'array': [1,2,3]
 };
 
 constbench=common.createBenchmark(main,{
 primitive: Object.keys(primValues),
 n: [25],
-len: [1e5],
+len: [2e4],
+strict: [0,1],
 method: [
 'deepEqual_Array',
-'deepStrictEqual_Array',
 'notDeepEqual_Array',
-'notDeepStrictEqual_Array',
 'deepEqual_Set',
-'deepStrictEqual_Set',
-'notDeepEqual_Set',
-'notDeepStrictEqual_Set'
+'notDeepEqual_Set'
 ]
 });
 
@@ -39,7 +32,7 @@ function run(fn, n, actual, expected){
 bench.end(n);
 }
 
-functionmain({ n, len, primitive, method }){
+functionmain({ n, len, primitive, method, strict}){
 constprim=primValues[primitive];
 constactual=[];
 constexpected=[];
@@ -62,28 +55,17 @@ function main({n, len, primitive, method }){
 // Empty string falls through to next line as default, mostly for tests.
 case'':
 case'deepEqual_Array':
-run(deepEqual,n,actual,expected);
-break;
-case'deepStrictEqual_Array':
-run(deepStrictEqual,n,actual,expected);
+run(strict ? deepStrictEqual : deepEqual,n,actual,expected);
 break;
 case'notDeepEqual_Array':
-run(notDeepEqual,n,actual,expectedWrong);
-break;
-case'notDeepStrictEqual_Array':
-run(notDeepStrictEqual,n,actual,expectedWrong);
+run(strict ? notDeepStrictEqual : notDeepEqual,n,actual,expectedWrong);
 break;
 case'deepEqual_Set':
-run(deepEqual,n,actualSet,expectedSet);
-break;
-case'deepStrictEqual_Set':
-run(deepStrictEqual,n,actualSet,expectedSet);
+run(strict ? deepStrictEqual : deepEqual,n,actualSet,expectedSet);
 break;
 case'notDeepEqual_Set':
-run(notDeepEqual,n,actualSet,expectedWrongSet);
-break;
-case'notDeepStrictEqual_Set':
-run(notDeepStrictEqual,n,actualSet,expectedWrongSet);
+run(strict ? notDeepStrictEqual : notDeepEqual,
+n,actualSet,expectedWrongSet);
 break;
 default:
 thrownewError(`Unsupported method "${method}"`);

benchmark/assert/deepequal-prims-and-objs-big-loop.js

@@ -3,35 +3,33 @@ const common = require('../common.js');
 constassert=require('assert');
 
 constprimValues={
-'null': null,
-'undefined': undefined,
 'string': 'a',
 'number': 1,
-'boolean': true,
 'object': {0: 'a'},
-'array': [1,2,3],
-'new-array': newArray([1,2,3])
+'array': [1,2,3]
 };
 
 constbench=common.createBenchmark(main,{
 primitive: Object.keys(primValues),
-n: [1e6],
+n: [2e4],
+strict: [0,1],
 method: [
 'deepEqual',
-'deepStrictEqual',
 'notDeepEqual',
-'notDeepStrictEqual'
 ]
 });
 
-functionmain({ n, primitive, method }){
+functionmain({ n, primitive, method, strict}){
 if(!method)
 method='deepEqual';
 constprim=primValues[primitive];
 constactual=prim;
 constexpected=prim;
 constexpectedWrong='b';
 
+if(strict){
+method=method.replace('eep','eepStrict');
+}
 constfn=assert[method];
 constvalue2=method.includes('not') ? expectedWrong : expected;