test: ensure assertions are reached on more tests

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

Author: aduh95

test/eslint.config_partial.mjs

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

test/parallel/test-tcp-wrap-connect.js

@@ -1,6 +1,6 @@
 // Flags: --expose-internals
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const { internalBinding } = require('internal/test/binding');
 const {
@@ -17,7 +17,7 @@ function makeConnection() {
   const err = client.connect(req, '127.0.0.1', this.address().port);
   assert.strictEqual(err, 0);
 
-  req.oncomplete = function(status, client_, req_, readable, writable) {
+  req.oncomplete = common.mustCall((status, client_, req_, readable, writable) => {
     assert.strictEqual(status, 0);
     assert.strictEqual(client_, client);
     assert.strictEqual(req_, req);
@@ -28,14 +28,14 @@ function makeConnection() {
     const err = client.shutdown(shutdownReq);
     assert.strictEqual(err, 0);
 
-    shutdownReq.oncomplete = function(status, client_, error) {
+    shutdownReq.oncomplete = common.mustCall((status, client_, error) => {
       assert.strictEqual(status, 0);
       assert.strictEqual(client_, client);
       assert.strictEqual(error, undefined);
       shutdownCount++;
       client.close();
-    };
-  };
+    });
+  });
 }
 
 let connectCount = 0;

test/parallel/test-tcp-wrap-listen.js

@@ -24,7 +24,7 @@ server.getsockname(port);
 
 server.listen(128);
 
-server.onconnection = (err, client) => {
+server.onconnection = common.mustCall((err, client) => {
   assert.strictEqual(client.writeQueueSize, 0);
   console.log('got connection');
 
@@ -82,7 +82,7 @@ server.onconnection = (err, client) => {
       maybeCloseClient();
     }
   }, 2);
-};
+});
 
 const net = require('net');
 

test/parallel/test-timers-immediate-queue-throw.js

@@ -31,7 +31,7 @@ process.once('uncaughtException', common.mustCall((err, errorOrigin) => {
 
 const d1 = domain.create();
 d1.once('error', common.expectsError(errObj));
-d1.once('error', () => assert.strictEqual(stage, 0));
+d1.once('error', common.mustCall(() => assert.strictEqual(stage, 0)));
 
 const run = common.mustCall((callStage) => {
   assert(callStage >= stage);

test/parallel/test-timers-interval-promisified.js

@@ -196,7 +196,7 @@ const { setInterval } = timerPromises;
     const { signal } = controller;
     const delay = 10;
     let totalIterations = 0;
-    const timeoutLoop = runInterval(async (iterationNumber) => {
+    const timeoutLoop = runInterval(common.mustCallAtLeast(async (iterationNumber) => {
       await setPromiseTimeout(delay * 4);
       if (iterationNumber <= 2) {
         assert.strictEqual(signal.aborted, false);
@@ -210,7 +210,7 @@ const { setInterval } = timerPromises;
       if (iterationNumber > totalIterations) {
         totalIterations = iterationNumber;
       }
-    }, delay, signal);
+    }, 0), delay, signal);
 
     timeoutLoop.catch(common.mustCall(() => {
       assert.ok(totalIterations >= 3, `iterations was ${totalIterations} < 3`);

test/parallel/test-timers-promises-scheduler.js

@@ -4,11 +4,7 @@ const common = require('../common');
 
 const { scheduler } = require('timers/promises');
 const { setTimeout } = require('timers');
-const {
-  strictEqual,
-  rejects,
-  throws,
-} = require('assert');
+const assert = require('assert');
 
 async function testYield() {
   await scheduler.yield();
@@ -23,7 +19,7 @@ async function testWait() {
   let value = 0;
   setTimeout(() => value++, 10);
   await scheduler.wait(15);
-  strictEqual(value, 1);
+  assert.strictEqual(value, 1);
 }
 
 testWait().then(common.mustCall());
@@ -32,7 +28,7 @@ async function testCancelableWait1() {
   const ac = new AbortController();
   const wait = scheduler.wait(1e6, { signal: ac.signal });
   ac.abort();
-  await rejects(wait, {
+  await assert.rejects(wait, {
     code: 'ABORT_ERR',
     message: 'The operation was aborted',
   });
@@ -42,14 +38,14 @@ testCancelableWait1().then(common.mustCall());
 
 async function testCancelableWait2() {
   const wait = scheduler.wait(10000, { signal: AbortSignal.abort() });
-  await rejects(wait, {
+  await assert.rejects(wait, {
     code: 'ABORT_ERR',
     message: 'The operation was aborted',
   });
 }
 
 testCancelableWait2().then(common.mustCall());
 
-throws(() => new scheduler.constructor(), {
+assert.throws(() => new scheduler.constructor(), {
   code: 'ERR_ILLEGAL_CONSTRUCTOR',
 });

test/parallel/test-timers-refresh.js

@@ -4,7 +4,7 @@
 
 const common = require('../common');
 
-const { strictEqual, throws } = require('assert');
+const assert = require('assert');
 const { setUnrefTimeout } = require('internal/timers');
 
 // Schedule the unrefed cases first so that the later case keeps the event loop
@@ -24,16 +24,16 @@ const { setUnrefTimeout } = require('internal/timers');
   // This relies on implicit timers handle sorting within libuv.
 
   setTimeout(common.mustCall(() => {
-    strictEqual(called, false, 'unref()\'d timer returned before check');
+    assert.strictEqual(called, false);
   }), 1);
 
-  strictEqual(timer.refresh(), timer);
+  assert.strictEqual(timer.refresh(), timer);
 }
 
 // Should throw with non-functions
 {
   [null, true, false, 0, 1, NaN, '', 'foo', {}, Symbol()].forEach((cb) => {
-    throws(
+    assert.throws(
       () => setUnrefTimeout(cb),
       {
         code: 'ERR_INVALID_ARG_TYPE',
@@ -50,10 +50,10 @@ const { setUnrefTimeout } = require('internal/timers');
   }), 1);
 
   setUnrefTimeout(common.mustCall(() => {
-    strictEqual(called, false, 'unref pooled timer returned before check');
+    assert.strictEqual(called, false);
   }), 1);
 
-  strictEqual(timer.refresh(), timer);
+  assert.strictEqual(timer.refresh(), timer);
 }
 
 // regular timer
@@ -64,10 +64,10 @@ const { setUnrefTimeout } = require('internal/timers');
   }), 1);
 
   setTimeout(common.mustCall(() => {
-    strictEqual(called, false, 'pooled timer returned before check');
+    assert.strictEqual(called, false);
   }), 1);
 
-  strictEqual(timer.refresh(), timer);
+  assert.strictEqual(timer.refresh(), timer);
 }
 
 // regular timer
@@ -78,7 +78,7 @@ const { setUnrefTimeout } = require('internal/timers');
       called = true;
       process.nextTick(common.mustCall(() => {
         timer.refresh();
-        strictEqual(timer.hasRef(), true);
+        assert.strictEqual(timer.hasRef(), true);
       }));
     }
   }, 2), 1);
@@ -95,8 +95,8 @@ const { setUnrefTimeout } = require('internal/timers');
   }, 2), 1);
 
   setTimeout(common.mustCall(() => {
-    strictEqual(called, 0, 'pooled timer returned before check');
+    assert.strictEqual(called, 0);
   }), 1);
 
-  strictEqual(timer.refresh(), timer);
+  assert.strictEqual(timer.refresh(), timer);
 }

test/parallel/test-timers-unref-throw-then-ref.js

@@ -9,11 +9,11 @@ process.once('uncaughtException', common.mustCall((err) => {
 }));
 
 let called = false;
-const t = setTimeout(() => {
+const t = setTimeout(common.mustCall(() => {
   assert(!called);
   called = true;
   t.ref();
   throw new Error('Timeout Error');
-}, 1).unref();
+}), 1).unref();
 
 setTimeout(common.mustCall(), 1);

test/parallel/test-timers-user-call.js

@@ -25,12 +25,12 @@ const common = require('../common');
 }
 
 {
-  const testInterval = (...args) => {
+  const testInterval = common.mustCall((...args) => {
     const fn = common.mustCall(() => { clearInterval(interval); });
     fn.call = 'not a function';
     fn.apply = 'also not a function';
     const interval = setInterval(fn, 1, ...args);
-  };
+  }, 5);
 
   testInterval();
   testInterval('oneArg');

test/parallel/test-tls-add-context.js

@@ -22,7 +22,7 @@ const serverOptions = {
 
 let connections = 0;
 
-const server = tls.createServer(serverOptions, (c) => {
+const server = tls.createServer(serverOptions, common.mustCall((c) => {
   if (++connections === 3) {
     server.close();
   }
@@ -31,7 +31,7 @@ const server = tls.createServer(serverOptions, (c) => {
     return;
   }
   assert.strictEqual(c.authorized, true);
-});
+}, 3));
 
 const secureContext = {
   key: loadPEM('agent1-key'),