test: improve multiple timers tests

PR-URL: https://github.com/nodejs/node/pull/14616
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Refael Ackermann <refack@gmail.com>

1 files changed, 21 insertions, 39 deletions

diff --git a/test/parallel/test-timers-unref.js b/test/parallel/test-timers-unref.js
index 7f66a364e3..0078d2dae3 100644
--- a/test/parallel/test-timers-unref.js
+++ b/test/parallel/test-timers-unref.js
@@ -21,60 +21,55 @@
 
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
-let interval_fired = false;
-let timeout_fired = false;
 let unref_interval = false;
 let unref_timer = false;
-let unref_callbacks = 0;
 let checks = 0;
 
 const LONG_TIME = 10 * 1000;
 const SHORT_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();
-
-const interval = setInterval(function() {
+const interval = 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();
 
-const check_unref = setInterval(function() {
+const check_unref = setInterval(() => {
   if (checks > 5 || (unref_interval && unref_timer))
     clearInterval(check_unref);
   checks += 1;
 }, 100);
 
-setTimeout(function() {
-  unref_callbacks++;
-  this.unref();
-}, SHORT_TIME);
+{
+  const timeout =
+    setTimeout(common.mustCall(() => {
+      timeout.unref();
+    }), SHORT_TIME);
+}
 
-// Should not timeout the test
-setInterval(function() {
-  this.unref();
-}, SHORT_TIME);
+{
+  // Should not timeout the test
+  const timeout =
+    setInterval(() => timeout.unref(), SHORT_TIME);
+}
 
 // Should not assert on args.Holder()->InternalFieldCount() > 0. See #4261.
 {
@@ -82,16 +77,3 @@ setInterval(function() {
   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');
-});