mirror of
https://github.com/zhigang1992/DefinitelyTyped.git
synced 2026-04-25 21:55:49 +08:00
580 lines
16 KiB
TypeScript
580 lines
16 KiB
TypeScript
///<reference path="eventemitter3.d.ts" />
|
|
///<reference path="../node/node.d.ts" />
|
|
///<reference path="../mocha/mocha.d.ts" />
|
|
'use strict';
|
|
|
|
import EventEmitter = require('eventemitter3');
|
|
import util = require('util');
|
|
import * as EventEmitter3ImportedAsES6Module from 'eventemitter3';
|
|
|
|
declare namespace Assume {
|
|
interface Class<T> {
|
|
new(...args: any[]): T;
|
|
}
|
|
|
|
interface Assume<T> {
|
|
equals(compare: T): Assume<T>;
|
|
equal(compare: T): Assume<T>;
|
|
eqls(compare: T): Assume<T>;
|
|
is: Assume<T>;
|
|
deep: Assume<T>;
|
|
to: Assume<T>;
|
|
either(arr: T[]): Assume<T>;
|
|
instanceOf(clazz: Class<T>): Assume<T>;
|
|
a(typeofString: string): Assume<T>;
|
|
}
|
|
|
|
export function assume<T>(input: T): Assume<T>;
|
|
}
|
|
|
|
let assume = Assume.assume;
|
|
|
|
class EventEmitterTest {
|
|
v: EventEmitter3.EventEmitter;
|
|
|
|
constructor() {
|
|
this.v = new EventEmitter();
|
|
this.v = new EventEmitter3ImportedAsES6Module();
|
|
var n: NodeJS.EventEmitter = this.v;
|
|
}
|
|
|
|
listeners() {
|
|
var v1: Function[] = this.v.listeners('click');
|
|
}
|
|
|
|
emit() {
|
|
var v1: boolean = this.v.emit('click');
|
|
var v2: boolean = this.v.emit('click', 1);
|
|
var v3: boolean = this.v.emit('click', 1, '1');
|
|
var v4: boolean = this.v.emit('click', 1, '1', true);
|
|
var v5: boolean = this.v.emit('click', 1, '1', true, new Date());
|
|
}
|
|
|
|
on() {
|
|
var fn = () => console.log(1);
|
|
var v1: EventEmitter3.EventEmitter = this.v.on('click', fn);
|
|
var v2: EventEmitter3.EventEmitter = this.v.on('click', fn, this);
|
|
}
|
|
|
|
once() {
|
|
var fn = () => console.log(1);
|
|
var v1: EventEmitter3.EventEmitter = this.v.once('click', fn);
|
|
var v2: EventEmitter3.EventEmitter = this.v.once('click', fn, this);
|
|
}
|
|
|
|
removeListener() {
|
|
var fn = () => console.log(1);
|
|
var v1: EventEmitter3.EventEmitter = this.v.removeListener('click', fn);
|
|
var v2: EventEmitter3.EventEmitter = this.v.removeListener('click', fn, true);
|
|
}
|
|
|
|
removeAllListeners() {
|
|
var v1: EventEmitter3.EventEmitter = this.v.removeAllListeners('click');
|
|
}
|
|
|
|
off() {
|
|
var fn = () => console.log(1);
|
|
var v1: EventEmitter3.EventEmitter = this.v.off('click', fn);
|
|
var v2: EventEmitter3.EventEmitter = this.v.off('click', fn, true);
|
|
}
|
|
|
|
addListener() {
|
|
var fn = () => console.log(1);
|
|
var v1: EventEmitter3.EventEmitter = this.v.addListener('click', fn);
|
|
var v2: EventEmitter3.EventEmitter = this.v.addListener('click', fn, this);
|
|
}
|
|
|
|
setMaxListeners() {
|
|
var v1: EventEmitter3.EventEmitter = this.v.setMaxListeners();
|
|
}
|
|
}
|
|
|
|
|
|
describe('EventEmitter', function tests() {
|
|
'use strict';
|
|
|
|
it('exposes a `prefixed` property', function () {
|
|
assume(EventEmitter.prefixed).is.either([false, '~']);
|
|
});
|
|
|
|
it('inherits when used with require(util).inherits', function () {
|
|
class Beast extends EventEmitter {
|
|
/* rawr, i'm a beast */
|
|
}
|
|
|
|
util.inherits(Beast, EventEmitter);
|
|
|
|
var moop = new Beast()
|
|
, meap = new Beast();
|
|
|
|
assume(moop).is.instanceOf(Beast);
|
|
assume(moop).is.instanceOf(EventEmitter);
|
|
|
|
moop.listeners();
|
|
meap.listeners();
|
|
|
|
moop.on('data', function () {
|
|
throw new Error('I should not emit');
|
|
});
|
|
|
|
meap.emit('data', 'rawr');
|
|
meap.removeListener('foo');
|
|
meap.removeAllListeners();
|
|
});
|
|
|
|
describe('EventEmitter#emit', function () {
|
|
it('should return false when there are not events to emit', function () {
|
|
var e = new EventEmitter();
|
|
|
|
assume(e.emit('foo')).equals(false);
|
|
assume(e.emit('bar')).equals(false);
|
|
});
|
|
|
|
it('emits with context', function (done) {
|
|
var context = { bar: 'baz' }
|
|
, e = new EventEmitter();
|
|
|
|
e.on('foo', function (bar: string) {
|
|
assume(bar).equals('bar');
|
|
assume(this).equals(context);
|
|
|
|
done();
|
|
}, context).emit('foo', 'bar');
|
|
});
|
|
|
|
it('emits with context, multiple arguments (force apply)', function (done) {
|
|
var context = { bar: 'baz' }
|
|
, e = new EventEmitter();
|
|
|
|
e.on('foo', function (bar: string) {
|
|
assume(bar).equals('bar');
|
|
assume(this).equals(context);
|
|
|
|
done();
|
|
}, context).emit('foo', 'bar', 1,2,3,4,5,6,7,8,9,0);
|
|
});
|
|
|
|
it('can emit the function with multiple arguments', function () {
|
|
var e = new EventEmitter();
|
|
|
|
for(var i = 0; i < 100; i++) {
|
|
(function (j: number) {
|
|
for (var i = 0, args: number[] = []; i < j; i++) {
|
|
args.push(j);
|
|
}
|
|
|
|
e.once('args', function () {
|
|
assume(arguments.length).equals(args.length);
|
|
});
|
|
|
|
e.emit.apply(e, (['args'] as any[]).concat(args));
|
|
})(i);
|
|
}
|
|
});
|
|
|
|
it('can emit the function with multiple arguments, multiple listeners', function () {
|
|
var e = new EventEmitter();
|
|
|
|
for(var i = 0; i < 100; i++) {
|
|
(function (j: number) {
|
|
for (var i = 0, args: number[] = []; i < j; i++) {
|
|
args.push(j);
|
|
}
|
|
|
|
e.once('args', function () {
|
|
assume(arguments.length).equals(args.length);
|
|
});
|
|
|
|
e.once('args', function () {
|
|
assume(arguments.length).equals(args.length);
|
|
});
|
|
|
|
e.once('args', function () {
|
|
assume(arguments.length).equals(args.length);
|
|
});
|
|
|
|
e.once('args', function () {
|
|
assume(arguments.length).equals(args.length);
|
|
});
|
|
|
|
e.emit.apply(e, (['args'] as any[]).concat(args));
|
|
})(i);
|
|
}
|
|
});
|
|
|
|
it('emits with context, multiple listeners (force loop)', function () {
|
|
var e = new EventEmitter();
|
|
|
|
e.on('foo', function (bar: string) {
|
|
assume(this).eqls({ foo: 'bar' });
|
|
assume(bar).equals('bar');
|
|
}, { foo: 'bar' });
|
|
|
|
e.on('foo', function (bar: string) {
|
|
assume(this).eqls({ bar: 'baz' });
|
|
assume(bar).equals('bar');
|
|
}, { bar: 'baz' });
|
|
|
|
e.emit('foo', 'bar');
|
|
});
|
|
|
|
it('emits with different contexts', function () {
|
|
var e = new EventEmitter()
|
|
, pattern = '';
|
|
|
|
function writer() {
|
|
pattern += this;
|
|
}
|
|
|
|
e.on('write', writer, 'foo');
|
|
e.on('write', writer, 'baz');
|
|
e.once('write', writer, 'bar');
|
|
e.once('write', writer, 'banana');
|
|
|
|
e.emit('write');
|
|
assume(pattern).equals('foobazbarbanana');
|
|
});
|
|
|
|
it('should return true when there are events to emit', function (done) {
|
|
var e = new EventEmitter();
|
|
|
|
e.on('foo', function () {
|
|
process.nextTick(done);
|
|
});
|
|
|
|
assume(e.emit('foo')).equals(true);
|
|
assume(e.emit('foob')).equals(false);
|
|
});
|
|
|
|
it('receives the emitted events', function (done) {
|
|
var e = new EventEmitter();
|
|
|
|
e.on('data', function (a: string, b: EventEmitter3.EventEmitter, c: Date, d: void, undef: void) {
|
|
assume(a).equals('foo');
|
|
assume(b).equals(e);
|
|
assume(c).is.instanceOf(Date);
|
|
assume(undef).equals(undefined);
|
|
assume(arguments.length).equals(3);
|
|
|
|
done();
|
|
});
|
|
|
|
e.emit('data', 'foo', e, new Date());
|
|
});
|
|
|
|
it('emits to all event listeners', function () {
|
|
var e = new EventEmitter()
|
|
, pattern: string[] = [];
|
|
|
|
e.on('foo', function () {
|
|
pattern.push('foo1');
|
|
});
|
|
|
|
e.on('foo', function () {
|
|
pattern.push('foo2');
|
|
});
|
|
|
|
e.emit('foo');
|
|
|
|
assume(pattern.join(';')).equals('foo1;foo2');
|
|
});
|
|
|
|
(function each(keys: string[]) {
|
|
var key = keys.shift();
|
|
|
|
if (!key) return;
|
|
|
|
it('can store event which is a known property: '+ key, function (next) {
|
|
var e = new EventEmitter();
|
|
|
|
e.on(key, function (key: string) {
|
|
assume(key).equals(key);
|
|
next();
|
|
}).emit(key, key);
|
|
});
|
|
|
|
each(keys);
|
|
})([
|
|
'hasOwnProperty',
|
|
'constructor',
|
|
'__proto__',
|
|
'toString',
|
|
'toValue',
|
|
'unwatch',
|
|
'watch'
|
|
]);
|
|
});
|
|
|
|
describe('EventEmitter#listeners', function () {
|
|
it('returns an empty array if no listeners are specified', function () {
|
|
var e = new EventEmitter();
|
|
|
|
assume(e.listeners('foo')).is.a('array');
|
|
assume(e.listeners('foo').length).equals(0);
|
|
});
|
|
|
|
it('returns an array of function', function () {
|
|
var e = new EventEmitter();
|
|
|
|
function foo() {}
|
|
|
|
e.on('foo', foo);
|
|
assume(e.listeners('foo')).is.a('array');
|
|
assume(e.listeners('foo').length).equals(1);
|
|
assume(e.listeners('foo')).deep.equals([foo]);
|
|
});
|
|
|
|
it('is not vulnerable to modifications', function () {
|
|
var e = new EventEmitter();
|
|
|
|
function foo() {}
|
|
|
|
e.on('foo', foo);
|
|
|
|
assume(e.listeners('foo')).deep.equals([foo]);
|
|
|
|
e.listeners('foo').length = 0;
|
|
assume(e.listeners('foo')).deep.equals([foo]);
|
|
});
|
|
|
|
it('can return a boolean as indication if listeners exist', function () {
|
|
var e = new EventEmitter();
|
|
|
|
function foo() {}
|
|
|
|
e.once('once', foo);
|
|
e.once('multiple', foo);
|
|
e.once('multiple', foo);
|
|
e.on('on', foo);
|
|
e.on('multi', foo);
|
|
e.on('multi', foo);
|
|
|
|
assume(e.listeners('foo', true)).equals(false);
|
|
assume(e.listeners('multiple', true)).equals(true);
|
|
assume(e.listeners('on', true)).equals(true);
|
|
assume(e.listeners('multi', true)).equals(true);
|
|
|
|
e.removeAllListeners();
|
|
|
|
assume(e.listeners('multiple', true)).equals(false);
|
|
assume(e.listeners('on', true)).equals(false);
|
|
assume(e.listeners('multi', true)).equals(false);
|
|
});
|
|
});
|
|
|
|
describe('EventEmitter#once', function () {
|
|
it('only emits it once', function () {
|
|
var e = new EventEmitter()
|
|
, calls = 0;
|
|
|
|
e.once('foo', function () {
|
|
calls++;
|
|
});
|
|
|
|
e.emit('foo');
|
|
e.emit('foo');
|
|
e.emit('foo');
|
|
e.emit('foo');
|
|
e.emit('foo');
|
|
|
|
assume(e.listeners('foo').length).equals(0);
|
|
assume(calls).equals(1);
|
|
});
|
|
|
|
it('only emits once if emits are nested inside the listener', function () {
|
|
var e = new EventEmitter()
|
|
, calls = 0;
|
|
|
|
e.once('foo', function () {
|
|
calls++;
|
|
e.emit('foo');
|
|
});
|
|
|
|
e.emit('foo');
|
|
assume(e.listeners('foo').length).equals(0);
|
|
assume(calls).equals(1);
|
|
});
|
|
|
|
it('only emits once for multiple events', function () {
|
|
var e = new EventEmitter()
|
|
, multi = 0
|
|
, foo = 0
|
|
, bar = 0;
|
|
|
|
e.once('foo', function () {
|
|
foo++;
|
|
});
|
|
|
|
e.once('foo', function () {
|
|
bar++;
|
|
});
|
|
|
|
e.on('foo', function () {
|
|
multi++;
|
|
});
|
|
|
|
e.emit('foo');
|
|
e.emit('foo');
|
|
e.emit('foo');
|
|
e.emit('foo');
|
|
e.emit('foo');
|
|
|
|
assume(e.listeners('foo').length).equals(1);
|
|
assume(multi).equals(5);
|
|
assume(foo).equals(1);
|
|
assume(bar).equals(1);
|
|
});
|
|
|
|
it('only emits once with context', function (done) {
|
|
var context = { foo: 'bar' }
|
|
, e = new EventEmitter();
|
|
|
|
e.once('foo', function (bar: string) {
|
|
assume(this).equals(context);
|
|
assume(bar).equals('bar');
|
|
|
|
done();
|
|
}, context).emit('foo', 'bar');
|
|
});
|
|
});
|
|
|
|
describe('EventEmitter#removeListener', function () {
|
|
it('should only remove the event with the specified function', function () {
|
|
var e = new EventEmitter();
|
|
|
|
function bar() {}
|
|
e.on('foo', function () {});
|
|
e.on('bar', function () {});
|
|
e.on('bar', bar);
|
|
|
|
assume(e.removeListener('foo', bar)).equals(e);
|
|
assume(e.listeners('foo').length).equals(1);
|
|
assume(e.listeners('bar').length).equals(2);
|
|
|
|
assume(e.removeListener('foo')).equals(e);
|
|
assume(e.listeners('foo').length).equals(0);
|
|
assume(e.listeners('bar').length).equals(2);
|
|
|
|
assume(e.removeListener('bar', bar)).equals(e);
|
|
assume(e.listeners('bar').length).equals(1);
|
|
assume(e.removeListener('bar')).equals(e);
|
|
assume(e.listeners('bar').length).equals(0);
|
|
});
|
|
|
|
it('should only remove once events when using the once flag', function () {
|
|
var e = new EventEmitter();
|
|
|
|
function foo() {}
|
|
e.on('foo', foo);
|
|
|
|
assume(e.removeListener('foo', function () {}, undefined, true)).equals(e);
|
|
assume(e.listeners('foo').length).equals(1);
|
|
assume(e.removeListener('foo', foo, undefined, true)).equals(e);
|
|
assume(e.listeners('foo').length).equals(1);
|
|
assume(e.removeListener('foo', foo)).equals(e);
|
|
assume(e.listeners('foo').length).equals(0);
|
|
|
|
e.on('foo', foo);
|
|
e.once('foo', foo);
|
|
|
|
assume(e.removeListener('foo', function () {}, undefined, true)).equals(e);
|
|
assume(e.listeners('foo').length).equals(2);
|
|
assume(e.removeListener('foo', foo, undefined, true)).equals(e);
|
|
assume(e.listeners('foo').length).equals(1);
|
|
|
|
e.once('foo', foo);
|
|
|
|
assume(e.removeListener('foo', foo)).equals(e);
|
|
assume(e.listeners('foo').length).equals(0);
|
|
});
|
|
|
|
it('should only remove listeners matching the correct context', function () {
|
|
var e = new EventEmitter()
|
|
, context = { foo: 'bar' };
|
|
|
|
function foo() {}
|
|
function bar() {}
|
|
e.on('foo', foo, context);
|
|
|
|
assume(e.listeners('foo').length).equals(1);
|
|
assume(e.removeListener('foo', function () {}, context)).equals(e);
|
|
assume(e.listeners('foo').length).equals(1);
|
|
assume(e.removeListener('foo', foo, { baz: 'quux' })).equals(e);
|
|
assume(e.listeners('foo').length).equals(1);
|
|
assume(e.removeListener('foo', foo, context)).equals(e);
|
|
assume(e.listeners('foo').length).equals(0);
|
|
|
|
e.on('foo', foo, context);
|
|
e.on('foo', bar);
|
|
|
|
assume(e.listeners('foo').length).equals(2);
|
|
assume(e.removeListener('foo', foo, { baz: 'quux' })).equals(e);
|
|
assume(e.listeners('foo').length).equals(2);
|
|
assume(e.removeListener('foo', foo, context)).equals(e);
|
|
assume(e.listeners('foo').length).equals(1);
|
|
assume(e.listeners('foo')[0]).equals(bar);
|
|
|
|
e.on('foo', foo, context);
|
|
|
|
assume(e.listeners('foo').length).equals(2);
|
|
assume(e.removeAllListeners('foo')).equals(e);
|
|
assume(e.listeners('foo').length).equals(0);
|
|
});
|
|
});
|
|
|
|
describe('EventEmitter#removeAllListeners', function () {
|
|
it('removes all events for the specified events', function () {
|
|
var e = new EventEmitter();
|
|
|
|
e.on('foo', function () { throw new Error('oops'); });
|
|
e.on('foo', function () { throw new Error('oops'); });
|
|
e.on('bar', function () { throw new Error('oops'); });
|
|
e.on('aaa', function () { throw new Error('oops'); });
|
|
|
|
assume(e.removeAllListeners('foo')).equals(e);
|
|
assume(e.listeners('foo').length).equals(0);
|
|
assume(e.listeners('bar').length).equals(1);
|
|
assume(e.listeners('aaa').length).equals(1);
|
|
|
|
assume(e.removeAllListeners('bar')).equals(e);
|
|
assume(e.removeAllListeners('aaa')).equals(e);
|
|
|
|
assume(e.emit('foo')).equals(false);
|
|
assume(e.emit('bar')).equals(false);
|
|
assume(e.emit('aaa')).equals(false);
|
|
});
|
|
|
|
it('just nukes the fuck out of everything', function () {
|
|
var e = new EventEmitter();
|
|
|
|
e.on('foo', function () { throw new Error('oops'); });
|
|
e.on('foo', function () { throw new Error('oops'); });
|
|
e.on('bar', function () { throw new Error('oops'); });
|
|
e.on('aaa', function () { throw new Error('oops'); });
|
|
|
|
assume(e.removeAllListeners()).equals(e);
|
|
assume(e.listeners('foo').length).equals(0);
|
|
assume(e.listeners('bar').length).equals(0);
|
|
assume(e.listeners('aaa').length).equals(0);
|
|
|
|
assume(e.emit('foo')).equals(false);
|
|
assume(e.emit('bar')).equals(false);
|
|
assume(e.emit('aaa')).equals(false);
|
|
});
|
|
});
|
|
|
|
describe('#setMaxListeners', function () {
|
|
it('is a function', function () {
|
|
var e = new EventEmitter();
|
|
|
|
assume(e.setMaxListeners).is.a('function');
|
|
});
|
|
|
|
it('returns self when called', function () {
|
|
var e = new EventEmitter();
|
|
|
|
assume(e.setMaxListeners()).to.equal(e);
|
|
});
|
|
});
|
|
});
|