benchmark: rework assert benchmarks for correctness

This reworks most assert benchmarks to provide more reliable test
cases that also test more cases than before while keeping the
runtime low.

Signed-off-by: Ruben Bridgewater <ruben@bridgewater.de>
PR-URL: #46593
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>

Author: BridgeAR

benchmark/assert/deepequal-buffer.js

@@ -6,27 +6,47 @@ const bench = common.createBenchmark(main, {
   n: [2e4],
   len: [1e2, 1e3],
   strict: [0, 1],
-  method: ['deepEqual', 'notDeepEqual'],
+  arrayBuffer: [0, 1],
+  method: ['deepEqual', 'notDeepEqual', 'unequal_length'],
+}, {
+  combinationFilter: (p) => {
+    return p.strict === 1 || p.method === 'deepEqual';
+  },
 });
 
-function main({ len, n, method, strict }) {
-  const data = Buffer.allocUnsafe(len + 1);
-  const actual = Buffer.alloc(len);
-  const expected = Buffer.alloc(len);
-  const expectedWrong = Buffer.alloc(len + 1);
-  data.copy(actual);
-  data.copy(expected);
-  data.copy(expectedWrong);
+function main({ len, n, method, strict, arrayBuffer }) {
+  let actual = Buffer.alloc(len);
+  let expected = Buffer.alloc(len + Number(method === 'unequal_length'));
+
+
+  if (method === 'unequal_length') {
+    method = 'notDeepEqual';
+  }
+
+  for (let i = 0; i < len; i++) {
+    actual.writeInt8(i % 128, i);
+    expected.writeInt8(i % 128, i);
+  }
+
+  if (method.includes('not')) {
+    const position = Math.floor(len / 2);
+    expected[position] = expected[position] + 1;
+  }
 
   if (strict) {
     method = method.replace('eep', 'eepStrict');
   }
+
   const fn = assert[method];
-  const value2 = method.includes('not') ? expectedWrong : expected;
+
+  if (arrayBuffer) {
+    actual = actual.buffer;
+    expected = expected.buffer;
+  }
 
   bench.start();
   for (let i = 0; i < n; ++i) {
-    fn(actual, value2);
+    fn(actual, expected);
   }
   bench.end(n);
 }

benchmark/assert/deepequal-object.js

@@ -4,14 +4,20 @@ const common = require('../common.js');
 const assert = require('assert');
 
 const bench = common.createBenchmark(main, {
-  n: [5e3],
-  size: [1e2, 1e3, 5e4],
-  strict: [0, 1],
+  n: [25, 2e2, 2e3],
+  size: [1e2, 1e3, 1e4],
+  strict: [1],
   method: ['deepEqual', 'notDeepEqual'],
+}, {
+  combinationFilter: (p) => {
+    return p.size === 1e4 && p.n === 25 ||
+           p.size === 1e3 && p.n === 2e2 ||
+           p.size === 1e2 && p.n === 2e3;
+  },
 });
 
-function createObj(source, add = '') {
-  return source.map((n) => ({
+function createObj(size, add = '') {
+  return Array.from({ length: size }, (n) => ({
     foo: 'yarp',
     nope: {
       bar: `123${add}`,
@@ -24,22 +30,17 @@ function createObj(source, add = '') {
 }
 
 function main({ size, n, method, strict }) {
-  const len = Math.min(Math.ceil(n / size), 20);
-
-  const source = Array.apply(null, Array(size));
-  const actual = createObj(source);
-  const expected = createObj(source);
-  const expectedWrong = createObj(source, '4');
-
   if (strict) {
     method = method.replace('eep', 'eepStrict');
   }
   const fn = assert[method];
-  const value2 = method.includes('not') ? expectedWrong : expected;
+
+  const actual = createObj(size);
+  const expected = method.includes('not') ? createObj(size, '4') : createObj(size);
 
   bench.start();
-  for (let i = 0; i < len; ++i) {
-    fn(actual, value2);
+  for (let i = 0; i < n; ++i) {
+    fn(actual, expected);
   }
-  bench.end(len);
+  bench.end(n);
 }

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

@@ -2,35 +2,77 @@
 const common = require('../common.js');
 const assert = require('assert');
 
+const circular = {};
+circular.circular = circular;
+const circular2 = {};
+circular2.circular = circular2;
+const notCircular = {};
+notCircular.circular = {};
+
 const primValues = {
-  'string': 'a',
-  'number': 1,
-  'object': { 0: 'a' },
+  'string': 'abcdef',
+  'number': 1_000,
+  'boolean': true,
+  'object': { property: 'abcdef' },
+  'object_other_property': { property: 'abcdef' },
+  'array': [1, 2, 3],
+  'set_object': new Set([[1]]),
+  'set_simple': new Set([1, 2, 3]),
+  'circular': circular,
+  'empty_object': {},
+  'regexp': /abc/i,
+  'date': new Date(),
+};
+
+const primValues2 = {
+  'object': { property: 'abcdef' },
   'array': [1, 2, 3],
+  'set_object': new Set([[1]]),
+  'set_simple': new Set([1, 3, 2]),
+  'circular': circular2,
+  'empty_object': {},
+  'regexp': /abc/i,
+  'date': new Date(primValues.date),
+};
+
+const primValuesUnequal = {
+  'string': 'abcdez',
+  'number': 1_001,
+  'boolean': false,
+  'object': { property2: 'abcdef' },
+  'array': [1, 3, 2],
+  'set_object': new Set([[2]]),
+  'set_simple': new Set([1, 4, 2]),
+  'circular': notCircular,
+  'empty_object': [],
+  'regexp': /abc/g,
+  'date': new Date(primValues.date.getTime() + 1),
 };
 
 const bench = common.createBenchmark(main, {
   primitive: Object.keys(primValues),
-  n: [2e4],
+  n: [1e5],
   strict: [0, 1],
   method: ['deepEqual', 'notDeepEqual'],
+}, {
+  combinationFilter: (p) => {
+    return p.strict === 1 || p.method === 'deepEqual';
+  },
 });
 
 function main({ n, primitive, method, strict }) {
   const prim = primValues[primitive];
-  const actual = prim;
-  const expected = prim;
-  const expectedWrong = 'b';
+  const actual = primValues2[primitive] ?? prim;
+  const expected = method.includes('not') ? primValuesUnequal[primitive] : prim;
 
   if (strict) {
     method = method.replace('eep', 'eepStrict');
   }
   const fn = assert[method];
-  const value2 = method.includes('not') ? expectedWrong : expected;
 
   bench.start();
   for (let i = 0; i < n; ++i) {
-    fn([actual], [value2]);
+    fn(actual, expected);
   }
   bench.end(n);
 }

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

@@ -4,18 +4,10 @@ const common = require('../common.js');
 const { deepEqual, deepStrictEqual, notDeepEqual, notDeepStrictEqual } =
   require('assert');
 
-const primValues = {
-  'string': 'a',
-  'number': 1,
-  'object': { 0: 'a' },
-  'array': [1, 2, 3],
-};
-
 const bench = common.createBenchmark(main, {
-  primitive: Object.keys(primValues),
-  n: [25],
-  len: [2e4],
-  strict: [0, 1],
+  n: [5e2],
+  len: [1e4],
+  strict: [1],
   method: [
     'deepEqual_Array',
     'notDeepEqual_Array',
@@ -32,38 +24,32 @@ function run(fn, n, actual, expected) {
   bench.end(n);
 }
 
-function main({ n, len, primitive, method, strict }) {
-  const prim = primValues[primitive];
+function main({ n, len, method, strict }) {
   const actual = [];
   const expected = [];
-  const expectedWrong = [];
 
-  for (let x = 0; x < len; x++) {
-    actual.push(prim);
-    expected.push(prim);
-    expectedWrong.push(prim);
+  for (let i = 0; i < len; i++) {
+    actual.push(i);
+    expected.push(i);
+  }
+  if (method.includes('not')) {
+    expected[len - 1] += 1;
   }
-  expectedWrong.pop();
-  expectedWrong.push('b');
-
-  // Note: primitives are only added once to a set
-  const actualSet = new Set(actual);
-  const expectedSet = new Set(expected);
-  const expectedWrongSet = new Set(expectedWrong);
 
   switch (method) {
     case 'deepEqual_Array':
       run(strict ? deepStrictEqual : deepEqual, n, actual, expected);
       break;
     case 'notDeepEqual_Array':
-      run(strict ? notDeepStrictEqual : notDeepEqual, n, actual, expectedWrong);
+      run(strict ? notDeepStrictEqual : notDeepEqual, n, actual, expected);
       break;
     case 'deepEqual_Set':
-      run(strict ? deepStrictEqual : deepEqual, n, actualSet, expectedSet);
+      run(strict ? deepStrictEqual : deepEqual,
+          n, new Set(actual), new Set(expected));
       break;
     case 'notDeepEqual_Set':
       run(strict ? notDeepStrictEqual : notDeepEqual,
-          n, actualSet, expectedWrongSet);
+          n, new Set(actual), new Set(expected));
       break;
     default:
       throw new Error(`Unsupported method "${method}"`);

benchmark/assert/deepequal-typedarrays.js

@@ -7,8 +7,7 @@ const bench = common.createBenchmark(main, {
     'Int8Array',
     'Uint8Array',
     'Float32Array',
-    'Float64Array',
-    'Uint8ClampedArray',
+    'Uint32Array',
   ],
   n: [5e2],
   strict: [0, 1],
@@ -23,21 +22,24 @@ function main({ type, n, len, method, strict }) {
   const clazz = global[type];
   const actual = new clazz(len);
   const expected = new clazz(len);
-  const expectedWrong = new clazz(len);
-  const wrongIndex = Math.floor(len / 2);
-  expectedWrong[wrongIndex] = 123;
 
   if (strict) {
     method = method.replace('eep', 'eepStrict');
   }
   const fn = assert[method];
-  const value2 = method.includes('not') ? expectedWrong : expected;
+
+  if (method.includes('not')) {
+    expected[Math.floor(len / 2)] = 123;
+  }
 
   bench.start();
   for (let i = 0; i < n; ++i) {
     actual[0] = i;
-    value2[0] = i;
-    fn(actual, value2);
+    expected[0] = i;
+    const pos = Math.ceil(len / 2) + 1;
+    actual[pos] = i;
+    expected[pos] = i;
+    fn(actual, expected);
   }
   bench.end(n);
 }