test: ensure assertions are reached on more tests

PR-URL: #60726
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>

Author: aduh95

test/eslint.config_partial.mjs

@@ -194,7 +194,7 @@ export default [
       ].join(',')}}/**/*.{js,mjs,cjs}`,
       `test/parallel/test-{${
         // 0x61 is code for 'a', this generates a string enumerating latin letters: 'a*,b*,…'
-        Array.from({ length: 4 }, (_, i) => String.fromCharCode(0x61 + i, 42)).join(',')
+        Array.from({ length: 7 }, (_, i) => String.fromCharCode(0x61 + i, 42)).join(',')
       },http-*,http2-*,${
         // 0x61 is code for 'a', this generates a string enumerating latin letters: 'z*,y*,…'
         Array.from({ length: 7 }, (_, i) => String.fromCharCode(0x61 + 25 - i, 42)).join(',')

test/parallel/test-error-format-list.js

@@ -2,7 +2,7 @@
 'use strict';
 
 const common = require('../common');
-const { strictEqual } = require('node:assert');
+const assert = require('node:assert');
 const { formatList } = require('internal/errors');
 
 if (!common.hasIntl) common.skip('missing Intl');
@@ -14,7 +14,7 @@ if (!common.hasIntl) common.skip('missing Intl');
   const input = ['apple', 'banana', 'orange', 'pear'];
   for (let i = 0; i < input.length; i++) {
     const slicedInput = input.slice(0, i);
-    strictEqual(formatList(slicedInput), and.format(slicedInput));
-    strictEqual(formatList(slicedInput, 'or'), or.format(slicedInput));
+    assert.strictEqual(formatList(slicedInput), and.format(slicedInput));
+    assert.strictEqual(formatList(slicedInput, 'or'), or.format(slicedInput));
   }
 }

test/parallel/test-error-reporting.js

@@ -28,7 +28,7 @@ const fixtures = require('../common/fixtures');
 function errExec(script, option, callback) {
   callback = typeof option === 'function' ? option : callback;
   option = typeof option === 'string' ? option : '';
-  return exec(...common.escapePOSIXShell`"${process.execPath}" ${option} "${fixtures.path(script)}"`, (err, stdout, stderr) => {
+  return exec(...common.escapePOSIXShell`"${process.execPath}" ${option} "${fixtures.path(script)}"`, common.mustCall((err, stdout, stderr) => {
     // There was some error
     assert.ok(err);
 
@@ -37,7 +37,7 @@ function errExec(script, option, callback) {
 
     // Proxy the args for more tests.
     callback(err, stdout, stderr);
-  });
+  }));
 }
 
 const syntaxErrorMessage = /\bSyntaxError\b/;

test/parallel/test-error-value-type-detection.mjs

@@ -1,211 +1,211 @@
 // Flags: --expose-internals
 
 import '../common/index.mjs';
-import { strictEqual } from 'node:assert';
+import assert from 'node:assert';
 import errorsModule from 'internal/errors';
 
 
 const { determineSpecificType } = errorsModule;
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(1n),
   'type bigint (1n)',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(true),
   'type boolean (true)',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(false),
   'type boolean (false)',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(2),
   'type number (2)',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(NaN),
   'type number (NaN)',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(Infinity),
   'type number (Infinity)',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType({ __proto__: null }),
   '[Object: null prototype] {}',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(''),
   "type string ('')",
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(''),
   "type string ('')",
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType("''"),
   "type string (\"''\")",
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType('Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor'),
   "type string ('Lorem ipsum dolor sit ame...')",
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor'"),
   "type string ('Lorem ipsum dolor sit ame...')",
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType("Lorem' ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor"),
   "type string (\"Lorem' ipsum dolor sit am...\")",
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(Symbol('foo')),
   'type symbol (Symbol(foo))',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(function foo() {}),
   'function foo',
 );
 
 const implicitlyNamed = function() {}; // eslint-disable-line func-style
-strictEqual(
+assert.strictEqual(
   determineSpecificType(implicitlyNamed),
   'function implicitlyNamed',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(() => {}),
   'function ',
 );
 function noName() {}
 delete noName.name;
-strictEqual(
+assert.strictEqual(
   noName.name,
   '',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(noName),
   'function ',
 );
 
 function * generatorFn() {}
-strictEqual(
+assert.strictEqual(
   determineSpecificType(generatorFn),
   'function generatorFn',
 );
 
 async function asyncFn() {}
-strictEqual(
+assert.strictEqual(
   determineSpecificType(asyncFn),
   'function asyncFn',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(null),
   'null',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(undefined),
   'undefined',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType([]),
   'an instance of Array',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Array()),
   'an instance of Array',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new BigInt64Array()),
   'an instance of BigInt64Array',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new BigUint64Array()),
   'an instance of BigUint64Array',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Int8Array()),
   'an instance of Int8Array',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Int16Array()),
   'an instance of Int16Array',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Int32Array()),
   'an instance of Int32Array',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Float32Array()),
   'an instance of Float32Array',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Float64Array()),
   'an instance of Float64Array',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Uint8Array()),
   'an instance of Uint8Array',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Uint8ClampedArray()),
   'an instance of Uint8ClampedArray',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Uint16Array()),
   'an instance of Uint16Array',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Uint32Array()),
   'an instance of Uint32Array',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Date()),
   'an instance of Date',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Map()),
   'an instance of Map',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new WeakMap()),
   'an instance of WeakMap',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType({}),
   'an instance of Object',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Object()),
   'an instance of Object',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(Promise.resolve('foo')),
   'an instance of Promise',
 );
 
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new Set()),
   'an instance of Set',
 );
-strictEqual(
+assert.strictEqual(
   determineSpecificType(new WeakSet()),
   'an instance of WeakSet',
 );

test/parallel/test-errors-aborterror.js

@@ -2,30 +2,27 @@
 'use strict';
 
 require('../common');
-const {
-  strictEqual,
-  throws,
-} = require('assert');
+const assert = require('assert');
 const { AbortError } = require('internal/errors');
 
 {
   const err = new AbortError();
-  strictEqual(err.message, 'The operation was aborted');
-  strictEqual(err.cause, undefined);
+  assert.strictEqual(err.message, 'The operation was aborted');
+  assert.strictEqual(err.cause, undefined);
 }
 
 {
   const cause = new Error('boom');
   const err = new AbortError('bang', { cause });
-  strictEqual(err.message, 'bang');
-  strictEqual(err.cause, cause);
+  assert.strictEqual(err.message, 'bang');
+  assert.strictEqual(err.cause, cause);
 }
 
 {
-  throws(() => new AbortError('', false), {
+  assert.throws(() => new AbortError('', false), {
     code: 'ERR_INVALID_ARG_TYPE'
   });
-  throws(() => new AbortError('', ''), {
+  assert.throws(() => new AbortError('', ''), {
     code: 'ERR_INVALID_ARG_TYPE'
   });
 }

test/parallel/test-errors-hide-stack-frames.js

@@ -1,7 +1,7 @@
 // Flags: --expose-internals
 'use strict';
 
-require('../common');
+const common = require('../common');
 const { hideStackFrames, codes } = require('internal/errors');
 const { validateInteger } = require('internal/validators');
 const assert = require('assert');
@@ -209,19 +209,15 @@ const assert = require('assert');
 
 {
   // Binding passes the value of this to the wrapped function.
-  let called = false;
   function a() {
     b.bind({ key: 'value' })();
   }
 
-  const b = hideStackFrames(function b() {
+  const b = hideStackFrames(common.mustCall(function b() {
     assert.strictEqual(this.key, 'value');
-    called = true;
-  });
+  }));
 
   a();
-
-  assert.strictEqual(called, true);
 }
 
 {
@@ -231,10 +227,10 @@ const assert = require('assert');
     b.withoutStackTrace.bind({ key: 'value' })();
   }
 
-  const b = hideStackFrames(function b() {
+  const b = hideStackFrames(common.mustCall(function b() {
     assert.strictEqual(this.key, 'value');
     called = true;
-  });
+  }));
 
   a();