test: ensure assertions are reached on more tests

PR-URL: #60759
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>

Author: aduh95

test/eslint.config_partial.mjs

@@ -194,8 +194,8 @@ 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: 7},(_,i)=>String.fromCharCode(0x61+i,42)).join(',')
-},http-*,http2-*,${
+Array.from({length: 13},(_,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(',')
 }}.{js,mjs,cjs}`,

test/parallel/test-h2leak-destroy-session-on-socket-ended.js

@@ -69,9 +69,7 @@ function client() {
 rejectUnauthorized: false,
 ALPNProtocols: ['h2']
 },()=>{
-client.end(Buffer.concat(h2fstStream.map((s)=>Buffer.from(s,'base64'))),(err)=>{
-assert.ifError(err);
-});
+client.end(Buffer.concat(h2fstStream.map((s)=>Buffer.from(s,'base64'))),common.mustSucceed());
 });
 
 client.on('error',(error)=>{

test/parallel/test-handle-wrap-hasref.js

@@ -2,25 +2,21 @@
 'use strict';
 
 constcommon=require('../common');
-conststrictEqual=require('assert').strictEqual;
+constassert=require('assert');
 const{ internalBinding }=require('internal/test/binding');
 
 // child_process
 {
 constspawn=require('child_process').spawn;
 constcmd=common.isWindows ? 'rundll32' : 'ls';
 constcp=spawn(cmd);
-strictEqual(cp._handle.hasRef(),
-true,'process_wrap: not initially refed');
+assert.strictEqual(cp._handle.hasRef(),true);
 cp.unref();
-strictEqual(cp._handle.hasRef(),
-false,'process_wrap: unref() ineffective');
+assert.strictEqual(cp._handle.hasRef(),false);
 cp.ref();
-strictEqual(cp._handle.hasRef(),
-true,'process_wrap: ref() ineffective');
+assert.strictEqual(cp._handle.hasRef(),true);
 cp._handle.close(common.mustCall(()=>
-strictEqual(cp._handle.hasRef(),
-false,'process_wrap: not unrefed on close')));
+assert.strictEqual(cp._handle.hasRef(),false)));
 }
 
 
@@ -32,17 +28,13 @@ const { kStateSymbol } = require('internal/dgram');
 constsock4=dgram.createSocket('udp4');
 consthandle=sock4[kStateSymbol].handle;
 
-strictEqual(handle.hasRef(),
-true,'udp_wrap: ipv4: not initially refed');
+assert.strictEqual(handle.hasRef(),true);
 sock4.unref();
-strictEqual(handle.hasRef(),
-false,'udp_wrap: ipv4: unref() ineffective');
+assert.strictEqual(handle.hasRef(),false);
 sock4.ref();
-strictEqual(handle.hasRef(),
-true,'udp_wrap: ipv4: ref() ineffective');
+assert.strictEqual(handle.hasRef(),true);
 handle.close(common.mustCall(()=>
-strictEqual(handle.hasRef(),
-false,'udp_wrap: ipv4: not unrefed on close')));
+assert.strictEqual(handle.hasRef(),false)));
 }
 
 
@@ -51,85 +43,70 @@ const { kStateSymbol } = require('internal/dgram');
 constsock6=dgram.createSocket('udp6');
 consthandle=sock6[kStateSymbol].handle;
 
-strictEqual(handle.hasRef(),
-true,'udp_wrap: ipv6: not initially refed');
+assert.strictEqual(handle.hasRef(),true);
 sock6.unref();
-strictEqual(handle.hasRef(),
-false,'udp_wrap: ipv6: unref() ineffective');
+assert.strictEqual(handle.hasRef(),false);
 sock6.ref();
-strictEqual(handle.hasRef(),
-true,'udp_wrap: ipv6: ref() ineffective');
+assert.strictEqual(handle.hasRef(),true);
 handle.close(common.mustCall(()=>
-strictEqual(handle.hasRef(),
-false,'udp_wrap: ipv6: not unrefed on close')));
+assert.strictEqual(handle.hasRef(),false)));
 }
 
 
 // pipe
 {
 const{ Pipe,constants: PipeConstants}=internalBinding('pipe_wrap');
 consthandle=newPipe(PipeConstants.SOCKET);
-strictEqual(handle.hasRef(),
-true,'pipe_wrap: not initially refed');
+assert.strictEqual(handle.hasRef(),true);
 handle.unref();
-strictEqual(handle.hasRef(),
-false,'pipe_wrap: unref() ineffective');
+assert.strictEqual(handle.hasRef(),false);
 handle.ref();
-strictEqual(handle.hasRef(),
-true,'pipe_wrap: ref() ineffective');
+assert.strictEqual(handle.hasRef(),true);
 handle.close(common.mustCall(()=>
-strictEqual(handle.hasRef(),
-false,'pipe_wrap: not unrefed on close')));
+assert.strictEqual(handle.hasRef(),false)));
 }
 
 
 // tcp
 {
 constnet=require('net');
 constserver=net.createServer(()=>{}).listen(0);
-strictEqual(server._handle.hasRef(),
-true,'tcp_wrap: not initially refed');
-strictEqual(server._unref,
-false,'tcp_wrap: _unref initially incorrect');
+assert.strictEqual(server._handle.hasRef(),true);
+assert.strictEqual(server._unref,false);
 server.unref();
-strictEqual(server._handle.hasRef(),
-false,'tcp_wrap: unref() ineffective');
-strictEqual(server._unref,
-true,'tcp_wrap: _unref not updated on unref()');
+assert.strictEqual(server._handle.hasRef(),false);
+assert.strictEqual(server._unref,true);
 server.ref();
-strictEqual(server._handle.hasRef(),
-true,'tcp_wrap: ref() ineffective');
-strictEqual(server._unref,
-false,'tcp_wrap: _unref not updated on ref()');
+assert.strictEqual(server._handle.hasRef(),true);
+assert.strictEqual(server._unref,false);
 server._handle.close(common.mustCall(()=>
-strictEqual(server._handle.hasRef(),
-false,'tcp_wrap: not unrefed on close')));
+assert.strictEqual(server._handle.hasRef(),false)));
 }
 
 // timers
 {
-strictEqual(process.getActiveResourcesInfo().filter(
+assert.strictEqual(process.getActiveResourcesInfo().filter(
 (type)=>type==='Timeout').length,0);
 consttimeout=setTimeout(()=>{},500);
-strictEqual(process.getActiveResourcesInfo().filter(
+assert.strictEqual(process.getActiveResourcesInfo().filter(
 (type)=>type==='Timeout').length,1);
 timeout.unref();
-strictEqual(process.getActiveResourcesInfo().filter(
+assert.strictEqual(process.getActiveResourcesInfo().filter(
 (type)=>type==='Timeout').length,0);
 timeout.ref();
-strictEqual(process.getActiveResourcesInfo().filter(
+assert.strictEqual(process.getActiveResourcesInfo().filter(
 (type)=>type==='Timeout').length,1);
 
-strictEqual(process.getActiveResourcesInfo().filter(
+assert.strictEqual(process.getActiveResourcesInfo().filter(
 (type)=>type==='Immediate').length,0);
 constimmediate=setImmediate(()=>{});
-strictEqual(process.getActiveResourcesInfo().filter(
+assert.strictEqual(process.getActiveResourcesInfo().filter(
 (type)=>type==='Immediate').length,1);
 immediate.unref();
-strictEqual(process.getActiveResourcesInfo().filter(
+assert.strictEqual(process.getActiveResourcesInfo().filter(
 (type)=>type==='Immediate').length,0);
 immediate.ref();
-strictEqual(process.getActiveResourcesInfo().filter(
+assert.strictEqual(process.getActiveResourcesInfo().filter(
 (type)=>type==='Immediate').length,1);
 }
 

test/parallel/test-heapdump-async-hooks-init-promise.js

@@ -31,10 +31,10 @@ async_hooks.createHook({
 if(promiseIds.includes(id))createSnapshot();
 },
 
-promiseResolve(id){
+promiseResolve: common.mustCallAtLeast((id)=>{
 assert(promiseIds.includes(id));
 createSnapshot();
-},
+}),
 
 destroy(id){
 if(promiseIds.includes(id))createSnapshot();

test/parallel/test-http.js

@@ -61,7 +61,7 @@ const server = http.Server(common.mustCall((req, res) => {
 },3));
 server.listen(0);
 
-server.on('listening',()=>{
+server.on('listening',common.mustCall(()=>{
 constagent=newhttp.Agent({port: server.address().port,maxSockets: 1});
 constreq=http.get({
 port: server.address().port,
@@ -133,4 +133,4 @@ server.on('listening', () => {
 }));
 req.end();
 }),2);
-});
+}));

test/parallel/test-https-agent-create-connection.js

@@ -19,7 +19,7 @@ const expectedHeader = /^HTTP\/1\.1 200 OK/;
 constexpectedBody=/helloworld\n/;
 constexpectCertError=/^UNABLE_TO_VERIFY_LEAF_SIGNATURE$/;
 
-constcheckRequest=(socket,server)=>{
+functioncheckRequest(socket,server){
 letresult='';
 socket.on('connect',common.mustCall((data)=>{
 socket.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n');

test/parallel/test-https-agent-keylog.js

@@ -36,9 +36,9 @@ const server = https.createServer({
 });
 });
 
-constverifyKeylog=(line,tlsSocket)=>{
+constverifyKeylog=common.mustCallAtLeast((line,tlsSocket)=>{
 assert(Buffer.isBuffer(line));
 assert.strictEqual(tlsSocket.encrypted,true);
-};
+});
 server.on('keylog',common.mustCall(verifyKeylog,10));
 https.globalAgent.on('keylog',common.mustCall(verifyKeylog,10));

test/parallel/test-https-agent-servername.js

@@ -21,19 +21,16 @@ const server = https.Server(options, (req, res) => {
 });
 
 
-server.listen(0,function(){
+server.listen(0,common.mustCall(function(){
 https.get({
 path: '/',
 port: this.address().port,
 rejectUnauthorized: true,
 servername: 'agent1',
 ca: options.ca
-},(res)=>{
+},common.mustCall((res)=>{
 res.resume();
 assert.strictEqual(res.statusCode,200);
 server.close();
-}).on('error',(e)=>{
-console.log(e.message);
-process.exit(1);
-});
-});
+})).on('error',common.mustNotCall());
+}));

test/parallel/test-https-agent-sni.js

@@ -27,7 +27,7 @@ const server = https.Server(options, function(req, res) {
 res.end('hello world');
 });
 
-server.listen(0,function(){
+server.listen(0,common.mustCall(function(){
 functionexpectResponse(id){
 returncommon.mustCall(function(res){
 res.resume();
@@ -59,4 +59,4 @@ server.listen(0, function() {
 servername: '',
 rejectUnauthorized: false
 },expectResponse(false));
-});
+}));

test/parallel/test-https-agent-unref-socket.js

@@ -17,13 +17,13 @@ if (process.argv[2] === 'localhost') {
 constnet=require('net');
 constserver=net.createServer();
 server.listen(0);
-server.on('listening',()=>{
+server.on('listening',common.mustCall(()=>{
 constport=server.address().port;
 const{ fork }=require('child_process');
 constchild=fork(__filename,['localhost',port],{});
-child.on('close',(exit_code)=>{
+child.on('close',common.mustCall((exit_code)=>{
 server.close();
 assert.strictEqual(exit_code,0);
-});
-});
+}));
+}));
 }