events: fix unwrapping of ee.once() listeners

lib/events.js

@@ -217,8 +217,7 @@ EventEmitter.prototype.addListener = function addListener(type, listener) {
     // To avoid recursion in the case that type === "newListener"! Before
     // adding it to the listeners, first emit "newListener".
     if (events.newListener) {
-      this.emit('newListener', type,
-                listener.listener ? listener.listener : listener);
+      this.emit('newListener', type, unwrapListener(listener));
 
       // Re-assign `events` because a newListener handler could have caused the
       // this._events to be assigned to a new object
@@ -294,20 +293,20 @@ EventEmitter.prototype.removeListener =
       if (!list)
         return this;
 
-      if (list === listener || (list.listener && list.listener === listener)) {
+      if (list === listener || unwrapListener(list) === listener) {
         if (--this._eventsCount === 0)
           this._events = {};
         else {
           delete events[type];
           if (events.removeListener)
-            this.emit('removeListener', type, listener);
+            this.emit('removeListener', type, unwrapListener(listener));
         }
       } else if (typeof list !== 'function') {
         position = -1;
 
         for (i = list.length; i-- > 0;) {
           if (list[i] === listener ||
-              (list[i].listener && list[i].listener === listener)) {
+              unwrapListener(list[i]) === listener) {
             position = i;
             break;
           }
@@ -329,7 +328,7 @@ EventEmitter.prototype.removeListener =
         }
 
         if (events.removeListener)
-          this.emit('removeListener', type, listener);
+          this.emit('removeListener', type, unwrapListener(listener));
       }
 
       return this;
@@ -397,9 +396,9 @@ EventEmitter.prototype.listeners = function listeners(type) {
     if (!evlistener)
       ret = [];
     else if (typeof evlistener === 'function')
-      ret = [evlistener];
+      ret = [unwrapListener(evlistener)];
     else
-      ret = arrayClone(evlistener, evlistener.length);
+      ret = arrayMap(evlistener, unwrapListener);
   }
 
   return ret;
@@ -452,3 +451,15 @@ function arrayClone(arr, i) {
     copy[i] = arr[i];
   return copy;
 }
+
+function arrayMap(arr, fn) {
+  var ret = new Array(arr.length);
+  for (var i = 0; i < ret.length; ++i) {
+    ret[i] = fn(arr[i]);
+  }
+  return ret;
+}
+
+function unwrapListener(listener) {
+  return listener.listener ? listener.listener : listener;
+}

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

@@ -30,3 +30,12 @@ var e3ListenersCopy = e3.listeners('foo');
 e3.on('foo', listener2);
 assert.deepEqual(e3.listeners('foo'), [listener, listener2]);
 assert.deepEqual(e3ListenersCopy, [listener]);
+
+var e4 = new events.EventEmitter();
+e4.once('foo', listener);
+assert.deepEqual(e4.listeners('foo'), [listener]);
+
+var e5 = new events.EventEmitter();
+e5.on('foo', listener);
+e5.once('foo', listener2);
+assert.deepEqual(e5.listeners('foo'), [listener, listener2]);

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

@@ -102,3 +102,19 @@ e6.emit('hello');
 
 // Interal listener array [listener3]
 e6.emit('hello');
+
+const e7 = new events.EventEmitter();
+e7.on('hello', listener1);
+e7.once('hello', listener2);
+e7.once('removeListener', common.mustCall(function(name, cb) {
+  assert.equal(name, 'hello');
+  assert.equal(cb, listener2);
+  assert.deepEqual([listener1], e7.listeners('hello'));
+  e7.once('removeListener', common.mustCall(function(name, cb) {
+    assert.equal(name, 'hello');
+    assert.equal(cb, listener1);
+    assert.deepEqual([], e7.listeners('hello'));
+  }));
+  e7.removeListener('hello', listener1);
+}));
+e7.emit('hello');