Debian Codegraph @

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

raw
1 // Copyright 2008 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 goog.provide('goog.events.KeyEventTest');
16 goog.setTestOnly('goog.events.KeyEventTest');
17
18 goog.require('goog.dom');
19 goog.require('goog.dom.TagName');
20 goog.require('goog.events');
21 goog.require('goog.events.BrowserEvent');
22 goog.require('goog.events.EventType');
23 goog.require('goog.events.KeyCodes');
24 goog.require('goog.events.KeyHandler');
25 goog.require('goog.testing.events');
26 goog.require('goog.testing.jsunit');
27 goog.require('goog.userAgent');
28
29 function setUp() {
30 // Have this based on a fictitious DOCUMENT_MODE constant.
31 goog.userAgent.isDocumentMode = function(mode) {
32 return mode <= goog.userAgent.DOCUMENT_MODE;
33 };
34 }
35
36
37 /**
38 * Tests the key handler for the IE 8 and lower behavior.
39 */
40 function testIe8StyleKeyHandling() {
41 goog.userAgent.OPERA = false;
42 goog.userAgent.IE = true;
43 goog.userAgent.GECKO = false;
44 goog.userAgent.WEBKIT = false;
45 goog.userAgent.MAC = false;
46 goog.userAgent.WINDOWS = true;
47 goog.userAgent.LINUX = false;
48 goog.userAgent.VERSION = 8;
49 goog.userAgent.DOCUMENT_MODE = 8;
50 goog.events.KeyHandler.USES_KEYDOWN_ = true;
51
52 assertIe8StyleKeyHandling();
53 }
54
55
56 /**
57 * Tests the key handler for the IE 8 and lower behavior.
58 */
59 function testIe8StyleKeyHandlingInIe9DocumentMode() {
60 goog.userAgent.OPERA = false;
61 goog.userAgent.IE = true;
62 goog.userAgent.GECKO = false;
63 goog.userAgent.WEBKIT = false;
64 goog.userAgent.MAC = false;
65 goog.userAgent.WINDOWS = true;
66 goog.userAgent.LINUX = false;
67 goog.userAgent.VERSION = 9; // Try IE9 in IE8 document mode.
68 goog.userAgent.DOCUMENT_MODE = 8;
69 goog.events.KeyHandler.USES_KEYDOWN_ = true;
70
71 assertIe8StyleKeyHandling();
72 }
73
74 function assertIe8StyleKeyHandling() {
75 var keyEvent, keyHandler = new goog.events.KeyHandler();
76 goog.events.listen(
77 keyHandler, goog.events.KeyHandler.EventType.KEY,
78 function(e) { keyEvent = e; });
79
80 fireKeyDown(keyHandler, goog.events.KeyCodes.ENTER);
81 fireKeyPress(keyHandler, goog.events.KeyCodes.ENTER);
82 assertEquals(
83 'Enter should fire a key event with the keycode 13',
84 goog.events.KeyCodes.ENTER, keyEvent.keyCode);
85 assertEquals(
86 'Enter should fire a key event with the charcode 0', 0,
87 keyEvent.charCode);
88
89 fireKeyDown(keyHandler, goog.events.KeyCodes.ESC);
90 fireKeyPress(keyHandler, goog.events.KeyCodes.ESC);
91 assertEquals(
92 'Esc should fire a key event with the keycode 27',
93 goog.events.KeyCodes.ESC, keyEvent.keyCode);
94 assertEquals(
95 'Esc should fire a key event with the charcode 0', 0, keyEvent.charCode);
96
97 fireKeyDown(keyHandler, goog.events.KeyCodes.UP);
98 assertEquals(
99 'Up should fire a key event with the keycode 38', goog.events.KeyCodes.UP,
100 keyEvent.keyCode);
101 assertEquals(
102 'Up should fire a key event with the charcode 0', 0, keyEvent.charCode);
103
104 fireKeyDown(
105 keyHandler, goog.events.KeyCodes.SEVEN, undefined, undefined, undefined,
106 undefined, true);
107 fireKeyPress(
108 keyHandler, 38, undefined, undefined, undefined, undefined, true);
109 assertEquals(
110 'Shift+7 should fire a key event with the keycode 55',
111 goog.events.KeyCodes.SEVEN, keyEvent.keyCode);
112 assertEquals(
113 'Shift+7 should fire a key event with the charcode 38', 38,
114 keyEvent.charCode);
115
116 fireKeyDown(keyHandler, goog.events.KeyCodes.A);
117 fireKeyPress(keyHandler, 97);
118 assertEquals(
119 'Lower case a should fire a key event with the keycode 65',
120 goog.events.KeyCodes.A, keyEvent.keyCode);
121 assertEquals(
122 'Lower case a should fire a key event with the charcode 97', 97,
123 keyEvent.charCode);
124
125 fireKeyDown(keyHandler, goog.events.KeyCodes.A);
126 fireKeyPress(keyHandler, 65);
127 assertEquals(
128 'Upper case A should fire a key event with the keycode 65',
129 goog.events.KeyCodes.A, keyEvent.keyCode);
130 assertEquals(
131 'Upper case A should fire a key event with the charcode 65', 65,
132 keyEvent.charCode);
133
134 fireKeyDown(keyHandler, goog.events.KeyCodes.DELETE);
135 assertEquals(
136 'Delete should fire a key event with the keycode 46',
137 goog.events.KeyCodes.DELETE, keyEvent.keyCode);
138 assertEquals(
139 'Delete should fire a key event with the charcode 0', 0,
140 keyEvent.charCode);
141
142 fireKeyDown(keyHandler, goog.events.KeyCodes.PERIOD);
143 fireKeyPress(keyHandler, 46);
144 assertEquals(
145 'Period should fire a key event with the keycode 190',
146 goog.events.KeyCodes.PERIOD, keyEvent.keyCode);
147 assertEquals(
148 'Period should fire a key event with the charcode 46', 46,
149 keyEvent.charCode);
150
151 fireKeyDown(keyHandler, goog.events.KeyCodes.CTRL);
152 fireKeyDown(keyHandler, goog.events.KeyCodes.A);
153 assertEquals(
154 'A with control down should fire a key event', goog.events.KeyCodes.A,
155 keyEvent.keyCode);
156
157 // On IE, when Ctrl+<key> is held down, there is a KEYDOWN, a KEYPRESS, and
158 // then a series of KEYDOWN events for each repeat.
159 fireKeyDown(keyHandler, goog.events.KeyCodes.B, undefined, undefined, true);
160 fireKeyPress(keyHandler, goog.events.KeyCodes.B, undefined, undefined, true);
161 assertEquals(
162 'B with control down should fire a key event', goog.events.KeyCodes.B,
163 keyEvent.keyCode);
164 assertTrue('Ctrl should be down.', keyEvent.ctrlKey);
165 assertFalse(
166 'Should not have repeat=true on the first key press.', keyEvent.repeat);
167 // Fire one repeated keydown event.
168 fireKeyDown(keyHandler, goog.events.KeyCodes.B, undefined, undefined, true);
169 assertEquals(
170 'A with control down should fire a key event', goog.events.KeyCodes.B,
171 keyEvent.keyCode);
172 assertTrue('Should have repeat=true on key repeat.', keyEvent.repeat);
173 assertTrue('Ctrl should be down.', keyEvent.ctrlKey);
174 }
175
176
177 /**
178 * Tests special cases for IE9.
179 */
180 function testIe9StyleKeyHandling() {
181 goog.userAgent.OPERA = false;
182 goog.userAgent.IE = true;
183 goog.userAgent.GECKO = false;
184 goog.userAgent.WEBKIT = false;
185 goog.userAgent.MAC = false;
186 goog.userAgent.WINDOWS = true;
187 goog.userAgent.LINUX = false;
188 goog.userAgent.VERSION = 9;
189 goog.userAgent.DOCUMENT_MODE = 9;
190 goog.events.KeyHandler.USES_KEYDOWN_ = true;
191
192 var keyEvent, keyHandler = new goog.events.KeyHandler();
193 goog.events.listen(
194 keyHandler, goog.events.KeyHandler.EventType.KEY,
195 function(e) { keyEvent = e; });
196
197 fireKeyDown(keyHandler, goog.events.KeyCodes.ENTER);
198 fireKeyPress(keyHandler, goog.events.KeyCodes.ENTER);
199 assertEquals(
200 'Enter should fire a key event with the keycode 13',
201 goog.events.KeyCodes.ENTER, keyEvent.keyCode);
202 assertEquals(
203 'Enter should fire a key event with the charcode 0', 0,
204 keyEvent.charCode);
205 }
206
207
208 /**
209 * Tests the key handler for the Gecko behavior.
210 */
211 function testGeckoStyleKeyHandling() {
212 goog.userAgent.OPERA = false;
213 goog.userAgent.IE = false;
214 goog.userAgent.GECKO = true;
215 goog.userAgent.WEBKIT = false;
216 goog.userAgent.MAC = false;
217 goog.userAgent.WINDOWS = true;
218 goog.userAgent.LINUX = false;
219 goog.events.KeyHandler.USES_KEYDOWN_ = false;
220
221 var keyEvent, keyHandler = new goog.events.KeyHandler();
222 goog.events.listen(
223 keyHandler, goog.events.KeyHandler.EventType.KEY,
224 function(e) { keyEvent = e; });
225
226 fireKeyDown(keyHandler, goog.events.KeyCodes.ENTER);
227 fireKeyPress(keyHandler, goog.events.KeyCodes.ENTER);
228 assertEquals(
229 'Enter should fire a key event with the keycode 13',
230 goog.events.KeyCodes.ENTER, keyEvent.keyCode);
231 assertEquals(
232 'Enter should fire a key event with the charcode 0', 0,
233 keyEvent.charCode);
234
235 fireKeyDown(keyHandler, goog.events.KeyCodes.ESC);
236 fireKeyPress(keyHandler, goog.events.KeyCodes.ESC);
237 assertEquals(
238 'Esc should fire a key event with the keycode 27',
239 goog.events.KeyCodes.ESC, keyEvent.keyCode);
240 assertEquals(
241 'Esc should fire a key event with the charcode 0', 0, keyEvent.charCode);
242
243 fireKeyDown(keyHandler, goog.events.KeyCodes.UP);
244 fireKeyPress(keyHandler, goog.events.KeyCodes.UP);
245 assertEquals(
246 'Up should fire a key event with the keycode 38', goog.events.KeyCodes.UP,
247 keyEvent.keyCode);
248 assertEquals(
249 'Up should fire a key event with the charcode 0', 0, keyEvent.charCode);
250
251 fireKeyDown(
252 keyHandler, goog.events.KeyCodes.SEVEN, undefined, undefined, undefined,
253 undefined, true);
254 fireKeyPress(
255 keyHandler, undefined, 38, undefined, undefined, undefined, true);
256 assertEquals(
257 'Shift+7 should fire a key event with the keycode 55',
258 goog.events.KeyCodes.SEVEN, keyEvent.keyCode);
259 assertEquals(
260 'Shift+7 should fire a key event with the charcode 38', 38,
261 keyEvent.charCode);
262
263 fireKeyDown(keyHandler, goog.events.KeyCodes.A);
264 fireKeyPress(keyHandler, undefined, 97);
265 assertEquals(
266 'Lower case a should fire a key event with the keycode 65',
267 goog.events.KeyCodes.A, keyEvent.keyCode);
268 assertEquals(
269 'Lower case a should fire a key event with the charcode 97', 97,
270 keyEvent.charCode);
271
272 fireKeyDown(keyHandler, goog.events.KeyCodes.A);
273 fireKeyPress(keyHandler, undefined, 65);
274 assertEquals(
275 'Upper case A should fire a key event with the keycode 65',
276 goog.events.KeyCodes.A, keyEvent.keyCode);
277 assertEquals(
278 'Upper case A should fire a key event with the charcode 65', 65,
279 keyEvent.charCode);
280
281 fireKeyDown(keyHandler, goog.events.KeyCodes.DELETE);
282 fireKeyPress(keyHandler, goog.events.KeyCodes.DELETE);
283 assertEquals(
284 'Delete should fire a key event with the keycode 46',
285 goog.events.KeyCodes.DELETE, keyEvent.keyCode);
286 assertEquals(
287 'Delete should fire a key event with the charcode 0', 0,
288 keyEvent.charCode);
289
290 fireKeyDown(keyHandler, goog.events.KeyCodes.PERIOD);
291 fireKeyPress(keyHandler, undefined, 46);
292 assertEquals(
293 'Period should fire a key event with the keycode 190',
294 goog.events.KeyCodes.PERIOD, keyEvent.keyCode);
295 assertEquals(
296 'Period should fire a key event with the charcode 46', 46,
297 keyEvent.charCode);
298 }
299
300
301 /**
302 * Tests the key handler for the Safari 3 behavior.
303 */
304 function testSafari3StyleKeyHandling() {
305 goog.userAgent.OPERA = false;
306 goog.userAgent.IE = false;
307 goog.userAgent.GECKO = false;
308 goog.userAgent.WEBKIT = true;
309 goog.userAgent.MAC = true;
310 goog.userAgent.WINDOWS = false;
311 goog.userAgent.LINUX = false;
312 goog.events.KeyHandler.USES_KEYDOWN_ = true;
313 goog.userAgent.VERSION = 525.3;
314
315 var keyEvent, keyHandler = new goog.events.KeyHandler();
316 // Make sure all events are caught while testing
317 goog.events.listen(
318 keyHandler, goog.events.KeyHandler.EventType.KEY,
319 function(e) { keyEvent = e; });
320
321 fireKeyDown(keyHandler, goog.events.KeyCodes.ENTER);
322 fireKeyPress(keyHandler, goog.events.KeyCodes.ENTER);
323 assertEquals(
324 'Enter should fire a key event with the keycode 13',
325 goog.events.KeyCodes.ENTER, keyEvent.keyCode);
326 assertEquals(
327 'Enter should fire a key event with the charcode 0', 0,
328 keyEvent.charCode);
329 fireKeyUp(keyHandler, goog.events.KeyCodes.ENTER);
330
331 // Add a listener to ensure that an extra ENTER event is not dispatched
332 // by a subsequent keypress.
333 var enterCheck = goog.events.listen(
334 keyHandler, goog.events.KeyHandler.EventType.KEY, function(e) {
335 assertNotEquals(
336 'Unexpected ENTER keypress dispatched', e.keyCode,
337 goog.events.KeyCodes.ENTER);
338 });
339
340 fireKeyDown(keyHandler, goog.events.KeyCodes.ESC);
341 assertEquals(
342 'Esc should fire a key event with the keycode 27',
343 goog.events.KeyCodes.ESC, keyEvent.keyCode);
344 assertEquals(
345 'Esc should fire a key event with the charcode 0', 0, keyEvent.charCode);
346 fireKeyPress(keyHandler, goog.events.KeyCodes.ESC);
347 goog.events.unlistenByKey(enterCheck);
348
349 fireKeyDown(keyHandler, goog.events.KeyCodes.UP);
350 assertEquals(
351 'Up should fire a key event with the keycode 38', goog.events.KeyCodes.UP,
352 keyEvent.keyCode);
353 assertEquals(
354 'Up should fire a key event with the charcode 0', 0, keyEvent.charCode);
355
356 fireKeyDown(
357 keyHandler, goog.events.KeyCodes.SEVEN, undefined, undefined, undefined,
358 undefined, true);
359 fireKeyPress(keyHandler, 38, 38, undefined, undefined, undefined, true);
360 assertEquals(
361 'Shift+7 should fire a key event with the keycode 55',
362 goog.events.KeyCodes.SEVEN, keyEvent.keyCode);
363 assertEquals(
364 'Shift+7 should fire a key event with the charcode 38', 38,
365 keyEvent.charCode);
366
367 fireKeyDown(keyHandler, goog.events.KeyCodes.A);
368 fireKeyPress(keyHandler, 97, 97);
369 assertEquals(
370 'Lower case a should fire a key event with the keycode 65',
371 goog.events.KeyCodes.A, keyEvent.keyCode);
372 assertEquals(
373 'Lower case a should fire a key event with the charcode 97', 97,
374 keyEvent.charCode);
375
376 fireKeyDown(keyHandler, goog.events.KeyCodes.A);
377 fireKeyPress(keyHandler, 65, 65);
378 assertEquals(
379 'Upper case A should fire a key event with the keycode 65',
380 goog.events.KeyCodes.A, keyEvent.keyCode);
381 assertEquals(
382 'Upper case A should fire a key event with the charcode 65', 65,
383 keyEvent.charCode);
384
385 fireKeyDown(keyHandler, goog.events.KeyCodes.CTRL);
386 fireKeyDown(keyHandler, goog.events.KeyCodes.A, null, null, true /*ctrl*/);
387 assertEquals(
388 'A with control down should fire a key event', goog.events.KeyCodes.A,
389 keyEvent.keyCode);
390
391 // Test that Alt-Tab outside the window doesn't break things.
392 fireKeyDown(keyHandler, goog.events.KeyCodes.ALT);
393 keyEvent.keyCode = -1; // Reset the event.
394 fireKeyDown(keyHandler, goog.events.KeyCodes.A);
395 assertEquals('Should not have dispatched an Alt-A', -1, keyEvent.keyCode);
396 fireKeyPress(keyHandler, 65, 65);
397 assertEquals(
398 'Alt should be ignored since it isn\'t currently depressed',
399 goog.events.KeyCodes.A, keyEvent.keyCode);
400
401 fireKeyDown(keyHandler, goog.events.KeyCodes.DELETE);
402 assertEquals(
403 'Delete should fire a key event with the keycode 46',
404 goog.events.KeyCodes.DELETE, keyEvent.keyCode);
405 assertEquals(
406 'Delete should fire a key event with the charcode 0', 0,
407 keyEvent.charCode);
408
409 fireKeyDown(keyHandler, goog.events.KeyCodes.PERIOD);
410 fireKeyPress(keyHandler, 46, 46);
411 assertEquals(
412 'Period should fire a key event with the keycode 190',
413 goog.events.KeyCodes.PERIOD, keyEvent.keyCode);
414 assertEquals(
415 'Period should fire a key event with the charcode 46', 46,
416 keyEvent.charCode);
417
418 // Safari sends zero key code for non-latin characters.
419 fireKeyDown(keyHandler, 0, 0);
420 fireKeyPress(keyHandler, 1092, 1092);
421 assertEquals(
422 'Cyrillic small letter "Ef" should fire a key event with ' +
423 'the keycode 0',
424 0, keyEvent.keyCode);
425 assertEquals(
426 'Cyrillic small letter "Ef" should fire a key event with ' +
427 'the charcode 1092',
428 1092, keyEvent.charCode);
429 }
430
431
432 /**
433 * Tests the key handler for the Opera behavior.
434 */
435 function testOperaStyleKeyHandling() {
436 goog.userAgent.OPERA = true;
437 goog.userAgent.IE = false;
438 goog.userAgent.GECKO = false;
439 goog.userAgent.WEBKIT = false;
440 goog.userAgent.MAC = false;
441 goog.userAgent.WINDOWS = true;
442 goog.userAgent.LINUX = false;
443 goog.events.KeyHandler.USES_KEYDOWN_ = false;
444
445 var keyEvent, keyHandler = new goog.events.KeyHandler();
446 goog.events.listen(
447 keyHandler, goog.events.KeyHandler.EventType.KEY,
448 function(e) { keyEvent = e; });
449
450 fireKeyDown(keyHandler, goog.events.KeyCodes.ENTER);
451 fireKeyPress(keyHandler, goog.events.KeyCodes.ENTER);
452 assertEquals(
453 'Enter should fire a key event with the keycode 13',
454 goog.events.KeyCodes.ENTER, keyEvent.keyCode);
455 assertEquals(
456 'Enter should fire a key event with the charcode 0', 0,
457 keyEvent.charCode);
458
459 fireKeyDown(keyHandler, goog.events.KeyCodes.ESC);
460 fireKeyPress(keyHandler, goog.events.KeyCodes.ESC);
461 assertEquals(
462 'Esc should fire a key event with the keycode 27',
463 goog.events.KeyCodes.ESC, keyEvent.keyCode);
464 assertEquals(
465 'Esc should fire a key event with the charcode 0', 0, keyEvent.charCode);
466
467 fireKeyDown(keyHandler, goog.events.KeyCodes.UP);
468 fireKeyPress(keyHandler, goog.events.KeyCodes.UP);
469 assertEquals(
470 'Up should fire a key event with the keycode 38', goog.events.KeyCodes.UP,
471 keyEvent.keyCode);
472 assertEquals(
473 'Up should fire a key event with the charcode 0', 0, keyEvent.charCode);
474
475 fireKeyDown(
476 keyHandler, goog.events.KeyCodes.SEVEN, undefined, undefined, undefined,
477 undefined, true);
478 fireKeyPress(
479 keyHandler, 38, undefined, undefined, undefined, undefined, true);
480 assertEquals(
481 'Shift+7 should fire a key event with the keycode 55',
482 goog.events.KeyCodes.SEVEN, keyEvent.keyCode);
483 assertEquals(
484 'Shift+7 should fire a key event with the charcode 38', 38,
485 keyEvent.charCode);
486
487 fireKeyDown(keyHandler, goog.events.KeyCodes.A);
488 fireKeyPress(keyHandler, 97);
489 assertEquals(
490 'Lower case a should fire a key event with the keycode 65',
491 goog.events.KeyCodes.A, keyEvent.keyCode);
492 assertEquals(
493 'Lower case a should fire a key event with the charcode 97', 97,
494 keyEvent.charCode);
495
496 fireKeyDown(keyHandler, goog.events.KeyCodes.A);
497 fireKeyPress(keyHandler, 65);
498 assertEquals(
499 'Upper case A should fire a key event with the keycode 65',
500 goog.events.KeyCodes.A, keyEvent.keyCode);
501 assertEquals(
502 'Upper case A should fire a key event with the charcode 65', 65,
503 keyEvent.charCode);
504
505 fireKeyDown(keyHandler, goog.events.KeyCodes.DELETE);
506 fireKeyPress(keyHandler, goog.events.KeyCodes.DELETE);
507 assertEquals(
508 'Delete should fire a key event with the keycode 46',
509 goog.events.KeyCodes.DELETE, keyEvent.keyCode);
510 assertEquals(
511 'Delete should fire a key event with the charcode 0', 0,
512 keyEvent.charCode);
513
514 fireKeyDown(keyHandler, goog.events.KeyCodes.PERIOD);
515 fireKeyPress(keyHandler, 46);
516 assertEquals(
517 'Period should fire a key event with the keycode 190',
518 goog.events.KeyCodes.PERIOD, keyEvent.keyCode);
519 assertEquals(
520 'Period should fire a key event with the charcode 46', 46,
521 keyEvent.charCode);
522 }
523
524 function testGeckoOnMacAltHandling() {
525 goog.userAgent.OPERA = false;
526 goog.userAgent.IE = false;
527 goog.userAgent.GECKO = true;
528 goog.userAgent.WEBKIT = false;
529 goog.userAgent.MAC = true;
530 goog.userAgent.WINDOWS = false;
531 goog.userAgent.LINUX = false;
532 goog.userAgent.EDGE = false;
533 goog.events.KeyHandler.SAVE_ALT_FOR_KEYPRESS_ = true;
534
535 var keyEvent, keyHandler = new goog.events.KeyHandler();
536 goog.events.listen(
537 keyHandler, goog.events.KeyHandler.EventType.KEY,
538 function(e) { keyEvent = e; });
539
540 fireKeyDown(
541 keyHandler, goog.events.KeyCodes.COMMA, 0, null, false, true, false);
542 fireKeyPress(keyHandler, 0, 8804, null, false, false, false);
543 assertEquals(
544 'should fire a key event with COMMA', goog.events.KeyCodes.COMMA,
545 keyEvent.keyCode);
546 assertEquals(
547 'should fire a key event with alt key set', true, keyEvent.altKey);
548
549 // Scenario: alt down, a down, a press, a up (should say alt is true),
550 // alt up.
551 keyEvent = undefined;
552 fireKeyDown(keyHandler, 18, 0, null, false, true, false);
553 fireKeyDown(keyHandler, goog.events.KeyCodes.A, 0, null, false, true, false);
554 fireKeyPress(keyHandler, 0, 229, null, false, false, false);
555 assertEquals(
556 'should fire a key event with alt key set', true, keyEvent.altKey);
557 fireKeyUp(keyHandler, 0, 229, null, false, true, false);
558 assertEquals('alt key should still be set', true, keyEvent.altKey);
559 fireKeyUp(keyHandler, 18, 0, null, false, false, false);
560 }
561
562 function testGeckoEqualSign() {
563 goog.userAgent.OPERA = false;
564 goog.userAgent.IE = false;
565 goog.userAgent.GECKO = true;
566 goog.userAgent.WEBKIT = false;
567 goog.userAgent.MAC = false;
568 goog.userAgent.WINDOWS = true;
569 goog.userAgent.LINUX = false;
570 goog.events.KeyHandler.USES_KEYDOWN_ = false;
571
572 var keyEvent, keyHandler = new goog.events.KeyHandler();
573 goog.events.listen(
574 keyHandler, goog.events.KeyHandler.EventType.KEY,
575 function(e) { keyEvent = e; });
576
577 fireKeyDown(keyHandler, 61, 0);
578 fireKeyPress(keyHandler, 0, 61);
579 assertEquals(
580 '= should fire should fire a key event with the keyCode 187',
581 goog.events.KeyCodes.EQUALS, keyEvent.keyCode);
582 assertEquals(
583 '= should fire a key event with the charCode 61',
584 goog.events.KeyCodes.FF_EQUALS, keyEvent.charCode);
585 }
586
587 function testMacGeckoSlash() {
588 goog.userAgent.OPERA = false;
589 goog.userAgent.IE = false;
590 goog.userAgent.GECKO = true;
591 goog.userAgent.WEBKIT = false;
592 goog.userAgent.MAC = true;
593 goog.userAgent.WINDOWS = false;
594 goog.userAgent.LINUX = false;
595 goog.events.KeyHandler.USES_KEYDOWN_ = false;
596
597 var keyEvent, keyHandler = new goog.events.KeyHandler();
598 goog.events.listen(
599 keyHandler, goog.events.KeyHandler.EventType.KEY,
600 function(e) { keyEvent = e; });
601
602 fireKeyDown(keyHandler, 0, 63, null, false, false, true);
603 fireKeyPress(keyHandler, 0, 63, null, false, false, true);
604 assertEquals(
605 '/ should fire a key event with the keyCode 191',
606 goog.events.KeyCodes.SLASH, keyEvent.keyCode);
607 assertEquals(
608 '? should fire a key event with the charCode 63',
609 goog.events.KeyCodes.QUESTION_MARK, keyEvent.charCode);
610 }
611
612 function testGetElement() {
613 var target = goog.dom.createDom(goog.dom.TagName.DIV);
614 var target2 = goog.dom.createDom(goog.dom.TagName.DIV);
615 var keyHandler = new goog.events.KeyHandler();
616 assertNull(keyHandler.getElement());
617
618 keyHandler.attach(target);
619 assertEquals(target, keyHandler.getElement());
620
621 keyHandler.attach(target2);
622 assertNotEquals(target, keyHandler.getElement());
623 assertEquals(target2, keyHandler.getElement());
624
625 var doc = goog.dom.getDocument();
626 keyHandler.attach(doc);
627 assertEquals(doc, keyHandler.getElement());
628
629 keyHandler = new goog.events.KeyHandler(doc);
630 assertEquals(doc, keyHandler.getElement());
631
632 keyHandler = new goog.events.KeyHandler(target);
633 assertEquals(target, keyHandler.getElement());
634 }
635
636 function testDetach() {
637 var target = goog.dom.createDom(goog.dom.TagName.DIV);
638 var keyHandler = new goog.events.KeyHandler(target);
639 assertEquals(target, keyHandler.getElement());
640
641 fireKeyDown(keyHandler, 0, 63, null, false, false, true);
642 fireKeyPress(keyHandler, 0, 63, null, false, false, true);
643 keyHandler.detach();
644
645 assertNull(keyHandler.getElement());
646 // All listeners should be cleared.
647 assertNull(keyHandler.keyDownKey_);
648 assertNull(keyHandler.keyPressKey_);
649 assertNull(keyHandler.keyUpKey_);
650 // All key related state should be cleared.
651 assertEquals('Last key should be -1', -1, keyHandler.lastKey_);
652 assertEquals('keycode should be -1', -1, keyHandler.keyCode_);
653 }
654
655 function testCapturePhase() {
656 var gotInCapturePhase;
657 var gotInBubblePhase;
658
659 var target = goog.dom.createDom(goog.dom.TagName.DIV);
660 goog.events.listen(
661 new goog.events.KeyHandler(target, false /* bubble */),
662 goog.events.KeyHandler.EventType.KEY, function() {
663 gotInBubblePhase = true;
664 assertTrue(gotInCapturePhase);
665 });
666 goog.events.listen(
667 new goog.events.KeyHandler(target, true /* capture */),
668 goog.events.KeyHandler.EventType.KEY,
669 function() { gotInCapturePhase = true; });
670
671 goog.testing.events.fireKeySequence(target, goog.events.KeyCodes.ESC);
672 assertTrue(gotInBubblePhase);
673 }
674
675 function fireKeyDown(
676 keyHandler, keyCode, opt_charCode, opt_keyIdentifier, opt_ctrlKey,
677 opt_altKey, opt_shiftKey) {
678 var fakeEvent = createFakeKeyEvent(
679 goog.events.EventType.KEYDOWN, keyCode, opt_charCode, opt_keyIdentifier,
680 opt_ctrlKey, opt_altKey, opt_shiftKey);
681 keyHandler.handleKeyDown_(fakeEvent);
682 return fakeEvent.returnValue_;
683 }
684
685 function fireKeyPress(
686 keyHandler, keyCode, opt_charCode, opt_keyIdentifier, opt_ctrlKey,
687 opt_altKey, opt_shiftKey) {
688 var fakeEvent = createFakeKeyEvent(
689 goog.events.EventType.KEYPRESS, keyCode, opt_charCode, opt_keyIdentifier,
690 opt_ctrlKey, opt_altKey, opt_shiftKey);
691 keyHandler.handleEvent(fakeEvent);
692 return fakeEvent.returnValue_;
693 }
694
695 function fireKeyUp(
696 keyHandler, keyCode, opt_charCode, opt_keyIdentifier, opt_ctrlKey,
697 opt_altKey, opt_shiftKey) {
698 var fakeEvent = createFakeKeyEvent(
699 goog.events.EventType.KEYUP, keyCode, opt_charCode, opt_keyIdentifier,
700 opt_ctrlKey, opt_altKey, opt_shiftKey);
701 keyHandler.handleKeyup_(fakeEvent);
702 return fakeEvent.returnValue_;
703 }
704
705 function createFakeKeyEvent(
706 type, keyCode, opt_charCode, opt_keyIdentifier, opt_ctrlKey, opt_altKey,
707 opt_shiftKey) {
708 var event = {
709 type: type,
710 keyCode: keyCode,
711 charCode: opt_charCode || undefined,
712 keyIdentifier: opt_keyIdentifier || undefined,
713 ctrlKey: opt_ctrlKey || false,
714 altKey: opt_altKey || false,
715 shiftKey: opt_shiftKey || false,
716 timeStamp: goog.now()
717 };
718 return new goog.events.BrowserEvent(event);
719 }