test: ensure assertions are reached on more tests

PR-URL: #60485 Reviewed-By: Colin Ihrig <[email protected]>

Author: aduh95

test/eslint.config_partial.mjs

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

test/parallel/test-abortcontroller-internal.js

@@ -2,9 +2,7 @@
 'use strict';
 require('../common');
 
-const{
- strictEqual,
-}=require('assert');
+constassert=require('assert');
 
 const{
  test,
@@ -30,5 +28,5 @@ test('A weak event listener should not prevent gc', async () =>{
 
 awaitsleep(10);
 globalThis.gc();
-strictEqual(ref.deref(),undefined);
+assert.strictEqual(ref.deref(),undefined);
 });

test/parallel/test-abortcontroller.js

@@ -1,15 +1,10 @@
 // Flags: --expose-gc
 'use strict';
 
-require('../common');
+constcommon=require('../common');
 const{ inspect }=require('util');
 
-const{
- ok,
- notStrictEqual,
- strictEqual,
- throws,
-}=require('assert');
+constassert=require('assert');
 
 const{
  test,
@@ -25,34 +20,34 @@ const{setTimeout: sleep } = require('timers/promises');
 test('Abort is fired with the correct event type on AbortControllers',()=>{
 // Tests that abort is fired with the correct event type on AbortControllers
 constac=newAbortController();
-ok(ac.signal);
+assert.ok(ac.signal);
 
-constfn=mock.fn((event)=>{
-ok(event);
-strictEqual(event.type,'abort');
-});
+constfn=mock.fn(common.mustCall((event)=>{
+assert.ok(event);
+assert.strictEqual(event.type,'abort');
+},2));
 
 ac.signal.onabort=fn;
 ac.signal.addEventListener('abort',fn);
 
 ac.abort();
 ac.abort();
-ok(ac.signal.aborted);
+assert.ok(ac.signal.aborted);
 
-strictEqual(fn.mock.calls.length,2);
+assert.strictEqual(fn.mock.calls.length,2);
 });
 
 test('Abort events are trusted',()=>{
 // Tests that abort events are trusted
 constac=newAbortController();
 
-constfn=mock.fn((event)=>{
-ok(event.isTrusted);
-});
+constfn=mock.fn(common.mustCall((event)=>{
+assert.ok(event.isTrusted);
+}));
 
 ac.signal.onabort=fn;
 ac.abort();
-strictEqual(fn.mock.calls.length,1);
+assert.strictEqual(fn.mock.calls.length,1);
 });
 
 test('Abort events have the same isTrusted reference',()=>{
@@ -73,14 +68,14 @@ test('Abort events have the same isTrusted reference', () =>{
 constfirstTrusted=Reflect.getOwnPropertyDescriptor(Object.getPrototypeOf(ev1),'isTrusted').get;
 constsecondTrusted=Reflect.getOwnPropertyDescriptor(Object.getPrototypeOf(ev2),'isTrusted').get;
 constuntrusted=Reflect.getOwnPropertyDescriptor(Object.getPrototypeOf(ev3),'isTrusted').get;
-strictEqual(firstTrusted,secondTrusted);
-strictEqual(untrusted,firstTrusted);
+assert.strictEqual(firstTrusted,secondTrusted);
+assert.strictEqual(untrusted,firstTrusted);
 });
 
 test('AbortSignal is impossible to construct manually',()=>{
 // Tests that AbortSignal is impossible to construct manually
 constac=newAbortController();
-throws(()=>newac.signal.constructor(),{
+assert.throws(()=>newac.signal.constructor(),{
 code: 'ERR_ILLEGAL_CONSTRUCTOR',
 });
 });
@@ -89,13 +84,13 @@ test('Symbol.toStringTag is correct', () =>{
 // Symbol.toStringTag
 consttoString=(o)=>Object.prototype.toString.call(o);
 constac=newAbortController();
-strictEqual(toString(ac),'[object AbortController]');
-strictEqual(toString(ac.signal),'[object AbortSignal]');
+assert.strictEqual(toString(ac),'[object AbortController]');
+assert.strictEqual(toString(ac.signal),'[object AbortSignal]');
 });
 
 test('AbortSignal.abort() creates an already aborted signal',()=>{
 constsignal=AbortSignal.abort();
-ok(signal.aborted);
+assert.ok(signal.aborted);
 });
 
 test('AbortController properties and methods valiate the receiver',()=>{
@@ -106,7 +101,7 @@ test('AbortController properties and methods valiate the receiver', () =>{
 constacAbort=AbortController.prototype.abort;
 
 constgoodController=newAbortController();
-ok(acSignalGet.call(goodController));
+assert.ok(acSignalGet.call(goodController));
 acAbort.call(goodController);
 
 constbadAbortControllers=[
@@ -119,11 +114,11 @@ test('AbortController properties and methods valiate the receiver', () =>{
 {__proto__: AbortController.prototype},
 ];
 for(constbadControllerofbadAbortControllers){
-throws(
+assert.throws(
 ()=>acSignalGet.call(badController),
 {name: 'TypeError'}
 );
-throws(
+assert.throws(
 ()=>acAbort.call(badController),
 {name: 'TypeError'}
 );
@@ -137,7 +132,7 @@ test('AbortSignal properties validate the receiver', () =>{
 ).get;
 
 constgoodSignal=newAbortController().signal;
-strictEqual(signalAbortedGet.call(goodSignal),false);
+assert.strictEqual(signalAbortedGet.call(goodSignal),false);
 
 constbadAbortSignals=[
 null,
@@ -149,7 +144,7 @@ test('AbortSignal properties validate the receiver', () =>{
 {__proto__: AbortSignal.prototype},
 ];
 for(constbadSignalofbadAbortSignals){
-throws(
+assert.throws(
 ()=>signalAbortedGet.call(badSignal),
 {name: 'TypeError'}
 );
@@ -158,38 +153,38 @@ test('AbortSignal properties validate the receiver', () =>{
 
 test('AbortController inspection depth 1 or null works',()=>{
 constac=newAbortController();
-strictEqual(inspect(ac,{depth: 1}),
-'AbortController{signal: [AbortSignal] }');
-strictEqual(inspect(ac,{depth: null}),
-'AbortController{signal: AbortSignal{aborted: false } }');
+assert.strictEqual(inspect(ac,{depth: 1}),
+'AbortController{signal: [AbortSignal] }');
+assert.strictEqual(inspect(ac,{depth: null}),
+'AbortController{signal: AbortSignal{aborted: false } }');
 });
 
 test('AbortSignal reason is set correctly',()=>{
 // Test AbortSignal.reason
 constac=newAbortController();
 ac.abort('reason');
-strictEqual(ac.signal.reason,'reason');
+assert.strictEqual(ac.signal.reason,'reason');
 });
 
 test('AbortSignal reasonable is set correctly with AbortSignal.abort()',()=>{
 // Test AbortSignal.reason
 constsignal=AbortSignal.abort('reason');
-strictEqual(signal.reason,'reason');
+assert.strictEqual(signal.reason,'reason');
 });
 
 test('AbortSignal.timeout() works as expected',async()=>{
 // Test AbortSignal timeout
 constsignal=AbortSignal.timeout(10);
-ok(!signal.aborted);
+assert.ok(!signal.aborted);
 
 const{ promise, resolve }=Promise.withResolvers();
 
-constfn=mock.fn(()=>{
-ok(signal.aborted);
-strictEqual(signal.reason.name,'TimeoutError');
-strictEqual(signal.reason.code,23);
+constfn=mock.fn(common.mustCall(()=>{
+assert.ok(signal.aborted);
+assert.strictEqual(signal.reason.name,'TimeoutError');
+assert.strictEqual(signal.reason.code,23);
 resolve();
-});
+}));
 
 setTimeout(fn,20);
 awaitpromise;
@@ -205,7 +200,7 @@ test('AbortSignal.timeout() does not prevent the signal from being collected', a
 
 awaitsleep(10);
 globalThis.gc();
-strictEqual(ref.deref(),undefined);
+assert.strictEqual(ref.deref(),undefined);
 });
 
 test('AbortSignal with a timeout is not collected while there is an active listener',async()=>{
@@ -220,14 +215,14 @@ test('AbortSignal with a timeout is not collected while there is an active liste
 
 awaitsleep(10);
 globalThis.gc();
-notStrictEqual(ref.deref(),undefined);
-ok(ref.deref()instanceofAbortSignal);
+assert.notStrictEqual(ref.deref(),undefined);
+assert.ok(ref.deref()instanceofAbortSignal);
 
 ref.deref().removeEventListener('abort',handler);
 
 awaitsleep(10);
 globalThis.gc();
-strictEqual(ref.deref(),undefined);
+assert.strictEqual(ref.deref(),undefined);
 });
 
 test('Setting a long timeout should not keep the process open',()=>{
@@ -237,18 +232,18 @@ test('Setting a long timeout should not keep the process open', () =>{
 test('AbortSignal.reason should default',()=>{
 // Test AbortSignal.reason default
 constsignal=AbortSignal.abort();
-ok(signal.reasoninstanceofDOMException);
-strictEqual(signal.reason.code,20);
+assert.ok(signal.reasoninstanceofDOMException);
+assert.strictEqual(signal.reason.code,20);
 
 constac=newAbortController();
 ac.abort();
-ok(ac.signal.reasoninstanceofDOMException);
-strictEqual(ac.signal.reason.code,20);
+assert.ok(ac.signal.reasoninstanceofDOMException);
+assert.strictEqual(ac.signal.reason.code,20);
 });
 
 test('abortSignal.throwIfAborted() works as expected',()=>{
 // Test abortSignal.throwIfAborted()
-throws(()=>AbortSignal.abort().throwIfAborted(),{
+assert.throws(()=>AbortSignal.abort().throwIfAborted(),{
 code: 20,
 name: 'AbortError',
 });
@@ -262,7 +257,7 @@ test('abortSignal.throwIfAobrted() works as expected (2)', () =>{
 constoriginalDesc=Reflect.getOwnPropertyDescriptor(AbortSignal.prototype,'aborted');
 constactualReason=newError();
 Reflect.defineProperty(AbortSignal.prototype,'aborted',{value: false});
-throws(()=>AbortSignal.abort(actualReason).throwIfAborted(),actualReason);
+assert.throws(()=>AbortSignal.abort(actualReason).throwIfAborted(),actualReason);
 Reflect.defineProperty(AbortSignal.prototype,'aborted',originalDesc);
 });
 
@@ -271,6 +266,6 @@ test('abortSignal.throwIfAobrted() works as expected (3)', () =>{
 constactualReason=newError();
 constfakeExcuse=newError();
 Reflect.defineProperty(AbortSignal.prototype,'reason',{value: fakeExcuse});
-throws(()=>AbortSignal.abort(actualReason).throwIfAborted(),actualReason);
+assert.throws(()=>AbortSignal.abort(actualReason).throwIfAborted(),actualReason);
 Reflect.defineProperty(AbortSignal.prototype,'reason',originalDesc);
 });

test/parallel/test-aborted-util.js

@@ -1,13 +1,9 @@
 // Flags: --expose-gc
 'use strict';
 
-require('../common');
+constcommon=require('../common');
 const{ aborted }=require('util');
-const{
- match,
- rejects,
- strictEqual,
-}=require('assert');
+constassert=require('assert');
 const{ getEventListeners }=require('events');
 const{ inspect }=require('util');
 
@@ -20,8 +16,8 @@ test('Aborted works when provided a resource', async () =>{
 constpromise=aborted(ac.signal,{});
 ac.abort();
 awaitpromise;
-strictEqual(ac.signal.aborted,true);
-strictEqual(getEventListeners(ac.signal,'abort').length,0);
+assert.strictEqual(ac.signal.aborted,true);
+assert.strictEqual(getEventListeners(ac.signal,'abort').length,0);
 });
 
 test('Aborted with gc cleanup',async()=>{
@@ -31,23 +27,23 @@ test('Aborted with gc cleanup', async () =>{
 constabortedPromise=aborted(ac.signal,{});
 const{ promise, resolve }=Promise.withResolvers();
 
-setImmediate(()=>{
+setImmediate(common.mustCall(()=>{
 globalThis.gc();
 ac.abort();
-strictEqual(ac.signal.aborted,true);
-strictEqual(getEventListeners(ac.signal,'abort').length,0);
+assert.strictEqual(ac.signal.aborted,true);
+assert.strictEqual(getEventListeners(ac.signal,'abort').length,0);
 resolve();
-});
+}));
 
 awaitpromise;
 
 // Ensure that the promise is still pending
-match(inspect(abortedPromise),/<pending>/);
+assert.match(inspect(abortedPromise),/<pending>/);
 });
 
 test('Fails with error if not provided AbortSignal',async()=>{
 awaitPromise.all([{},null,undefined,Symbol(),[],1,0,1n,true,false,'a',()=>{}].map((sig)=>
-rejects(aborted(sig,{}),{
+assert.rejects(aborted(sig,{}),{
 code: 'ERR_INVALID_ARG_TYPE',
 })
 ));
@@ -57,7 +53,7 @@ test('Fails if not provided a resource', async () =>{
 // Fails if not provided a resource
 constac=newAbortController();
 awaitPromise.all([null,undefined,0,1,0n,1n,Symbol(),'','a'].map((resource)=>
-rejects(aborted(ac.signal,resource),{
+assert.rejects(aborted(ac.signal,resource),{
 code: 'ERR_INVALID_ARG_TYPE',
 })
 ));
@@ -82,10 +78,10 @@ function lazySpawn(){
 test('Does not hang forever',{skip: !lazySpawn()},async()=>{
 const{ promise, resolve }=Promise.withResolvers();
 constchildProcess=spawn(process.execPath,['--input-type=module']);
-childProcess.on('exit',(code)=>{
-strictEqual(code,13);
+childProcess.on('exit',common.mustCall((code)=>{
+assert.strictEqual(code,13);
 resolve();
-});
+}));
 childProcess.stdin.end(`
  import{aborted } from 'node:util'
  await aborted(new AbortController().signal,{});