reduce ESLint exceptions in benchmarks

benchmark/assert/deepequal-buffer.js

@@ -14,6 +14,8 @@ const bench = common.createBenchmark(main, {
 });
 
 function main({ len, n, method }) {
+ if (!method)
+ method = 'deepEqual';
  const data = Buffer.allocUnsafe(len + 1);
  const actual = Buffer.alloc(len);
  const expected = Buffer.alloc(len);
@@ -22,8 +24,7 @@ function main({ len, n, method }) {
  data.copy(expected);
  data.copy(expectedWrong);
 
- // eslint-disable-next-line no-restricted-properties
- const fn = method !== '' ? assert[method] : assert.deepEqual;
+ const fn = assert[method];
  const value2 = method.includes('not') ? expectedWrong : expected;
 
  bench.start();

benchmark/assert/deepequal-map.js

@@ -1,9 +1,8 @@
 'use strict';
 
-/* eslint-disable no-restricted-properties */
-
 const common = require('../common.js');
-const assert = require('assert');
+const { deepEqual, deepStrictEqual, notDeepEqual, notDeepStrictEqual } =
+ require('assert');
 
 const bench = common.createBenchmark(main, {
  n: [5e2],
@@ -47,74 +46,74 @@ 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(assert.deepEqual, n, values);
+ benchmark(deepEqual, n, values);
  break;
  case 'deepStrictEqual_primitiveOnly':
  values = array.map((_, i) => [`str_${i}`, 123]);
- benchmark(assert.deepStrictEqual, n, values);
+ benchmark(deepStrictEqual, n, values);
  break;
  case 'deepEqual_objectOnly':
  values = array.map((_, i) => [[`str_${i}`, 1], 123]);
- benchmark(assert.deepEqual, n, values);
+ benchmark(deepEqual, n, values);
  break;
  case 'deepStrictEqual_objectOnly':
  values = array.map((_, i) => [[`str_${i}`, 1], 123]);
- benchmark(assert.deepStrictEqual, n, values);
+ benchmark(deepStrictEqual, n, values);
  break;
  case 'deepEqual_mixed':
  values = array.map((_, i) => [i % 2 ? [`str_${i}`, 1] : `str_${i}`, 123]);
- benchmark(assert.deepEqual, n, values);
+ benchmark(deepEqual, n, values);
  break;
  case 'deepStrictEqual_mixed':
  values = array.map((_, i) => [i % 2 ? [`str_${i}`, 1] : `str_${i}`, 123]);
- benchmark(assert.deepStrictEqual, n, values);
+ 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(assert.deepEqual, n, values, values2);
+ benchmark(deepEqual, n, values, values2);
  break;
  case 'notDeepEqual_primitiveOnly':
  values = array.map((_, i) => [`str_${i}`, 123]);
  values2 = values.slice(0);
  values2[Math.floor(len / 2)] = ['w00t', 123];
- benchmark(assert.notDeepEqual, n, values, values2);
+ 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(assert.notDeepStrictEqual, n, values, values2);
+ benchmark(notDeepStrictEqual, 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(assert.notDeepEqual, n, values, values2);
+ 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(assert.notDeepStrictEqual, n, values, values2);
+ benchmark(notDeepStrictEqual, 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(assert.notDeepEqual, n, values, values2);
+ 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(assert.notDeepStrictEqual, n, values, values2);
+ 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(assert.notDeepEqual, n, values, values2);
+ benchmark(notDeepEqual, n, values, values2);
  break;
  default:
  throw new Error(`Unsupported method ${method}`);

benchmark/assert/deepequal-object.js

@@ -29,13 +29,15 @@ function main({ size, n, method }) {
  // TODO: Fix this "hack". `n` should not be manipulated.
  n = n / size;
 
+ if (!method)
+ method = 'deepEqual';
+
  const source = Array.apply(null, Array(size));
  const actual = createObj(source);
  const expected = createObj(source);
  const expectedWrong = createObj(source, '4');
 
- // eslint-disable-next-line no-restricted-properties
- const fn = method !== '' ? assert[method] : assert.deepEqual;
+ const fn = assert[method];
  const value2 = method.includes('not') ? expectedWrong : expected;
 
  bench.start();

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

@@ -1,7 +1,8 @@
 'use strict';
 
 const common = require('../common.js');
-const assert = require('assert');
+const { deepEqual, deepStrictEqual, notDeepEqual, notDeepStrictEqual } =
+ require('assert');
 
 const primValues = {
  'null': null,
@@ -61,32 +62,28 @@ function main({ n, len, primitive, method }) {
  // Empty string falls through to next line as default, mostly for tests.
  case '':
  case 'deepEqual_Array':
- // eslint-disable-next-line no-restricted-properties
- run(assert.deepEqual, n, actual, expected);
+ run(deepEqual, n, actual, expected);
  break;
  case 'deepStrictEqual_Array':
- run(assert.deepStrictEqual, n, actual, expected);
+ run(deepStrictEqual, n, actual, expected);
  break;
  case 'notDeepEqual_Array':
- // eslint-disable-next-line no-restricted-properties
- run(assert.notDeepEqual, n, actual, expectedWrong);
+ run(notDeepEqual, n, actual, expectedWrong);
  break;
  case 'notDeepStrictEqual_Array':
- run(assert.notDeepStrictEqual, n, actual, expectedWrong);
+ run(notDeepStrictEqual, n, actual, expectedWrong);
  break;
  case 'deepEqual_Set':
- // eslint-disable-next-line no-restricted-properties
- run(assert.deepEqual, n, actualSet, expectedSet);
+ run(deepEqual, n, actualSet, expectedSet);
  break;
  case 'deepStrictEqual_Set':
- run(assert.deepStrictEqual, n, actualSet, expectedSet);
+ run(deepStrictEqual, n, actualSet, expectedSet);
  break;
  case 'notDeepEqual_Set':
- // eslint-disable-next-line no-restricted-properties
- run(assert.notDeepEqual, n, actualSet, expectedWrongSet);
+ run(notDeepEqual, n, actualSet, expectedWrongSet);
  break;
  case 'notDeepStrictEqual_Set':
- run(assert.notDeepStrictEqual, n, actualSet, expectedWrongSet);
+ run(notDeepStrictEqual, n, actualSet, expectedWrongSet);
  break;
  default:
  throw new Error(`Unsupported method "${method}"`);

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

@@ -25,13 +25,14 @@ const bench = common.createBenchmark(main, {
 });
 
 function main({ n, primitive, method }) {
+ if (!method)
+ method = 'deepEqual';
  const prim = primValues[primitive];
  const actual = prim;
  const expected = prim;
  const expectedWrong = 'b';
 
- // eslint-disable-next-line no-restricted-properties
- const fn = method !== '' ? assert[method] : assert.deepEqual;
+ const fn = assert[method];
  const value2 = method.includes('not') ? expectedWrong : expected;
 
  bench.start();

benchmark/assert/deepequal-set.js

@@ -1,9 +1,8 @@
 'use strict';
 
-/* eslint-disable no-restricted-properties */
-
 const common = require('../common.js');
-const assert = require('assert');
+const { deepEqual, deepStrictEqual, notDeepEqual, notDeepStrictEqual } =
+ require('assert');
 
 const bench = common.createBenchmark(main, {
  n: [5e2],
@@ -48,82 +47,82 @@ 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}`);
- benchmark(assert.deepEqual, n, values);
+ benchmark(deepEqual, n, values);
  break;
  case 'deepStrictEqual_primitiveOnly':
  values = array.map((_, i) => `str_${i}`);
- benchmark(assert.deepStrictEqual, n, values);
+ benchmark(deepStrictEqual, n, values);
  break;
  case 'deepEqual_objectOnly':
  values = array.map((_, i) => [`str_${i}`, null]);
- benchmark(assert.deepEqual, n, values);
+ benchmark(deepEqual, n, values);
  break;
  case 'deepStrictEqual_objectOnly':
  values = array.map((_, i) => [`str_${i}`, null]);
- benchmark(assert.deepStrictEqual, n, values);
+ benchmark(deepStrictEqual, n, values);
  break;
  case 'deepEqual_mixed':
  values = array.map((_, i) => {
  return i % 2 ? [`str_${i}`, null] : `str_${i}`;
  });
- benchmark(assert.deepEqual, n, values);
+ benchmark(deepEqual, n, values);
  break;
  case 'deepStrictEqual_mixed':
  values = array.map((_, i) => {
  return i % 2 ? [`str_${i}`, null] : `str_${i}`;
  });
- benchmark(assert.deepStrictEqual, n, values);
+ benchmark(deepStrictEqual, n, values);
  break;
  case 'deepEqual_looseMatches':
  values = array.map((_, i) => i);
  values2 = values.slice().map((v) => String(v));
- benchmark(assert.deepEqual, n, values, values2);
+ benchmark(deepEqual, n, values, values2);
  break;
  case 'notDeepEqual_primitiveOnly':
  values = array.map((_, i) => `str_${i}`);
  values2 = values.slice(0);
  values2[Math.floor(len / 2)] = 'w00t';
- benchmark(assert.notDeepEqual, n, values, values2);
+ benchmark(notDeepEqual, n, values, values2);
  break;
  case 'notDeepStrictEqual_primitiveOnly':
  values = array.map((_, i) => `str_${i}`);
  values2 = values.slice(0);
  values2[Math.floor(len / 2)] = 'w00t';
- benchmark(assert.notDeepStrictEqual, n, values, values2);
+ benchmark(notDeepStrictEqual, n, values, values2);
  break;
  case 'notDeepEqual_objectOnly':
  values = array.map((_, i) => [`str_${i}`, null]);
  values2 = values.slice(0);
  values2[Math.floor(len / 2)] = ['w00t'];
- benchmark(assert.notDeepEqual, n, values, values2);
+ benchmark(notDeepEqual, n, values, values2);
  break;
  case 'notDeepStrictEqual_objectOnly':
  values = array.map((_, i) => [`str_${i}`, null]);
  values2 = values.slice(0);
  values2[Math.floor(len / 2)] = ['w00t'];
- benchmark(assert.notDeepStrictEqual, n, values, values2);
+ benchmark(notDeepStrictEqual, n, values, values2);
  break;
  case 'notDeepEqual_mixed':
  values = array.map((_, i) => {
  return i % 2 ? [`str_${i}`, null] : `str_${i}`;
  });
  values2 = values.slice();
  values2[0] = 'w00t';
- benchmark(assert.notDeepEqual, n, values, values2);
+ benchmark(notDeepEqual, n, values, values2);
  break;
  case 'notDeepStrictEqual_mixed':
  values = array.map((_, i) => {
  return i % 2 ? [`str_${i}`, null] : `str_${i}`;
  });
  values2 = values.slice();
  values2[0] = 'w00t';
- benchmark(assert.notDeepStrictEqual, n, values, values2);
+ benchmark(notDeepStrictEqual, n, values, values2);
  break;
  case 'notDeepEqual_looseMatches':
  values = array.map((_, i) => i);
  values2 = values.slice().map((v) => String(v));
  values2[len - 1] = String(len + 1);
- benchmark(assert.notDeepEqual, n, values, values2);
+ benchmark(notDeepEqual, n, values, values2);
  break;
  default:
  throw new Error(`Unsupported method "${method}"`);

benchmark/assert/deepequal-typedarrays.js

@@ -25,15 +25,16 @@ const bench = common.createBenchmark(main, {
 });
 
 function main({ type, n, len, method }) {
+ if (!method)
+ method = 'deepEqual';
  const clazz = global[type];
  const actual = new clazz(len);
  const expected = new clazz(len);
  const expectedWrong = Buffer.alloc(len);
  const wrongIndex = Math.floor(len / 2);
  expectedWrong[wrongIndex] = 123;
 
- // eslint-disable-next-line no-restricted-properties
- const fn = method !== '' ? assert[method] : assert.deepEqual;
+ const fn = assert[method];
  const value2 = method.includes('not') ? expectedWrong : expected;
 
  bench.start();

benchmark/assert/throws.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const common = require('../common.js');
-const assert = require('assert');
+const { throws, doesNotThrow } = require('assert');
 
 const bench = common.createBenchmark(main, {
  n: [1e6],
@@ -14,8 +14,8 @@ const bench = common.createBenchmark(main, {
 });
 
 function main({ n, method }) {
- const throws = () => { throw new TypeError('foobar'); };
- const doesNotThrow = () => { return 'foobar'; };
+ const throwError = () => { throw new TypeError('foobar'); };
+ const doNotThrowError = () => { return 'foobar'; };
  const regExp = /foobar/;
  const message = 'failure';
  var i;
@@ -26,30 +26,28 @@ function main({ n, method }) {
  case 'doesNotThrow':
  bench.start();
  for (i = 0; i < n; ++i) {
- // eslint-disable-next-line no-restricted-syntax
- assert.doesNotThrow(doesNotThrow);
+ doesNotThrow(doNotThrowError);
  }
  bench.end(n);
  break;
  case 'throws':
  bench.start();
  for (i = 0; i < n; ++i) {
- // eslint-disable-next-line no-restricted-syntax
- assert.throws(throws);
+ throws(throwError);
  }
  bench.end(n);
  break;
  case 'throws_TypeError':
  bench.start();
  for (i = 0; i < n; ++i) {
- assert.throws(throws, TypeError, message);
+ throws(throwError, TypeError, message);
  }
  bench.end(n);
  break;
  case 'throws_RegExp':
  bench.start();
  for (i = 0; i < n; ++i) {
- assert.throws(throws, regExp, message);
+ throws(throwError, regExp, message);
  }
  bench.end(n);
  break;