Debian Codegraph @

closure-library/closure/goog/events/eventtargettester.js

raw
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 }