events: refactor to use validator

lib/events.js

@@ -33,7 +33,6 @@ const {
   ErrorCaptureStackTrace,
   FunctionPrototypeBind,
   FunctionPrototypeCall,
-  NumberIsNaN,
   NumberMAX_SAFE_INTEGER,
   ObjectCreate,
   ObjectDefineProperty,
@@ -70,7 +69,6 @@ const {
   codes: {
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_THIS,
-    ERR_OUT_OF_RANGE,
     ERR_UNHANDLED_ERROR
   },
   genericNodeError,
@@ -81,6 +79,7 @@ const {
   validateAbortSignal,
   validateBoolean,
   validateFunction,
+  validateNumber,
   validateString,
 } = require('internal/validators');
 
@@ -279,11 +278,7 @@ ObjectDefineProperty(EventEmitter, 'defaultMaxListeners', {
     return defaultMaxListeners;
   },
   set: function(arg) {
-    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
-      throw new ERR_OUT_OF_RANGE('defaultMaxListeners',
-                                 'a non-negative number',
-                                 arg);
-    }
+    validateNumber(arg, 'defaultMaxListeners', 0);
     defaultMaxListeners = arg;
   }
 });
@@ -313,8 +308,7 @@ ObjectDefineProperties(EventEmitter, {
  */
 EventEmitter.setMaxListeners =
   function(n = defaultMaxListeners, ...eventTargets) {
-    if (typeof n !== 'number' || n < 0 || NumberIsNaN(n))
-      throw new ERR_OUT_OF_RANGE('n', 'a non-negative number', n);
+    validateNumber(n, 'n', 0);
     if (eventTargets.length === 0) {
       defaultMaxListeners = n;
     } else {
@@ -410,9 +404,7 @@ function emitUnhandledRejectionOrErr(ee, err, type, args) {
  * @returns {EventEmitter}
  */
 EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
-    throw new ERR_OUT_OF_RANGE('n', 'a non-negative number', n);
-  }
+  validateNumber(n, 'n', 0);
   this._maxListeners = n;
   return this;
 };

test/parallel/test-event-emitter-max-listeners.js

@@ -23,46 +23,80 @@
 const common = require('../common');
 const assert = require('assert');
 const events = require('events');
-const { inspect } = require('util');
-const e = new events.EventEmitter();
 
-e.on('maxListeners', common.mustCall());
+const throwInvalidType = [true, 'string'];
+const throwOutOfRange = [-1, NaN];
 
-// Should not corrupt the 'maxListeners' queue.
-e.setMaxListeners(42);
+// for EventEmitter.prototype.setMaxListeners
+{
+  const e = new events.EventEmitter();
 
-const throwsObjs = [NaN, -1, 'and even this'];
+  e.on('maxListeners', common.mustCall());
 
-for (const obj of throwsObjs) {
-  assert.throws(
-    () => e.setMaxListeners(obj),
-    {
-      code: 'ERR_OUT_OF_RANGE',
-      name: 'RangeError',
-      message: 'The value of "n" is out of range. ' +
-               `It must be a non-negative number. Received ${inspect(obj)}`
-    }
-  );
+  // Should not corrupt the 'maxListeners' queue.
+  e.setMaxListeners(42);
 
-  assert.throws(
-    () => events.defaultMaxListeners = obj,
-    {
-      code: 'ERR_OUT_OF_RANGE',
-      name: 'RangeError',
-      message: 'The value of "defaultMaxListeners" is out of range. ' +
-               `It must be a non-negative number. Received ${inspect(obj)}`
-    }
-  );
+  for (const obj of throwInvalidType) {
+    assert.throws(
+      () => e.setMaxListeners(obj),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError',
+      }
+    );
+  }
+
+  for (const obj of throwOutOfRange) {
+    assert.throws(
+      () => e.setMaxListeners(obj),
+      {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError',
+      }
+    );
+  }
+
+  e.emit('maxListeners');
 }
 
-e.emit('maxListeners');
+// for EventEmitter.defaultMaxListeners
+{
+  for (const obj of throwInvalidType) {
+    assert.throws(
+      () => events.defaultMaxListeners = obj,
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError',
+      }
+    );
+  }
+
+  for (const obj of throwOutOfRange) {
+    assert.throws(
+      () => events.defaultMaxListeners = obj,
+      {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError',
+      }
+    );
+  }
+}
 
+// for EventEmitter.setMaxListeners
 {
   const { EventEmitter, defaultMaxListeners } = events;
-  for (const obj of throwsObjs) {
-    assert.throws(() => EventEmitter.setMaxListeners(obj), {
-      code: 'ERR_OUT_OF_RANGE',
-    });
+  for (const obj of throwInvalidType) {
+    assert.throws(
+      () => EventEmitter.setMaxListeners(obj),
+      { code: 'ERR_INVALID_ARG_TYPE' }
+    );
+  }
+
+  for (const obj of throwOutOfRange) {
+    assert.throws(
+      () => EventEmitter.setMaxListeners(obj),
+      { code: 'ERR_OUT_OF_RANGE' }
+    );
   }
 
   assert.throws(