test: ensure assertions are reached on more tests

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

Author: aduh95

test/eslint.config_partial.mjs

@@ -205,7 +205,7 @@ export default [
 Array.from({length: 13},(_,i)=>String.fromCharCode(0x61+i,42)).join(',')
 },n*,${
 // 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(',')
+Array.from({length: 8},(_,i)=>String.fromCharCode(0x61+25-i,42)).join(',')
 }}.{js,mjs,cjs}`,
 ],
 rules: {

test/parallel/test-socket-writes-before-passed-to-tls-socket.js

@@ -7,7 +7,7 @@ const net = require('net');
 
 constHEAD=Buffer.alloc(1024*1024,0);
 
-constserver=net.createServer((serverSock)=>{
+constserver=net.createServer(common.mustCallAtLeast((serverSock)=>{
 letrecvLen=0;
 constrecv=[];
 serverSock.on('data',common.mustCallAtLeast((chunk)=>{
@@ -21,7 +21,7 @@ const server = net.createServer((serverSock) => {
 process.exit(0);
 }
 },1));
-})
+}))
 .listen(client);
 
 functionclient(){

test/parallel/test-socketaddress.js

@@ -2,11 +2,7 @@
 'use strict';
 
 constcommon=require('../common');
-const{
- ok,
- strictEqual,
- throws,
-}=require('assert');
+constassert=require('assert');
 const{
  SocketAddress,
 }=require('net');
@@ -26,19 +22,19 @@ describe('net.SocketAddress...', () => {
 
 it('is cloneable',()=>{
 constsa=newSocketAddress();
-strictEqual(sa.address,'127.0.0.1');
-strictEqual(sa.port,0);
-strictEqual(sa.family,'ipv4');
-strictEqual(sa.flowlabel,0);
+assert.strictEqual(sa.address,'127.0.0.1');
+assert.strictEqual(sa.port,0);
+assert.strictEqual(sa.family,'ipv4');
+assert.strictEqual(sa.flowlabel,0);
 
 constmc=newMessageChannel();
 mc.port1.onmessage=common.mustCall(({ data })=>{
-ok(SocketAddress.isSocketAddress(data));
+assert.ok(SocketAddress.isSocketAddress(data));
 
-strictEqual(data.address,'127.0.0.1');
-strictEqual(data.port,0);
-strictEqual(data.family,'ipv4');
-strictEqual(data.flowlabel,0);
+assert.strictEqual(data.address,'127.0.0.1');
+assert.strictEqual(data.port,0);
+assert.strictEqual(data.family,'ipv4');
+assert.strictEqual(data.flowlabel,0);
 
 mc.port1.close();
 });
@@ -47,80 +43,80 @@ describe('net.SocketAddress...', () => {
 
 it('has reasonable defaults',()=>{
 constsa=newSocketAddress({});
-strictEqual(sa.address,'127.0.0.1');
-strictEqual(sa.port,0);
-strictEqual(sa.family,'ipv4');
-strictEqual(sa.flowlabel,0);
+assert.strictEqual(sa.address,'127.0.0.1');
+assert.strictEqual(sa.port,0);
+assert.strictEqual(sa.family,'ipv4');
+assert.strictEqual(sa.flowlabel,0);
 });
 
 it('interprets simple ipv4 correctly',()=>{
 constsa=newSocketAddress({
 address: '123.123.123.123',
 });
-strictEqual(sa.address,'123.123.123.123');
-strictEqual(sa.port,0);
-strictEqual(sa.family,'ipv4');
-strictEqual(sa.flowlabel,0);
+assert.strictEqual(sa.address,'123.123.123.123');
+assert.strictEqual(sa.port,0);
+assert.strictEqual(sa.family,'ipv4');
+assert.strictEqual(sa.flowlabel,0);
 });
 
 it('sets the port correctly',()=>{
 constsa=newSocketAddress({
 address: '123.123.123.123',
 port: 80
 });
-strictEqual(sa.address,'123.123.123.123');
-strictEqual(sa.port,80);
-strictEqual(sa.family,'ipv4');
-strictEqual(sa.flowlabel,0);
+assert.strictEqual(sa.address,'123.123.123.123');
+assert.strictEqual(sa.port,80);
+assert.strictEqual(sa.family,'ipv4');
+assert.strictEqual(sa.flowlabel,0);
 });
 
 it('interprets simple ipv6 correctly',()=>{
 constsa=newSocketAddress({
 family: 'ipv6'
 });
-strictEqual(sa.address,'::');
-strictEqual(sa.port,0);
-strictEqual(sa.family,'ipv6');
-strictEqual(sa.flowlabel,0);
+assert.strictEqual(sa.address,'::');
+assert.strictEqual(sa.port,0);
+assert.strictEqual(sa.family,'ipv6');
+assert.strictEqual(sa.flowlabel,0);
 });
 
 it('uses the flowlabel correctly',()=>{
 constsa=newSocketAddress({
 family: 'ipv6',
 flowlabel: 1,
 });
-strictEqual(sa.address,'::');
-strictEqual(sa.port,0);
-strictEqual(sa.family,'ipv6');
-strictEqual(sa.flowlabel,1);
+assert.strictEqual(sa.address,'::');
+assert.strictEqual(sa.port,0);
+assert.strictEqual(sa.family,'ipv6');
+assert.strictEqual(sa.flowlabel,1);
 });
 
 it('validates input correctly',()=>{
 [1,false,'hello'].forEach((i)=>{
-throws(()=>newSocketAddress(i),{
+assert.throws(()=>newSocketAddress(i),{
 code: 'ERR_INVALID_ARG_TYPE'
 });
 });
 
 [1,false,{},[],'test'].forEach((family)=>{
-throws(()=>newSocketAddress({ family }),{
+assert.throws(()=>newSocketAddress({ family }),{
 code: 'ERR_INVALID_ARG_VALUE'
 });
 });
 
 [1,false,{},[]].forEach((address)=>{
-throws(()=>newSocketAddress({ address }),{
+assert.throws(()=>newSocketAddress({ address }),{
 code: 'ERR_INVALID_ARG_TYPE'
 });
 });
 
 [-1,false,{},[]].forEach((port)=>{
-throws(()=>newSocketAddress({ port }),{
+assert.throws(()=>newSocketAddress({ port }),{
 code: 'ERR_SOCKET_BAD_PORT'
 });
 });
 
-throws(()=>newSocketAddress({flowlabel: -1}),{
+assert.throws(()=>newSocketAddress({flowlabel: -1}),{
 code: 'ERR_OUT_OF_RANGE'
 });
 });
@@ -135,11 +131,11 @@ describe('net.SocketAddress...', () => {
 constflowlabel=0;
 consthandle=new_SocketAddress(address,port,AF_INET,flowlabel);
 constaddr=newInternalSocketAddress(handle);
-ok(addrinstanceofSocketAddress);
-strictEqual(addr.address,address);
-strictEqual(addr.port,port);
-strictEqual(addr.family,'ipv4');
-strictEqual(addr.flowlabel,flowlabel);
+assert.ok(addrinstanceofSocketAddress);
+assert.strictEqual(addr.address,address);
+assert.strictEqual(addr.port,port);
+assert.strictEqual(addr.family,'ipv4');
+assert.strictEqual(addr.flowlabel,flowlabel);
 });
 
 it('SocketAddress.parse() works as expected',()=>{
@@ -156,9 +152,9 @@ describe('net.SocketAddress...', () => {
 
 good.forEach((i)=>{
 constaddr=SocketAddress.parse(i.input);
-strictEqual(addr.address,i.address);
-strictEqual(addr.port,i.port);
-strictEqual(addr.family,i.family);
+assert.strictEqual(addr.address,i.address);
+assert.strictEqual(addr.port,i.port);
+assert.strictEqual(addr.family,i.family);
 });
 
 constbad=[
@@ -169,7 +165,7 @@ describe('net.SocketAddress...', () => {
 ];
 
 bad.forEach((i)=>{
-strictEqual(SocketAddress.parse(i),undefined);
+assert.strictEqual(SocketAddress.parse(i),undefined);
 });
 });
 

test/parallel/test-spawn-cmd-named-pipe.js

@@ -16,22 +16,22 @@ if (!process.argv[2]) {
 conststdinPipeName=`\\\\.\\pipe\\${pipeNamePrefix}.stdin`;
 conststdoutPipeName=`\\\\.\\pipe\\${pipeNamePrefix}.stdout`;
 
-conststdinPipeServer=net.createServer(function(c){
+conststdinPipeServer=net.createServer(common.mustCall((c)=>{
 c.on('end',common.mustCall());
 c.end('hello');
-});
+}));
 stdinPipeServer.listen(stdinPipeName);
 
 constoutput=[];
 
-conststdoutPipeServer=net.createServer(function(c){
+conststdoutPipeServer=net.createServer(common.mustCallAtLeast((c)=>{
 c.on('data',function(x){
 output.push(x);
 });
 c.on('end',common.mustCall(function(){
 assert.strictEqual(output.join(''),'hello');
 }));
-});
+}));
 stdoutPipeServer.listen(stdoutPipeName);
 
 constargs=

test/parallel/test-sqlite-custom-functions.js

@@ -1,5 +1,5 @@
 'use strict';
-const{ skipIfSQLiteMissing }=require('../common');
+const{ skipIfSQLiteMissing, mustCall}=require('../common');
 skipIfSQLiteMissing();
 constassert=require('node:assert');
 const{ DatabaseSync }=require('node:sqlite');
@@ -376,14 +376,14 @@ suite('DatabaseSync.prototype.function()', () => {
 
 test('supported argument types',()=>{
 constdb=newDatabaseSync(':memory:');
-db.function('arguments',(i,f,s,n,b)=>{
+db.function('arguments',mustCall((i,f,s,n,b)=>{
 assert.strictEqual(i,5);
 assert.strictEqual(f,3.14);
 assert.strictEqual(s,'foo');
 assert.strictEqual(n,null);
 assert.deepStrictEqual(b,newUint8Array([254]));
 return42;
-});
+}));
 conststmt=db.prepare(
 'SELECT arguments(5, 3.14, \'foo\', null, x\'fe\') as result'
 );

test/parallel/test-stdin-pipe-resume.js

@@ -1,6 +1,6 @@
 'use strict';
 // This tests that piping stdin will cause it to resume() as well.
-require('../common');
+constcommon=require('../common');
 constassert=require('assert');
 
 if(process.argv[2]==='child'){
@@ -12,11 +12,11 @@ if (process.argv[2] === 'child') {
 child.stdout.on('data',function(c){
 buffers.push(c);
 });
-child.stdout.on('close',function(){
+child.stdout.on('close',common.mustCall(()=>{
 constb=Buffer.concat(buffers).toString();
 assert.strictEqual(b,'Hello, world\n');
 console.log('ok');
-});
+}));
 child.stdin.write('Hel');
 child.stdin.write('lo,');
 child.stdin.write(' wo');

test/parallel/test-stdio-pipe-stderr.js

@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+constcommon=require('../common');
 consttmpdir=require('../common/tmpdir');
 constassert=require('assert');
 constfs=require('fs');
@@ -19,7 +19,7 @@ const stream = fs.createWriteStream(stderrOutputPath);
 // non-built-in module.
 fs.writeFileSync(fakeModulePath,'','utf8');
 
-stream.on('open',()=>{
+stream.on('open',common.mustCall(()=>{
 spawnSync(process.execPath,{
 input: `require(${JSON.stringify(fakeModulePath)})`,
 stdio: ['pipe','pipe',stream]
@@ -33,4 +33,4 @@ stream.on('open', () => {
 stream.end();
 fs.unlinkSync(stderrOutputPath);
 fs.unlinkSync(fakeModulePath);
-});
+}));

test/parallel/test-stdout-cannot-be-closed-child-process-pipe.js

@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+constcommon=require('../common');
 constassert=require('assert');
 
 if(process.argv[2]==='child')
@@ -23,10 +23,10 @@ function parent() {
 err+=c;
 });
 
-child.on('close',function(code,signal){
+child.on('close',common.mustCall((code,signal)=>{
 assert.strictEqual(code,0);
 assert.strictEqual(err,'');
 assert.strictEqual(out,'foo');
 console.log('ok');
-});
+}));
 }

test/parallel/test-strace-openat-openssl.js

@@ -32,7 +32,7 @@ if (spawnSync('strace').error !== undefined) {
 
 // stderr is the default for strace
 constrl=createInterface({input: strace.stderr});
-rl.on('line',(line)=>{
+rl.on('line',common.mustCallAtLeast((line)=>{
 if(!line.startsWith('open')){
 return;
 }
@@ -48,7 +48,7 @@ if (spawnSync('strace').error !== undefined) {
 }
 
 assert(allowedOpenCalls.delete(file),`${file} is not in the list of allowed openat calls`);
-});
+}));
 constdebugOutput=[];
 strace.stderr.setEncoding('utf8');
 strace.stderr.on('data',(chunk)=>{

test/parallel/test-stream-big-push.js

@@ -61,7 +61,7 @@ assert.strictEqual(chunk, str);
 chunk=r.read();
 assert.strictEqual(chunk,null);
 
-r.once('readable',()=>{
+r.once('readable',common.mustCall(()=>{
 // This time, we'll get *all* the remaining data, because
 // it's been added synchronously, as the read WOULD take
 // us below the hwm, and so it triggered a _read() again,
@@ -71,4 +71,4 @@ r.once('readable', () => {
 
 chunk=r.read();
 assert.strictEqual(chunk,null);
-});
+}));