test: refactor large event emitter tests

This commit splits several large event emitter tests into smaller
block scoped tests. This keeps the tests more isolated. This
commit also replaces var with const, assert.equal() with
assert.stictEqual(), and other small enhancements.

PR-URL: https://github.com/nodejs/node/pull/6446
Reviewed-By: Santiago Gimeno <santiago.gimeno@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

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

@@ -1,32 +1,38 @@
 'use strict';
 
 require('../common');
-var assert = require('assert');
+const assert = require('assert');
-var events = require('events');
+const events = require('events');
 
 function listener() {}
 function listener2() {}
 
-var e1 = new events.EventEmitter();
+{
-e1.on('foo', listener);
+  const ee = new events.EventEmitter();
-var fooListeners = e1.listeners('foo');
+  ee.on('foo', listener);
-assert.deepStrictEqual(e1.listeners('foo'), [listener]);
+  const fooListeners = ee.listeners('foo');
-e1.removeAllListeners('foo');
+  assert.deepStrictEqual(ee.listeners('foo'), [listener]);
-assert.deepStrictEqual(e1.listeners('foo'), []);
+  ee.removeAllListeners('foo');
+  assert.deepStrictEqual(ee.listeners('foo'), []);
   assert.deepStrictEqual(fooListeners, [listener]);
+}
 
-var e2 = new events.EventEmitter();
+{
-e2.on('foo', listener);
+  const ee = new events.EventEmitter();
-var e2ListenersCopy = e2.listeners('foo');
+  ee.on('foo', listener);
-assert.deepStrictEqual(e2ListenersCopy, [listener]);
+  const eeListenersCopy = ee.listeners('foo');
-assert.deepStrictEqual(e2.listeners('foo'), [listener]);
+  assert.deepStrictEqual(eeListenersCopy, [listener]);
-e2ListenersCopy.push(listener2);
+  assert.deepStrictEqual(ee.listeners('foo'), [listener]);
-assert.deepStrictEqual(e2.listeners('foo'), [listener]);
+  eeListenersCopy.push(listener2);
-assert.deepStrictEqual(e2ListenersCopy, [listener, listener2]);
+  assert.deepStrictEqual(ee.listeners('foo'), [listener]);
+  assert.deepStrictEqual(eeListenersCopy, [listener, listener2]);
+}
 
-var e3 = new events.EventEmitter();
+{
-e3.on('foo', listener);
+  const ee = new events.EventEmitter();
-var e3ListenersCopy = e3.listeners('foo');
+  ee.on('foo', listener);
-e3.on('foo', listener2);
+  const eeListenersCopy = ee.listeners('foo');
-assert.deepStrictEqual(e3.listeners('foo'), [listener, listener2]);
+  ee.on('foo', listener2);
-assert.deepStrictEqual(e3ListenersCopy, [listener]);
+  assert.deepStrictEqual(ee.listeners('foo'), [listener, listener2]);
+  assert.deepStrictEqual(eeListenersCopy, [listener]);
+}

test/parallel/test-event-emitter-remove-all-listeners.js

@@ -1,11 +1,11 @@
 'use strict';
-var common = require('../common');
+const common = require('../common');
-var assert = require('assert');
+const assert = require('assert');
-var events = require('events');
+const events = require('events');
 
 
 function expect(expected) {
-  var actual = [];
+  const actual = [];
   process.on('exit', function() {
     assert.deepStrictEqual(actual.sort(), expected.sort());
   });
@@ -17,56 +17,63 @@ function expect(expected) {
 
 function listener() {}
 
-var e1 = new events.EventEmitter();
+{
-e1.on('foo', listener);
+  const ee = new events.EventEmitter();
-e1.on('bar', listener);
+  ee.on('foo', listener);
-e1.on('baz', listener);
+  ee.on('bar', listener);
-e1.on('baz', listener);
+  ee.on('baz', listener);
-var fooListeners = e1.listeners('foo');
+  ee.on('baz', listener);
-var barListeners = e1.listeners('bar');
+  const fooListeners = ee.listeners('foo');
-var bazListeners = e1.listeners('baz');
+  const barListeners = ee.listeners('bar');
-e1.on('removeListener', expect(['bar', 'baz', 'baz']));
+  const bazListeners = ee.listeners('baz');
-e1.removeAllListeners('bar');
+  ee.on('removeListener', expect(['bar', 'baz', 'baz']));
-e1.removeAllListeners('baz');
+  ee.removeAllListeners('bar');
-assert.deepStrictEqual(e1.listeners('foo'), [listener]);
+  ee.removeAllListeners('baz');
-assert.deepStrictEqual(e1.listeners('bar'), []);
+  assert.deepStrictEqual(ee.listeners('foo'), [listener]);
-assert.deepStrictEqual(e1.listeners('baz'), []);
+  assert.deepStrictEqual(ee.listeners('bar'), []);
-// after calling removeAllListeners,
+  assert.deepStrictEqual(ee.listeners('baz'), []);
-// the old listeners array should stay unchanged
+  // After calling removeAllListeners(),
+  // the old listeners array should stay unchanged.
   assert.deepStrictEqual(fooListeners, [listener]);
   assert.deepStrictEqual(barListeners, [listener]);
   assert.deepStrictEqual(bazListeners, [listener, listener]);
-// after calling removeAllListeners,
+  // After calling removeAllListeners(),
-// new listeners arrays are different from the old
+  // new listeners arrays is different from the old.
-assert.notEqual(e1.listeners('bar'), barListeners);
+  assert.notEqual(ee.listeners('bar'), barListeners);
-assert.notEqual(e1.listeners('baz'), bazListeners);
+  assert.notEqual(ee.listeners('baz'), bazListeners);
+}
 
-var e2 = new events.EventEmitter();
+{
-e2.on('foo', listener);
+  const ee = new events.EventEmitter();
-e2.on('bar', listener);
+  ee.on('foo', listener);
-// expect LIFO order
+  ee.on('bar', listener);
-e2.on('removeListener', expect(['foo', 'bar', 'removeListener']));
+  // Expect LIFO order
-e2.on('removeListener', expect(['foo', 'bar']));
+  ee.on('removeListener', expect(['foo', 'bar', 'removeListener']));
-e2.removeAllListeners();
+  ee.on('removeListener', expect(['foo', 'bar']));
-console.error(e2);
+  ee.removeAllListeners();
-assert.deepStrictEqual([], e2.listeners('foo'));
+  assert.deepStrictEqual([], ee.listeners('foo'));
-assert.deepStrictEqual([], e2.listeners('bar'));
+  assert.deepStrictEqual([], ee.listeners('bar'));
+}
 
-var e3 = new events.EventEmitter();
+{
-e3.on('removeListener', listener);
+  const ee = new events.EventEmitter();
-// check for regression where removeAllListeners throws when
+  ee.on('removeListener', listener);
-// there exists a removeListener listener, but there exists
+  // Check for regression where removeAllListeners() throws when
-// no listeners for the provided event type
+  // there exists a 'removeListener' listener, but there exists
-assert.doesNotThrow(e3.removeAllListeners.bind(e3, 'foo'));
+  // no listeners for the provided event type.
+  assert.doesNotThrow(ee.removeAllListeners.bind(ee, 'foo'));
+}
 
-var e4 = new events.EventEmitter();
+{
+  const ee = new events.EventEmitter();
   var expectLength = 2;
-e4.on('removeListener', function(name, listener) {
+  ee.on('removeListener', function(name, listener) {
-  assert.equal(expectLength--, this.listeners('baz').length);
+    assert.strictEqual(expectLength--, this.listeners('baz').length);
   });
-e4.on('baz', function() {});
+  ee.on('baz', function() {});
-e4.on('baz', function() {});
+  ee.on('baz', function() {});
-e4.on('baz', function() {});
+  ee.on('baz', function() {});
-assert.equal(e4.listeners('baz').length, expectLength + 1);
+  assert.strictEqual(ee.listeners('baz').length, expectLength + 1);
-e4.removeAllListeners('baz');
+  ee.removeAllListeners('baz');
-assert.equal(e4.listeners('baz').length, 0);
+  assert.strictEqual(ee.listeners('baz').length, 0);
+}

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

@@ -1,115 +1,117 @@
 'use strict';
-var common = require('../common');
+const common = require('../common');
-var assert = require('assert');
+const assert = require('assert');
-var events = require('events');
+const events = require('events');
 
-var count = 0;
+function listener1() {}
+function listener2() {}
 
-function listener1() {
+{
-  console.log('listener1');
+  const ee = new events.EventEmitter();
-  count++;
+  ee.on('hello', listener1);
+  ee.on('removeListener', common.mustCall((name, cb) => {
+    assert.strictEqual(name, 'hello');
+    assert.strictEqual(cb, listener1);
+  }));
+  ee.removeListener('hello', listener1);
+  assert.deepStrictEqual([], ee.listeners('hello'));
 }
 
-function listener2() {
+{
-  console.log('listener2');
+  const ee = new events.EventEmitter();
-  count++;
+  ee.on('hello', listener1);
+  ee.on('removeListener', common.fail);
+  ee.removeListener('hello', listener2);
+  assert.deepStrictEqual([listener1], ee.listeners('hello'));
 }
 
+{
+  const ee = new events.EventEmitter();
+  ee.on('hello', listener1);
+  ee.on('hello', listener2);
+  ee.once('removeListener', common.mustCall((name, cb) => {
+    assert.strictEqual(name, 'hello');
+    assert.strictEqual(cb, listener1);
+    assert.deepStrictEqual([listener2], ee.listeners('hello'));
+  }));
+  ee.removeListener('hello', listener1);
+  assert.deepStrictEqual([listener2], ee.listeners('hello'));
+  ee.once('removeListener', common.mustCall((name, cb) => {
+    assert.strictEqual(name, 'hello');
+    assert.strictEqual(cb, listener2);
+    assert.deepStrictEqual([], ee.listeners('hello'));
+  }));
+  ee.removeListener('hello', listener2);
+  assert.deepStrictEqual([], ee.listeners('hello'));
+}
+
+{
+  const ee = new events.EventEmitter();
+
   function remove1() {
-  assert(0);
+    common.fail('remove1 should not have been called');
   }
 
   function remove2() {
-  assert(0);
+    common.fail('remove2 should not have been called');
   }
 
-var e1 = new events.EventEmitter();
+  ee.on('removeListener', common.mustCall(function(name, cb) {
-e1.on('hello', listener1);
-e1.on('removeListener', common.mustCall(function(name, cb) {
-  assert.equal(name, 'hello');
-  assert.equal(cb, listener1);
-}));
-e1.removeListener('hello', listener1);
-assert.deepStrictEqual([], e1.listeners('hello'));
-
-var e2 = new events.EventEmitter();
-e2.on('hello', listener1);
-e2.on('removeListener', common.fail);
-e2.removeListener('hello', listener2);
-assert.deepStrictEqual([listener1], e2.listeners('hello'));
-
-var e3 = new events.EventEmitter();
-e3.on('hello', listener1);
-e3.on('hello', listener2);
-e3.once('removeListener', common.mustCall(function(name, cb) {
-  assert.equal(name, 'hello');
-  assert.equal(cb, listener1);
-  assert.deepStrictEqual([listener2], e3.listeners('hello'));
-}));
-e3.removeListener('hello', listener1);
-assert.deepStrictEqual([listener2], e3.listeners('hello'));
-e3.once('removeListener', common.mustCall(function(name, cb) {
-  assert.equal(name, 'hello');
-  assert.equal(cb, listener2);
-  assert.deepStrictEqual([], e3.listeners('hello'));
-}));
-e3.removeListener('hello', listener2);
-assert.deepStrictEqual([], e3.listeners('hello'));
-
-var e4 = new events.EventEmitter();
-e4.on('removeListener', common.mustCall(function(name, cb) {
     if (cb !== remove1) return;
     this.removeListener('quux', remove2);
     this.emit('quux');
   }, 2));
-e4.on('quux', remove1);
+  ee.on('quux', remove1);
-e4.on('quux', remove2);
+  ee.on('quux', remove2);
-e4.removeListener('quux', remove1);
+  ee.removeListener('quux', remove1);
+}
 
-var e5 = new events.EventEmitter();
+{
-e5.on('hello', listener1);
+  const ee = new events.EventEmitter();
-e5.on('hello', listener2);
+  ee.on('hello', listener1);
-e5.once('removeListener', common.mustCall(function(name, cb) {
+  ee.on('hello', listener2);
-  assert.equal(name, 'hello');
+  ee.once('removeListener', common.mustCall((name, cb) => {
-  assert.equal(cb, listener1);
+    assert.strictEqual(name, 'hello');
-  assert.deepStrictEqual([listener2], e5.listeners('hello'));
+    assert.strictEqual(cb, listener1);
-  e5.once('removeListener', common.mustCall(function(name, cb) {
+    assert.deepStrictEqual([listener2], ee.listeners('hello'));
-    assert.equal(name, 'hello');
+    ee.once('removeListener', common.mustCall((name, cb) => {
-    assert.equal(cb, listener2);
+      assert.strictEqual(name, 'hello');
-    assert.deepStrictEqual([], e5.listeners('hello'));
+      assert.strictEqual(cb, listener2);
+      assert.deepStrictEqual([], ee.listeners('hello'));
     }));
-  e5.removeListener('hello', listener2);
+    ee.removeListener('hello', listener2);
-  assert.deepStrictEqual([], e5.listeners('hello'));
+    assert.deepStrictEqual([], ee.listeners('hello'));
   }));
-e5.removeListener('hello', listener1);
+  ee.removeListener('hello', listener1);
-assert.deepStrictEqual([], e5.listeners('hello'));
+  assert.deepStrictEqual([], ee.listeners('hello'));
-
+}
-const e6 = new events.EventEmitter();
 
+{
+  const ee = new events.EventEmitter();
   const listener3 = common.mustCall(() => {
-  e6.removeListener('hello', listener4);
+    ee.removeListener('hello', listener4);
   }, 2);
+  const listener4 = common.mustCall(() => {});
 
-const listener4 = common.mustCall(() => {}, 1);
+  ee.on('hello', listener3);
-
+  ee.on('hello', listener4);
-e6.on('hello', listener3);
-e6.on('hello', listener4);
 
   // listener4 will still be called although it is removed by listener 3.
-e6.emit('hello');
+  ee.emit('hello');
   // This is so because the interal listener array at time of emit
   // was [listener3,listener4]
 
   // Interal listener array [listener3]
-e6.emit('hello');
+  ee.emit('hello');
+}
 
-const e7 = new events.EventEmitter();
+{
+  const ee = new events.EventEmitter();
 
-const listener5 = () => {};
+  ee.once('hello', listener1);
-
+  ee.on('removeListener', common.mustCall((eventName, listener) => {
-e7.once('hello', listener5);
-e7.on('removeListener', common.mustCall((eventName, listener) => {
     assert.strictEqual(eventName, 'hello');
-  assert.strictEqual(listener, listener5);
+    assert.strictEqual(listener, listener1);
   }));
-e7.emit('hello');
+  ee.emit('hello');
+}