1
// Copyright 2012 The Closure Library Authors. All Rights Reserved.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//      http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS-IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
/**
16
 * @fileoverview goog.events.EventTarget tester.
17
 * @author [email protected] (Chris Henry)
18
 */
19

20
goog.provide('goog.events.eventTargetTester');
21
goog.setTestOnly('goog.events.eventTargetTester');
22
goog.provide('goog.events.eventTargetTester.KeyType');
23
goog.setTestOnly('goog.events.eventTargetTester.KeyType');
24
goog.provide('goog.events.eventTargetTester.UnlistenReturnType');
25
goog.setTestOnly('goog.events.eventTargetTester.UnlistenReturnType');
26

27
goog.require('goog.array');
28
goog.require('goog.events');
29
goog.require('goog.events.Event');
30
goog.require('goog.events.EventTarget');
31
goog.require('goog.testing.asserts');
32
goog.require('goog.testing.recordFunction');
33

34

35
/**
36
 * Setup step for the test functions. This needs to be called from the
37
 * test setUp.
38
 * @param {function():!goog.events.Listenable} listenableFactoryFn Function
39
 *     that will return a new Listenable instance each time it is called.
40
 * @param {Function} listenFn Function that, given the same signature
41
 *     as goog.events.listen, will add listener to the given event
42
 *     target.
43
 * @param {Function} unlistenFn Function that, given the same
44
 *     signature as goog.events.unlisten, will remove listener from
45
 *     the given event target.
46
 * @param {Function} unlistenByKeyFn Function that, given 2
47
 *     parameters: src and key, will remove the corresponding
48
 *     listener.
49
 * @param {Function} listenOnceFn Function that, given the same
50
 *     signature as goog.events.listenOnce, will add a one-time
51
 *     listener to the given event target.
52
 * @param {Function} dispatchEventFn Function that, given the same
53
 *     signature as goog.events.dispatchEvent, will dispatch the event
54
 *     on the given event target.
55
 * @param {Function} removeAllFn Function that, given the same
56
 *     signature as goog.events.removeAll, will remove all listeners
57
 *     according to the contract of goog.events.removeAll.
58
 * @param {Function} getListenersFn Function that, given the same
59
 *     signature as goog.events.getListeners, will retrieve listeners.
60
 * @param {Function} getListenerFn Function that, given the same
61
 *     signature as goog.events.getListener, will retrieve the
62
 *     listener object.
63
 * @param {Function} hasListenerFn Function that, given the same
64
 *     signature as goog.events.hasListener, will determine whether
65
 *     listeners exist.
66
 * @param {goog.events.eventTargetTester.KeyType} listenKeyType The
67
 *     key type returned by listen call.
68
 * @param {goog.events.eventTargetTester.UnlistenReturnType}
69
 *     unlistenFnReturnType
70
 *     Whether we should check return value from
71
 *     unlisten call. If unlisten does not return a value, this should
72
 *     be set to false.
73
 * @param {boolean} objectListenerSupported Whether listener of type
74
 *     Object is supported.
75
 */
76
goog.events.eventTargetTester.setUp = function(
77
    listenableFactoryFn, listenFn, unlistenFn, unlistenByKeyFn, listenOnceFn,
78
    dispatchEventFn, removeAllFn, getListenersFn, getListenerFn, hasListenerFn,
79
    listenKeyType, unlistenFnReturnType, objectListenerSupported) {
80
  listenableFactory = listenableFactoryFn;
81
  listen = listenFn;
82
  unlisten = unlistenFn;
83
  unlistenByKey = unlistenByKeyFn;
84
  listenOnce = listenOnceFn;
85
  dispatchEvent = dispatchEventFn;
86
  removeAll = removeAllFn;
87
  getListeners = getListenersFn;
88
  getListener = getListenerFn;
89
  hasListener = hasListenerFn;
90
  keyType = listenKeyType;
91
  unlistenReturnType = unlistenFnReturnType;
92
  objectTypeListenerSupported = objectListenerSupported;
93

94
  listeners = [];
95
  for (var i = 0; i < goog.events.eventTargetTester.MAX_; i++) {
96
    listeners[i] = createListener();
97
  }
98

99
  eventTargets = [];
100
  for (i = 0; i < goog.events.eventTargetTester.MAX_; i++) {
101
    eventTargets[i] = listenableFactory();
102
  }
103
};
104

105

106
/**
107
 * Teardown step for the test functions. This needs to be called from
108
 * test teardown.
109
 */
110
goog.events.eventTargetTester.tearDown = function() {
111
  for (var i = 0; i < goog.events.eventTargetTester.MAX_; i++) {
112
    goog.dispose(eventTargets[i]);
113
  }
114
};
115

116

117
/**
118
 * The type of key returned by key-returning functions (listen).
119
 * @enum {number}
120
 */
121
goog.events.eventTargetTester.KeyType = {
122
  /**
123
   * Returns number for key.
124
   */
125
  NUMBER: 0,
126

127
  /**
128
   * Returns undefined (no return value).
129
   */
130
  UNDEFINED: 1
131
};
132

133

134
/**
135
 * The type of unlisten function's return value.
136
 * @enum {number}
137
 */
138
goog.events.eventTargetTester.UnlistenReturnType = {
139
  /**
140
   * Returns boolean indicating whether unlisten is successful.
141
   */
142
  BOOLEAN: 0,
143

144
  /**
145
   * Returns undefind (no return value).
146
   */
147
  UNDEFINED: 1
148
};
149

150

151
/**
152
 * Expando property used on "listener" function to determine if a
153
 * listener has already been checked. This is what allows us to
154
 * implement assertNoOtherListenerIsCalled.
155
 * @type {string}
156
 */
157
goog.events.eventTargetTester.ALREADY_CHECKED_PROP = '__alreadyChecked';
158

159

160
/**
161
 * Expando property used on "listener" function to record the number
162
 * of times it has been called the last time assertListenerIsCalled is
163
 * done. This allows us to verify that it has not been called more
164
 * times in assertNoOtherListenerIsCalled.
165
 */
166
goog.events.eventTargetTester.NUM_CALLED_PROP = '__numCalled';
167

168

169
/**
170
 * The maximum number of initialized event targets (in eventTargets
171
 * array) and listeners (in listeners array).
172
 * @type {number}
173
 * @private
174
 */
175
goog.events.eventTargetTester.MAX_ = 10;
176

177

178
/**
179
 * Contains test event types.
180
 * @enum {string}
181
 */
182
var EventType = {
183
  A: goog.events.getUniqueId('a'),
184
  B: goog.events.getUniqueId('b'),
185
  C: goog.events.getUniqueId('c')
186
};
187

188

189
var listenableFactory, listen, unlisten, unlistenByKey, listenOnce;
190
var dispatchEvent, removeAll, getListeners, getListener, hasListener;
191
var keyType, unlistenReturnType, objectTypeListenerSupported;
192
var eventTargets, listeners;
193

194

195

196
/**
197
 * Custom event object for testing.
198
 * @constructor
199
 * @extends {goog.events.Event}
200
 * @final
201
 */
202
var TestEvent = function() {
203
  TestEvent.base(this, 'constructor', EventType.A);
204
};
205
goog.inherits(TestEvent, goog.events.Event);
206

207

208
/**
209
 * Creates a listener that executes the given function (optional).
210
 * @param {!Function=} opt_listenerFn The optional function to execute.
211
 * @return {!Function} The listener function.
212
 */
213
function createListener(opt_listenerFn) {
214
  return goog.testing.recordFunction(opt_listenerFn);
215
}
216

217

218
/**
219
 * Asserts that the given listener is called numCount number of times.
220
 * @param {!Function} listener The listener to check.
221
 * @param {number} numCount The number of times. See also the times()
222
 *     function below.
223
 */
224
function assertListenerIsCalled(listener, numCount) {
225
  assertEquals(
226
      'Listeners is not called the correct number of times.', numCount,
227
      listener.getCallCount());
228
  listener[goog.events.eventTargetTester.ALREADY_CHECKED_PROP] = true;
229
  listener[goog.events.eventTargetTester.NUM_CALLED_PROP] = numCount;
230
}
231

232

233
/**
234
 * Asserts that no other listeners, other than those verified via
235
 * assertListenerIsCalled, have been called since the last
236
 * resetListeners().
237
 */
238
function assertNoOtherListenerIsCalled() {
239
  goog.array.forEach(listeners, function(l, index) {
240
    if (!l[goog.events.eventTargetTester.ALREADY_CHECKED_PROP]) {
241
      assertEquals(
242
          'Listeners ' + index + ' is unexpectedly called.', 0,
243
          l.getCallCount());
244
    } else {
245
      assertEquals(
246
          'Listeners ' + index + ' is unexpectedly called.',
247
          l[goog.events.eventTargetTester.NUM_CALLED_PROP], l.getCallCount());
248
    }
249
  });
250
}
251

252

253
/**
254
 * Resets all listeners call count to 0.
255
 */
256
function resetListeners() {
257
  goog.array.forEach(listeners, function(l) {
258
    l.reset();
259
    l[goog.events.eventTargetTester.ALREADY_CHECKED_PROP] = false;
260
  });
261
}
262

263

264
/**
265
 * The number of times a listener should have been executed. This
266
 * exists to make assertListenerIsCalled more readable.  This is used
267
 * like so: assertListenerIsCalled(listener, times(2));
268
 * @param {number} n The number of times a listener should have been
269
 *     executed.
270
 * @return {number} The number n.
271
 */
272
function times(n) {
273
  return n;
274
}
275

276

277
function testNoListener() {
278
  dispatchEvent(eventTargets[0], EventType.A);
279
  assertNoOtherListenerIsCalled();
280
}
281

282

283
function testOneListener() {
284
  listen(eventTargets[0], EventType.A, listeners[0]);
285
  dispatchEvent(eventTargets[0], EventType.A);
286
  assertListenerIsCalled(listeners[0], times(1));
287
  assertNoOtherListenerIsCalled();
288

289
  resetListeners();
290

291
  dispatchEvent(eventTargets[0], EventType.B);
292
  dispatchEvent(eventTargets[0], EventType.C);
293
  assertNoOtherListenerIsCalled();
294
}
295

296

297
function testTwoListenersOfSameType() {
298
  var key1 = listen(eventTargets[0], EventType.A, listeners[0]);
299
  var key2 = listen(eventTargets[0], EventType.A, listeners[1]);
300

301
  if (keyType == goog.events.eventTargetTester.KeyType.NUMBER) {
302
    assertNotEquals(key1, key2);
303
  } else {
304
    assertUndefined(key1);
305
    assertUndefined(key2);
306
  }
307

308
  dispatchEvent(eventTargets[0], EventType.A);
309
  assertListenerIsCalled(listeners[0], times(1));
310
  assertListenerIsCalled(listeners[1], times(1));
311
  assertNoOtherListenerIsCalled();
312
}
313

314

315
function testInstallingSameListeners() {
316
  var key1 = listen(eventTargets[0], EventType.A, listeners[0]);
317
  var key2 = listen(eventTargets[0], EventType.A, listeners[0]);
318
  var key3 = listen(eventTargets[0], EventType.B, listeners[0]);
319

320
  if (keyType == goog.events.eventTargetTester.KeyType.NUMBER) {
321
    assertEquals(key1, key2);
322
    assertNotEquals(key1, key3);
323
  } else {
324
    assertUndefined(key1);
325
    assertUndefined(key2);
326
    assertUndefined(key3);
327
  }
328

329
  dispatchEvent(eventTargets[0], EventType.A);
330
  assertListenerIsCalled(listeners[0], times(1));
331

332
  dispatchEvent(eventTargets[0], EventType.B);
333
  assertListenerIsCalled(listeners[0], times(2));
334

335
  assertNoOtherListenerIsCalled();
336
}
337

338

339
function testScope() {
340
  listeners[0] = createListener(function(e) {
341
    assertEquals('Wrong scope with undefined scope', eventTargets[0], this);
342
  });
343
  listeners[1] = createListener(function(e) {
344
    assertEquals('Wrong scope with null scope', eventTargets[0], this);
345
  });
346
  var scope = {};
347
  listeners[2] = createListener(function(e) {
348
    assertEquals('Wrong scope with specific scope object', scope, this);
349
  });
350
  listen(eventTargets[0], EventType.A, listeners[0]);
351
  listen(eventTargets[0], EventType.A, listeners[1], false, null);
352
  listen(eventTargets[0], EventType.A, listeners[2], false, scope);
353

354
  dispatchEvent(eventTargets[0], EventType.A);
355
  assertListenerIsCalled(listeners[0], times(1));
356
  assertListenerIsCalled(listeners[1], times(1));
357
  assertListenerIsCalled(listeners[2], times(1));
358
}
359

360

361
function testDispatchEventDoesNotThrowWithDisposedEventTarget() {
362
  goog.dispose(eventTargets[0]);
363
  assertTrue(dispatchEvent(eventTargets[0], EventType.A));
364
}
365

366

367
function testDispatchEventWithObjectLiteral() {
368
  listen(eventTargets[0], EventType.A, listeners[0]);
369

370
  assertTrue(dispatchEvent(eventTargets[0], {type: EventType.A}));
371
  assertListenerIsCalled(listeners[0], times(1));
372
  assertNoOtherListenerIsCalled();
373
}
374

375

376
function testDispatchEventWithCustomEventObject() {
377
  listen(eventTargets[0], EventType.A, listeners[0]);
378

379
  var e = new TestEvent();
380
  assertTrue(dispatchEvent(eventTargets[0], e));
381
  assertListenerIsCalled(listeners[0], times(1));
382
  assertNoOtherListenerIsCalled();
383

384
  var actualEvent = listeners[0].getLastCall().getArgument(0);
385

386
  assertEquals(e, actualEvent);
387
  assertEquals(eventTargets[0], actualEvent.target);
388
}
389

390

391
function testDisposingEventTargetRemovesListeners() {
392
  if (!(listenableFactory() instanceof goog.events.EventTarget)) {
393
    return;
394
  }
395
  listen(eventTargets[0], EventType.A, listeners[0]);
396
  goog.dispose(eventTargets[0]);
397
  dispatchEvent(eventTargets[0], EventType.A);
398

399
  assertNoOtherListenerIsCalled();
400
}
401

402

403
/**
404
 * Unlisten/unlistenByKey should still work after disposal. There are
405
 * many circumstances when this is actually necessary. For example, a
406
 * user may have listened to an event target and stored the key
407
 * (e.g. in a goog.events.EventHandler) and only unlisten after the
408
 * target has been disposed.
409
 */
410
function testUnlistenWorksAfterDisposal() {
411
  var key = listen(eventTargets[0], EventType.A, listeners[0]);
412
  goog.dispose(eventTargets[0]);
413
  unlisten(eventTargets[0], EventType.A, listeners[1]);
414
  if (unlistenByKey) {
415
    unlistenByKey(eventTargets[0], key);
416
  }
417
}
418

419

420
function testRemovingListener() {
421
  var ret1 = unlisten(eventTargets[0], EventType.A, listeners[0]);
422
  listen(eventTargets[0], EventType.A, listeners[0]);
423
  var ret2 = unlisten(eventTargets[0], EventType.A, listeners[1]);
424
  var ret3 = unlisten(eventTargets[0], EventType.B, listeners[0]);
425
  var ret4 = unlisten(eventTargets[1], EventType.A, listeners[0]);
426

427
  dispatchEvent(eventTargets[0], EventType.A);
428
  assertListenerIsCalled(listeners[0], times(1));
429

430
  var ret5 = unlisten(eventTargets[0], EventType.A, listeners[0]);
431
  var ret6 = unlisten(eventTargets[0], EventType.A, listeners[0]);
432

433
  dispatchEvent(eventTargets[0], EventType.A);
434
  assertListenerIsCalled(listeners[0], times(1));
435

436
  assertNoOtherListenerIsCalled();
437

438
  if (unlistenReturnType ==
439
      goog.events.eventTargetTester.UnlistenReturnType.BOOLEAN) {
440
    assertFalse(ret1);
441
    assertFalse(ret2);
442
    assertFalse(ret3);
443
    assertFalse(ret4);
444
    assertTrue(ret5);
445
    assertFalse(ret6);
446
  } else {
447
    assertUndefined(ret1);
448
    assertUndefined(ret2);
449
    assertUndefined(ret3);
450
    assertUndefined(ret4);
451
    assertUndefined(ret5);
452
    assertUndefined(ret6);
453
  }
454
}
455

456

457
function testCapture() {
458
  eventTargets[0].setParentEventTarget(eventTargets[1]);
459
  eventTargets[1].setParentEventTarget(eventTargets[2]);
460

461
  eventTargets[9].setParentEventTarget(eventTargets[0]);
462

463
  var ordering = 0;
464
  listeners[0] = createListener(function(e) {
465
    assertEquals(eventTargets[2], e.currentTarget);
466
    assertEquals(eventTargets[0], e.target);
467
    assertEquals('First capture listener is not called first', 0, ordering);
468
    ordering++;
469
  });
470
  listeners[1] = createListener(function(e) {
471
    assertEquals(eventTargets[1], e.currentTarget);
472
    assertEquals(eventTargets[0], e.target);
473
    assertEquals('2nd capture listener is not called 2nd', 1, ordering);
474
    ordering++;
475
  });
476
  listeners[2] = createListener(function(e) {
477
    assertEquals(eventTargets[0], e.currentTarget);
478
    assertEquals(eventTargets[0], e.target);
479
    assertEquals('3rd capture listener is not called 3rd', 2, ordering);
480
    ordering++;
481
  });
482

483
  listen(eventTargets[2], EventType.A, listeners[0], true);
484
  listen(eventTargets[1], EventType.A, listeners[1], true);
485
  listen(eventTargets[0], EventType.A, listeners[2], true);
486

487
  // These should not be called.
488
  listen(eventTargets[3], EventType.A, listeners[3], true);
489

490
  listen(eventTargets[0], EventType.B, listeners[4], true);
491
  listen(eventTargets[0], EventType.C, listeners[5], true);
492
  listen(eventTargets[1], EventType.B, listeners[6], true);
493
  listen(eventTargets[1], EventType.C, listeners[7], true);
494
  listen(eventTargets[2], EventType.B, listeners[8], true);
495
  listen(eventTargets[2], EventType.C, listeners[9], true);
496

497
  dispatchEvent(eventTargets[0], EventType.A);
498
  assertListenerIsCalled(listeners[0], times(1));
499
  assertListenerIsCalled(listeners[1], times(1));
500
  assertListenerIsCalled(listeners[2], times(1));
501
  assertNoOtherListenerIsCalled();
502
}
503

504

505
function testBubble() {
506
  eventTargets[0].setParentEventTarget(eventTargets[1]);
507
  eventTargets[1].setParentEventTarget(eventTargets[2]);
508

509
  eventTargets[9].setParentEventTarget(eventTargets[0]);
510

511
  var ordering = 0;
512
  listeners[0] = createListener(function(e) {
513
    assertEquals(eventTargets[0], e.currentTarget);
514
    assertEquals(eventTargets[0], e.target);
515
    assertEquals('First bubble listener is not called first', 0, ordering);
516
    ordering++;
517
  });
518
  listeners[1] = createListener(function(e) {
519
    assertEquals(eventTargets[1], e.currentTarget);
520
    assertEquals(eventTargets[0], e.target);
521
    assertEquals('2nd bubble listener is not called 2nd', 1, ordering);
522
    ordering++;
523
  });
524
  listeners[2] = createListener(function(e) {
525
    assertEquals(eventTargets[2], e.currentTarget);
526
    assertEquals(eventTargets[0], e.target);
527
    assertEquals('3rd bubble listener is not called 3rd', 2, ordering);
528
    ordering++;
529
  });
530

531
  listen(eventTargets[0], EventType.A, listeners[0]);
532
  listen(eventTargets[1], EventType.A, listeners[1]);
533
  listen(eventTargets[2], EventType.A, listeners[2]);
534

535
  // These should not be called.
536
  listen(eventTargets[3], EventType.A, listeners[3]);
537

538
  listen(eventTargets[0], EventType.B, listeners[4]);
539
  listen(eventTargets[0], EventType.C, listeners[5]);
540
  listen(eventTargets[1], EventType.B, listeners[6]);
541
  listen(eventTargets[1], EventType.C, listeners[7]);
542
  listen(eventTargets[2], EventType.B, listeners[8]);
543
  listen(eventTargets[2], EventType.C, listeners[9]);
544

545
  dispatchEvent(eventTargets[0], EventType.A);
546
  assertListenerIsCalled(listeners[0], times(1));
547
  assertListenerIsCalled(listeners[1], times(1));
548
  assertListenerIsCalled(listeners[2], times(1));
549
  assertNoOtherListenerIsCalled();
550
}
551

552

553
function testCaptureAndBubble() {
554
  eventTargets[0].setParentEventTarget(eventTargets[1]);
555
  eventTargets[1].setParentEventTarget(eventTargets[2]);
556

557
  listen(eventTargets[0], EventType.A, listeners[0], true);
558
  listen(eventTargets[1], EventType.A, listeners[1], true);
559
  listen(eventTargets[2], EventType.A, listeners[2], true);
560

561
  listen(eventTargets[0], EventType.A, listeners[3]);
562
  listen(eventTargets[1], EventType.A, listeners[4]);
563
  listen(eventTargets[2], EventType.A, listeners[5]);
564

565
  dispatchEvent(eventTargets[0], EventType.A);
566
  assertListenerIsCalled(listeners[0], times(1));
567
  assertListenerIsCalled(listeners[1], times(1));
568
  assertListenerIsCalled(listeners[2], times(1));
569
  assertListenerIsCalled(listeners[3], times(1));
570
  assertListenerIsCalled(listeners[4], times(1));
571
  assertListenerIsCalled(listeners[5], times(1));
572
  assertNoOtherListenerIsCalled();
573
}
574

575

576
function testPreventDefaultByReturningFalse() {
577
  listeners[0] = createListener(function(e) { return false; });
578
  listeners[1] = createListener(function(e) { return true; });
579
  listen(eventTargets[0], EventType.A, listeners[0]);
580
  listen(eventTargets[0], EventType.A, listeners[1]);
581

582
  var result = dispatchEvent(eventTargets[0], EventType.A);
583
  assertFalse(result);
584
}
585

586

587
function testPreventDefault() {
588
  listeners[0] = createListener(function(e) { e.preventDefault(); });
589
  listeners[1] = createListener(function(e) { return true; });
590
  listen(eventTargets[0], EventType.A, listeners[0]);
591
  listen(eventTargets[0], EventType.A, listeners[1]);
592

593
  var result = dispatchEvent(eventTargets[0], EventType.A);
594
  assertFalse(result);
595
}
596

597

598
function testPreventDefaultAtCapture() {
599
  listeners[0] = createListener(function(e) { e.preventDefault(); });
600
  listeners[1] = createListener(function(e) { return true; });
601
  listen(eventTargets[0], EventType.A, listeners[0], true);
602
  listen(eventTargets[0], EventType.A, listeners[1], true);
603

604
  var result = dispatchEvent(eventTargets[0], EventType.A);
605
  assertFalse(result);
606
}
607

608

609
function testStopPropagation() {
610
  eventTargets[0].setParentEventTarget(eventTargets[1]);
611
  eventTargets[1].setParentEventTarget(eventTargets[2]);
612

613
  listeners[0] = createListener(function(e) { e.stopPropagation(); });
614
  listen(eventTargets[0], EventType.A, listeners[0]);
615
  listen(eventTargets[0], EventType.A, listeners[1]);
616
  listen(eventTargets[1], EventType.A, listeners[2]);
617
  listen(eventTargets[2], EventType.A, listeners[3]);
618

619
  dispatchEvent(eventTargets[0], EventType.A);
620

621
  assertListenerIsCalled(listeners[0], times(1));
622
  assertListenerIsCalled(listeners[1], times(1));
623
  assertNoOtherListenerIsCalled();
624
}
625

626

627
function testStopPropagation2() {
628
  eventTargets[0].setParentEventTarget(eventTargets[1]);
629
  eventTargets[1].setParentEventTarget(eventTargets[2]);
630

631
  listeners[1] = createListener(function(e) { e.stopPropagation(); });
632
  listen(eventTargets[0], EventType.A, listeners[0]);
633
  listen(eventTargets[0], EventType.A, listeners[1]);
634
  listen(eventTargets[1], EventType.A, listeners[2]);
635
  listen(eventTargets[2], EventType.A, listeners[3]);
636

637
  dispatchEvent(eventTargets[0], EventType.A);
638

639
  assertListenerIsCalled(listeners[0], times(1));
640
  assertListenerIsCalled(listeners[1], times(1));
641
  assertNoOtherListenerIsCalled();
642
}
643

644

645
function testStopPropagation3() {
646
  eventTargets[0].setParentEventTarget(eventTargets[1]);
647
  eventTargets[1].setParentEventTarget(eventTargets[2]);
648

649
  listeners[2] = createListener(function(e) { e.stopPropagation(); });
650
  listen(eventTargets[0], EventType.A, listeners[0]);
651
  listen(eventTargets[0], EventType.A, listeners[1]);
652
  listen(eventTargets[1], EventType.A, listeners[2]);
653
  listen(eventTargets[2], EventType.A, listeners[3]);
654

655
  dispatchEvent(eventTargets[0], EventType.A);
656

657
  assertListenerIsCalled(listeners[0], times(1));
658
  assertListenerIsCalled(listeners[1], times(1));
659
  assertListenerIsCalled(listeners[2], times(1));
660
  assertNoOtherListenerIsCalled();
661
}
662

663

664
function testStopPropagationAtCapture() {
665
  eventTargets[0].setParentEventTarget(eventTargets[1]);
666
  eventTargets[1].setParentEventTarget(eventTargets[2]);
667

668
  listeners[0] = createListener(function(e) { e.stopPropagation(); });
669
  listen(eventTargets[2], EventType.A, listeners[0], true);
670
  listen(eventTargets[1], EventType.A, listeners[1], true);
671
  listen(eventTargets[0], EventType.A, listeners[2], true);
672
  listen(eventTargets[0], EventType.A, listeners[3]);
673
  listen(eventTargets[1], EventType.A, listeners[4]);
674
  listen(eventTargets[2], EventType.A, listeners[5]);
675

676
  dispatchEvent(eventTargets[0], EventType.A);
677

678
  assertListenerIsCalled(listeners[0], times(1));
679
  assertNoOtherListenerIsCalled();
680
}
681

682

683
function testHandleEvent() {
684
  if (!objectTypeListenerSupported) {
685
    return;
686
  }
687

688
  var obj = {};
689
  obj.handleEvent = goog.testing.recordFunction();
690

691
  listen(eventTargets[0], EventType.A, obj);
692
  dispatchEvent(eventTargets[0], EventType.A);
693

694
  assertEquals(1, obj.handleEvent.getCallCount());
695
}
696

697

698
function testListenOnce() {
699
  if (!listenOnce) {
700
    return;
701
  }
702

703
  listenOnce(eventTargets[0], EventType.A, listeners[0], true);
704
  listenOnce(eventTargets[0], EventType.A, listeners[1]);
705
  listenOnce(eventTargets[0], EventType.B, listeners[2]);
706

707
  dispatchEvent(eventTargets[0], EventType.A);
708

709
  assertListenerIsCalled(listeners[0], times(1));
710
  assertListenerIsCalled(listeners[1], times(1));
711
  assertListenerIsCalled(listeners[2], times(0));
712
  assertNoOtherListenerIsCalled();
713
  resetListeners();
714

715
  dispatchEvent(eventTargets[0], EventType.A);
716

717
  assertListenerIsCalled(listeners[0], times(0));
718
  assertListenerIsCalled(listeners[1], times(0));
719
  assertListenerIsCalled(listeners[2], times(0));
720

721
  dispatchEvent(eventTargets[0], EventType.B);
722
  assertListenerIsCalled(listeners[2], times(1));
723
  assertNoOtherListenerIsCalled();
724
}
725

726

727
function testUnlistenInListen() {
728
  listeners[1] = createListener(function(e) {
729
    unlisten(eventTargets[0], EventType.A, listeners[1]);
730
    unlisten(eventTargets[0], EventType.A, listeners[2]);
731
  });
732
  listen(eventTargets[0], EventType.A, listeners[0]);
733
  listen(eventTargets[0], EventType.A, listeners[1]);
734
  listen(eventTargets[0], EventType.A, listeners[2]);
735
  listen(eventTargets[0], EventType.A, listeners[3]);
736

737
  dispatchEvent(eventTargets[0], EventType.A);
738

739
  assertListenerIsCalled(listeners[0], times(1));
740
  assertListenerIsCalled(listeners[1], times(1));
741
  assertListenerIsCalled(listeners[2], times(0));
742
  assertListenerIsCalled(listeners[3], times(1));
743
  assertNoOtherListenerIsCalled();
744
  resetListeners();
745

746
  dispatchEvent(eventTargets[0], EventType.A);
747
  assertListenerIsCalled(listeners[0], times(1));
748
  assertListenerIsCalled(listeners[1], times(0));
749
  assertListenerIsCalled(listeners[2], times(0));
750
  assertListenerIsCalled(listeners[3], times(1));
751
  assertNoOtherListenerIsCalled();
752
}
753

754

755
function testUnlistenByKeyInListen() {
756
  if (!unlistenByKey) {
757
    return;
758
  }
759

760
  var key1, key2;
761
  listeners[1] = createListener(function(e) {
762
    unlistenByKey(eventTargets[0], key1);
763
    unlistenByKey(eventTargets[0], key2);
764
  });
765
  listen(eventTargets[0], EventType.A, listeners[0]);
766
  key1 = listen(eventTargets[0], EventType.A, listeners[1]);
767
  key2 = listen(eventTargets[0], EventType.A, listeners[2]);
768
  listen(eventTargets[0], EventType.A, listeners[3]);
769

770
  dispatchEvent(eventTargets[0], EventType.A);
771

772
  assertListenerIsCalled(listeners[0], times(1));
773
  assertListenerIsCalled(listeners[1], times(1));
774
  assertListenerIsCalled(listeners[2], times(0));
775
  assertListenerIsCalled(listeners[3], times(1));
776
  assertNoOtherListenerIsCalled();
777
  resetListeners();
778

779
  dispatchEvent(eventTargets[0], EventType.A);
780
  assertListenerIsCalled(listeners[0], times(1));
781
  assertListenerIsCalled(listeners[1], times(0));
782
  assertListenerIsCalled(listeners[2], times(0));
783
  assertListenerIsCalled(listeners[3], times(1));
784
  assertNoOtherListenerIsCalled();
785
}
786

787

788
function testSetParentEventTarget() {
789
  assertNull(eventTargets[0].getParentEventTarget());
790

791
  eventTargets[0].setParentEventTarget(eventTargets[1]);
792
  assertEquals(eventTargets[1], eventTargets[0].getParentEventTarget());
793
  assertNull(eventTargets[1].getParentEventTarget());
794

795
  eventTargets[0].setParentEventTarget(null);
796
  assertNull(eventTargets[0].getParentEventTarget());
797
}
798

799

800
function testListenOnceAfterListenDoesNotChangeExistingListener() {
801
  if (!listenOnce) {
802
    return;
803
  }
804

805
  listen(eventTargets[0], EventType.A, listeners[0]);
806
  listenOnce(eventTargets[0], EventType.A, listeners[0]);
807

808
  dispatchEvent(eventTargets[0], EventType.A);
809
  dispatchEvent(eventTargets[0], EventType.A);
810
  dispatchEvent(eventTargets[0], EventType.A);
811

812
  assertListenerIsCalled(listeners[0], times(3));
813
  assertNoOtherListenerIsCalled();
814
}
815

816

817
function testListenOnceAfterListenOnceDoesNotChangeExistingListener() {
818
  if (!listenOnce) {
819
    return;
820
  }
821

822
  listenOnce(eventTargets[0], EventType.A, listeners[0]);
823
  listenOnce(eventTargets[0], EventType.A, listeners[0]);
824

825
  dispatchEvent(eventTargets[0], EventType.A);
826
  dispatchEvent(eventTargets[0], EventType.A);
827
  dispatchEvent(eventTargets[0], EventType.A);
828

829
  assertListenerIsCalled(listeners[0], times(1));
830
  assertNoOtherListenerIsCalled();
831
}
832

833

834
function testListenAfterListenOnceRemoveOnceness() {
835
  if (!listenOnce) {
836
    return;
837
  }
838

839
  listenOnce(eventTargets[0], EventType.A, listeners[0]);
840
  listen(eventTargets[0], EventType.A, listeners[0]);
841

842
  dispatchEvent(eventTargets[0], EventType.A);
843
  dispatchEvent(eventTargets[0], EventType.A);
844
  dispatchEvent(eventTargets[0], EventType.A);
845

846
  assertListenerIsCalled(listeners[0], times(3));
847
  assertNoOtherListenerIsCalled();
848
}
849

850

851
function testUnlistenAfterListenOnce() {
852
  if (!listenOnce) {
853
    return;
854
  }
855

856
  listenOnce(eventTargets[0], EventType.A, listeners[0]);
857
  unlisten(eventTargets[0], EventType.A, listeners[0]);
858
  dispatchEvent(eventTargets[0], EventType.A);
859

860
  listen(eventTargets[0], EventType.A, listeners[0]);
861
  listenOnce(eventTargets[0], EventType.A, listeners[0]);
862
  unlisten(eventTargets[0], EventType.A, listeners[0]);
863
  dispatchEvent(eventTargets[0], EventType.A);
864

865
  listenOnce(eventTargets[0], EventType.A, listeners[0]);
866
  listen(eventTargets[0], EventType.A, listeners[0]);
867
  unlisten(eventTargets[0], EventType.A, listeners[0]);
868
  dispatchEvent(eventTargets[0], EventType.A);
869

870
  listenOnce(eventTargets[0], EventType.A, listeners[0]);
871
  listenOnce(eventTargets[0], EventType.A, listeners[0]);
872
  unlisten(eventTargets[0], EventType.A, listeners[0]);
873
  dispatchEvent(eventTargets[0], EventType.A);
874

875
  assertNoOtherListenerIsCalled();
876
}
877

878

879
function testRemoveAllWithType() {
880
  if (!removeAll) {
881
    return;
882
  }
883

884
  listen(eventTargets[0], EventType.A, listeners[0], true);
885
  listen(eventTargets[0], EventType.A, listeners[1]);
886
  listen(eventTargets[0], EventType.C, listeners[2], true);
887
  listen(eventTargets[0], EventType.C, listeners[3]);
888
  listen(eventTargets[0], EventType.B, listeners[4], true);
889
  listen(eventTargets[0], EventType.B, listeners[5], true);
890
  listen(eventTargets[0], EventType.B, listeners[6]);
891
  listen(eventTargets[0], EventType.B, listeners[7]);
892

893
  assertEquals(4, removeAll(eventTargets[0], EventType.B));
894

895
  dispatchEvent(eventTargets[0], EventType.A);
896
  dispatchEvent(eventTargets[0], EventType.B);
897
  dispatchEvent(eventTargets[0], EventType.C);
898

899
  assertListenerIsCalled(listeners[0], times(1));
900
  assertListenerIsCalled(listeners[1], times(1));
901
  assertListenerIsCalled(listeners[2], times(1));
902
  assertListenerIsCalled(listeners[3], times(1));
903
  assertNoOtherListenerIsCalled();
904
}
905

906

907
function testRemoveAll() {
908
  if (!removeAll) {
909
    return;
910
  }
911

912
  listen(eventTargets[0], EventType.A, listeners[0], true);
913
  listen(eventTargets[0], EventType.A, listeners[1]);
914
  listen(eventTargets[0], EventType.C, listeners[2], true);
915
  listen(eventTargets[0], EventType.C, listeners[3]);
916
  listen(eventTargets[0], EventType.B, listeners[4], true);
917
  listen(eventTargets[0], EventType.B, listeners[5], true);
918
  listen(eventTargets[0], EventType.B, listeners[6]);
919
  listen(eventTargets[0], EventType.B, listeners[7]);
920

921
  assertEquals(8, removeAll(eventTargets[0]));
922

923
  dispatchEvent(eventTargets[0], EventType.A);
924
  dispatchEvent(eventTargets[0], EventType.B);
925
  dispatchEvent(eventTargets[0], EventType.C);
926

927
  assertNoOtherListenerIsCalled();
928
}
929

930

931
function testRemoveAllCallsMarkAsRemoved() {
932
  if (!removeAll) {
933
    return;
934
  }
935

936
  var key0 = listen(eventTargets[0], EventType.A, listeners[0]);
937
  var key1 = listen(eventTargets[1], EventType.A, listeners[1]);
938

939
  assertNotNullNorUndefined(key0.listener);
940
  assertFalse(key0.removed);
941
  assertNotNullNorUndefined(key1.listener);
942
  assertFalse(key1.removed);
943

944
  assertEquals(1, removeAll(eventTargets[0]));
945
  assertNull(key0.listener);
946
  assertTrue(key0.removed);
947
  assertNotNullNorUndefined(key1.listener);
948
  assertFalse(key1.removed);
949

950
  assertEquals(1, removeAll(eventTargets[1]));
951
  assertNull(key1.listener);
952
  assertTrue(key1.removed);
953
}
954

955

956
function testGetListeners() {
957
  if (!getListeners) {
958
    return;
959
  }
960

961
  listen(eventTargets[0], EventType.A, listeners[0], true);
962
  listen(eventTargets[0], EventType.A, listeners[1], true);
963
  listen(eventTargets[0], EventType.A, listeners[2]);
964
  listen(eventTargets[0], EventType.A, listeners[3]);
965

966
  var l = getListeners(eventTargets[0], EventType.A, true);
967
  assertEquals(2, l.length);
968
  assertEquals(listeners[0], l[0].listener);
969
  assertEquals(listeners[1], l[1].listener);
970

971
  l = getListeners(eventTargets[0], EventType.A, false);
972
  assertEquals(2, l.length);
973
  assertEquals(listeners[2], l[0].listener);
974
  assertEquals(listeners[3], l[1].listener);
975

976
  l = getListeners(eventTargets[0], EventType.B, true);
977
  assertEquals(0, l.length);
978
}
979

980

981
function testGetListener() {
982
  if (!getListener) {
983
    return;
984
  }
985

986
  listen(eventTargets[0], EventType.A, listeners[0], true);
987

988
  assertNotNull(getListener(eventTargets[0], EventType.A, listeners[0], true));
989
  assertNull(getListener(eventTargets[0], EventType.A, listeners[0], true, {}));
990
  assertNull(getListener(eventTargets[1], EventType.A, listeners[0], true));
991
  assertNull(getListener(eventTargets[0], EventType.B, listeners[0], true));
992
  assertNull(getListener(eventTargets[0], EventType.A, listeners[1], true));
993
}
994

995

996
function testHasListener() {
997
  if (!hasListener) {
998
    return;
999
  }
1000

1001
  assertFalse(hasListener(eventTargets[0]));
1002

1003
  listen(eventTargets[0], EventType.A, listeners[0], true);
1004

1005
  assertTrue(hasListener(eventTargets[0]));
1006
  assertTrue(hasListener(eventTargets[0], EventType.A));
1007
  assertTrue(hasListener(eventTargets[0], EventType.A, true));
1008
  assertTrue(hasListener(eventTargets[0], undefined, true));
1009
  assertFalse(hasListener(eventTargets[0], EventType.A, false));
1010
  assertFalse(hasListener(eventTargets[0], undefined, false));
1011
  assertFalse(hasListener(eventTargets[0], EventType.B));
1012
  assertFalse(hasListener(eventTargets[0], EventType.B, true));
1013
  assertFalse(hasListener(eventTargets[1]));
1014
}
1015

1016

1017
function testFiringEventBeforeDisposeInternalWorks() {
1018
  /**
1019
   * @extends {goog.events.EventTarget}
1020
   * @constructor
1021
   * @final
1022
   */
1023
  var MockTarget = function() { MockTarget.base(this, 'constructor'); };
1024
  goog.inherits(MockTarget, goog.events.EventTarget);
1025

1026
  MockTarget.prototype.disposeInternal = function() {
1027
    dispatchEvent(this, EventType.A);
1028
    MockTarget.base(this, 'disposeInternal');
1029
  };
1030

1031
  var t = new MockTarget();
1032
  try {
1033
    listen(t, EventType.A, listeners[0]);
1034
    t.dispose();
1035
    assertListenerIsCalled(listeners[0], times(1));
1036
  } catch (e) {
1037
    goog.dispose(t);
1038
  }
1039
}
1040

1041

1042
function testLoopDetection() {
1043
  var target = listenableFactory();
1044
  target.setParentEventTarget(target);
1045

1046
  try {
1047
    target.dispatchEvent('string');
1048
    fail('expected error');
1049
  } catch (e) {
1050
    assertContains('infinite', e.message);
1051
  }
1052
}
1053

1054