test: improve multiple timers tests

PR-URL: #14616
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Refael Ackermann <refack@gmail.com>

Author: jasnell

test/parallel/test-timers-immediate.js

@@ -2,32 +2,23 @@
 constcommon=require('../common');
 constassert=require('assert');
 
-letimmediateB;
-letimmediateC;
-letimmediateD;
-
 letmainFinished=false;
 
 setImmediate(common.mustCall(function(){
 assert.strictEqual(mainFinished,true);
 clearImmediate(immediateB);
 }));
 
-immediateB=setImmediate(function(){
+letimmediateB=setImmediate(function(){
 common.fail('this immediate should not run');
 });
 
-setImmediate(function(x,y,z){
-immediateC=[x,y,z];
-},1,2,3);
-
-setImmediate(function(x,y,z,a,b){
-immediateD=[x,y,z,a,b];
-},1,2,3,4,5);
+setImmediate(common.mustCall((...args)=>{
+assert.deepStrictEqual(args,[1,2,3]);
+}),1,2,3);
 
-process.on('exit',function(){
-assert.deepStrictEqual(immediateC,[1,2,3],'immediateC args should match');
-assert.deepStrictEqual(immediateD,[1,2,3,4,5],'5 args should match');
-});
+setImmediate(common.mustCall((...args)=>{
+assert.deepStrictEqual(args,[1,2,3,4,5]);
+}),1,2,3,4,5);
 
 mainFinished=true;

test/parallel/test-timers-non-integer-delay.js

@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+constcommon=require('../common');
 
 /*
  * This test makes sure that non-integer timer delays do not make the process
@@ -18,13 +18,11 @@ require('../common');
  */
 
 constTIMEOUT_DELAY=1.1;
-constNB_TIMEOUTS_FIRED=50;
+letN=50;
 
-letnbTimeoutFired=0;
-constinterval=setInterval(function(){
-++nbTimeoutFired;
-if(nbTimeoutFired===NB_TIMEOUTS_FIRED){
+constinterval=setInterval(common.mustCall(()=>{
+if(--N===0){
 clearInterval(interval);
 process.exit(0);
 }
-},TIMEOUT_DELAY);
+},N),TIMEOUT_DELAY);

test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js

@@ -6,6 +6,7 @@
 
 constcommon=require('../common');
 constnet=require('net');
+constCountdown=require('../common/countdown');
 
 constclients=[];
 
@@ -19,7 +20,7 @@ const server = net.createServer(function onClient(client) {
  * the list of unref timers when traversing it, and exposes the
  * original issue in joyent/node#8897.
  */
-clients[0].setTimeout(1,functiononTimeout(){
+clients[0].setTimeout(1,()=>{
 clients[1].setTimeout(0);
 clients[0].end();
 clients[1].end();
@@ -31,19 +32,16 @@ const server = net.createServer(function onClient(client) {
 }
 });
 
-server.listen(0,common.localhostIPv4,function(){
-letnbClientsEnded=0;
+server.listen(0,common.localhostIPv4,common.mustCall(()=>{
+constcountdown=newCountdown(2,common.mustCall(()=>server.close()));
 
-functionaddEndedClient(client){
-++nbClientsEnded;
-if(nbClientsEnded===2){
-server.close();
-}
+{
+constclient=net.connect({port: server.address().port});
+client.on('end',()=>countdown.dec());
 }
 
-constclient1=net.connect({port: this.address().port});
-client1.on('end',addEndedClient);
-
-constclient2=net.connect({port: this.address().port});
-client2.on('end',addEndedClient);
-});
+{
+constclient=net.connect({port: server.address().port});
+client.on('end',()=>countdown.dec());
+}
+}));

test/parallel/test-timers-unref-leak.js

@@ -1,27 +1,14 @@
 'use strict';
-require('../common');
-constassert=require('assert');
+constcommon=require('../common');
 
-letcalled=0;
-letclosed=0;
-
-consttimeout=setTimeout(function(){
-called++;
-},10);
+consttimeout=setTimeout(common.mustCall(),10);
 timeout.unref();
 
 // Wrap `close` method to check if the handle was closed
 constclose=timeout._handle.close;
-timeout._handle.close=function(){
-closed++;
+timeout._handle.close=common.mustCall(function(){
 returnclose.apply(this,arguments);
-};
+});
 
 // Just to keep process alive and let previous timer's handle die
-setTimeout(function(){
-},50);
-
-process.on('exit',function(){
-assert.strictEqual(called,1);
-assert.strictEqual(closed,1);
-});
+setTimeout(()=>{},50);

test/parallel/test-timers-unref.js

@@ -1,76 +1,58 @@
 'use strict';
 
-require('../common');
+constcommon=require('../common');
 constassert=require('assert');
 
-letinterval_fired=false;
-lettimeout_fired=false;
 letunref_interval=false;
 letunref_timer=false;
-letunref_callbacks=0;
 letchecks=0;
 
 constLONG_TIME=10*1000;
 constSHORT_TIME=100;
 
-assert.doesNotThrow(function(){
+assert.doesNotThrow(()=>{
 setTimeout(()=>{},10).unref().ref().unref();
 },'ref and unref are chainable');
 
-assert.doesNotThrow(function(){
+assert.doesNotThrow(()=>{
 setInterval(()=>{},10).unref().ref().unref();
 },'ref and unref are chainable');
 
-setInterval(function(){
-interval_fired=true;
-},LONG_TIME).unref();
+setInterval(common.mustNotCall('Interval should not fire'),LONG_TIME).unref();
+setTimeout(common.mustNotCall('Timer should not fire'),LONG_TIME).unref();
 
-setTimeout(function(){
-timeout_fired=true;
-},LONG_TIME).unref();
-
-constinterval=setInterval(function(){
+constinterval=setInterval(common.mustCall(()=>{
 unref_interval=true;
 clearInterval(interval);
-},SHORT_TIME);
+}),SHORT_TIME);
 interval.unref();
 
-setTimeout(function(){
+setTimeout(common.mustCall(()=>{
 unref_timer=true;
-},SHORT_TIME).unref();
+}),SHORT_TIME).unref();
 
-constcheck_unref=setInterval(function(){
+constcheck_unref=setInterval(()=>{
 if(checks>5||(unref_interval&&unref_timer))
 clearInterval(check_unref);
 checks+=1;
 },100);
 
-setTimeout(function(){
-unref_callbacks++;
-this.unref();
-},SHORT_TIME);
+{
+consttimeout=
+setTimeout(common.mustCall(()=>{
+timeout.unref();
+}),SHORT_TIME);
+}
 
-// Should not timeout the test
-setInterval(function(){
-this.unref();
-},SHORT_TIME);
+{
+// Should not timeout the test
+consttimeout=
+setInterval(()=>timeout.unref(),SHORT_TIME);
+}
 
 // Should not assert on args.Holder()->InternalFieldCount() > 0. See #4261.
 {
 constt=setInterval(()=>{},1);
 process.nextTick(t.unref.bind({}));
 process.nextTick(t.unref.bind(t));
 }
-
-process.on('exit',function(){
-assert.strictEqual(interval_fired,false,
-'Interval should not fire');
-assert.strictEqual(timeout_fired,false,
-'Timeout should not fire');
-assert.strictEqual(unref_timer,true,
-'An unrefd timeout should still fire');
-assert.strictEqual(unref_interval,true,
-'An unrefd interval should still fire');
-assert.strictEqual(unref_callbacks,1,
-'Callback should only run once');
-});

test/parallel/test-timers-unrefd-interval-still-fires.js

@@ -5,23 +5,20 @@
 constcommon=require('../common');
 
 constTEST_DURATION=common.platformTimeout(1000);
-constN=3;
-letnbIntervalFired=0;
+letN=3;
 
-constkeepOpen=setTimeout(()=>{
-console.error('[FAIL] Interval fired %d/%d times.',nbIntervalFired,N);
-thrownewError('Test timed out. keepOpen was not canceled.');
-},TEST_DURATION);
+constkeepOpen=
+setTimeout(
+common.mustNotCall('Test timed out. keepOpen was not canceled.'),
+TEST_DURATION);
 
-consttimer=setInterval(()=>{
-++nbIntervalFired;
-if(nbIntervalFired===N){
+consttimer=setInterval(common.mustCall(()=>{
+if(--N===0){
 clearInterval(timer);
-timer._onTimeout=()=>{
-thrownewError('Unrefd interval fired after being cleared.');
-};
+timer._onTimeout=
+common.mustNotCall('Unrefd interal fired after being cleared');
 clearTimeout(keepOpen);
 }
-},1);
+},N),1);
 
 timer.unref();

test/parallel/test-timers-unrefed-in-beforeexit.js

@@ -1,20 +1,7 @@
 'use strict';
 
-require('../common');
-constassert=require('assert');
+constcommon=require('../common');
 
-letonce=0;
-
-process.on('beforeExit',()=>{
-if(once>1)
-thrownewRangeError('beforeExit should only have been called once!');
-
-setTimeout(()=>{},1).unref();
-once++;
-});
-
-process.on('exit',(code)=>{
-if(code!==0)return;
-
-assert.strictEqual(once,1);
-});
+process.on('beforeExit',common.mustCall(()=>{
+setTimeout(common.mustNotCall(),1).unref();
+}));

test/parallel/test-timers-zero-timeout.js

@@ -15,18 +15,14 @@ const assert = require('assert');
 }
 
 {
-letncalled=0;
+letncalled=3;
 
-constiv=setInterval(f,0,'foo','bar','baz');
-
-functionf(a,b,c){
+constf=common.mustCall((a,b,c)=>{
 assert.strictEqual(a,'foo');
 assert.strictEqual(b,'bar');
 assert.strictEqual(c,'baz');
-if(++ncalled===3)clearTimeout(iv);
-}
+if(--ncalled===0)clearTimeout(iv);
+},ncalled);
 
-process.on('exit',function(){
-assert.strictEqual(ncalled,3);
-});
+constiv=setInterval(f,0,'foo','bar','baz');
 }