| // Copyright 2008 The Closure Library Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS-IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| goog.provide('goog.events.KeyEventTest'); |
| goog.setTestOnly('goog.events.KeyEventTest'); |
| |
| goog.require('goog.dom'); |
| goog.require('goog.events'); |
| goog.require('goog.events.BrowserEvent'); |
| goog.require('goog.events.EventType'); |
| goog.require('goog.events.KeyCodes'); |
| goog.require('goog.events.KeyHandler'); |
| goog.require('goog.testing.events'); |
| goog.require('goog.testing.jsunit'); |
| goog.require('goog.userAgent'); |
| |
| function setUp() { |
| // Have this based on a fictitious DOCUMENT_MODE constant. |
| goog.userAgent.isDocumentMode = function(mode) { |
| return mode <= goog.userAgent.DOCUMENT_MODE; |
| }; |
| } |
| |
| |
| /** |
| * Tests the key handler for the IE 8 and lower behavior. |
| */ |
| function testIe8StyleKeyHandling() { |
| goog.userAgent.OPERA = false; |
| goog.userAgent.IE = true; |
| goog.userAgent.GECKO = false; |
| goog.userAgent.WEBKIT = false; |
| goog.userAgent.MAC = false; |
| goog.userAgent.WINDOWS = true; |
| goog.userAgent.LINUX = false; |
| goog.userAgent.VERSION = 8; |
| goog.userAgent.DOCUMENT_MODE = 8; |
| goog.events.KeyHandler.USES_KEYDOWN_ = true; |
| |
| assertIe8StyleKeyHandling(); |
| } |
| |
| |
| /** |
| * Tests the key handler for the IE 8 and lower behavior. |
| */ |
| function testIe8StyleKeyHandlingInIe9DocumentMode() { |
| goog.userAgent.OPERA = false; |
| goog.userAgent.IE = true; |
| goog.userAgent.GECKO = false; |
| goog.userAgent.WEBKIT = false; |
| goog.userAgent.MAC = false; |
| goog.userAgent.WINDOWS = true; |
| goog.userAgent.LINUX = false; |
| goog.userAgent.VERSION = 9; // Try IE9 in IE8 document mode. |
| goog.userAgent.DOCUMENT_MODE = 8; |
| goog.events.KeyHandler.USES_KEYDOWN_ = true; |
| |
| assertIe8StyleKeyHandling(); |
| } |
| |
| function assertIe8StyleKeyHandling() { |
| var keyEvent, keyHandler = new goog.events.KeyHandler(); |
| goog.events.listen(keyHandler, goog.events.KeyHandler.EventType.KEY, |
| function(e) { keyEvent = e; }); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.ENTER); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.ENTER); |
| assertEquals('Enter should fire a key event with the keycode 13', |
| goog.events.KeyCodes.ENTER, |
| keyEvent.keyCode); |
| assertEquals('Enter should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.ESC); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.ESC); |
| assertEquals('Esc should fire a key event with the keycode 27', |
| goog.events.KeyCodes.ESC, |
| keyEvent.keyCode); |
| assertEquals('Esc should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.UP); |
| assertEquals('Up should fire a key event with the keycode 38', |
| goog.events.KeyCodes.UP, |
| keyEvent.keyCode); |
| assertEquals('Up should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.SEVEN, undefined, undefined, |
| undefined, undefined, true); |
| fireKeyPress(keyHandler, 38, undefined, undefined, undefined, undefined, |
| true); |
| assertEquals('Shift+7 should fire a key event with the keycode 55', |
| goog.events.KeyCodes.SEVEN, |
| keyEvent.keyCode); |
| assertEquals('Shift+7 should fire a key event with the charcode 38', |
| 38, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.A); |
| fireKeyPress(keyHandler, 97); |
| assertEquals('Lower case a should fire a key event with the keycode 65', |
| goog.events.KeyCodes.A, |
| keyEvent.keyCode); |
| assertEquals('Lower case a should fire a key event with the charcode 97', |
| 97, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.A); |
| fireKeyPress(keyHandler, 65); |
| assertEquals('Upper case A should fire a key event with the keycode 65', |
| goog.events.KeyCodes.A, |
| keyEvent.keyCode); |
| assertEquals('Upper case A should fire a key event with the charcode 65', |
| 65, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.DELETE); |
| assertEquals('Delete should fire a key event with the keycode 46', |
| goog.events.KeyCodes.DELETE, |
| keyEvent.keyCode); |
| assertEquals('Delete should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.PERIOD); |
| fireKeyPress(keyHandler, 46); |
| assertEquals('Period should fire a key event with the keycode 190', |
| goog.events.KeyCodes.PERIOD, |
| keyEvent.keyCode); |
| assertEquals('Period should fire a key event with the charcode 46', |
| 46, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.CTRL); |
| fireKeyDown(keyHandler, goog.events.KeyCodes.A); |
| assertEquals('A with control down should fire a key event', |
| goog.events.KeyCodes.A, |
| keyEvent.keyCode); |
| |
| // On IE, when Ctrl+<key> is held down, there is a KEYDOWN, a KEYPRESS, and |
| // then a series of KEYDOWN events for each repeat. |
| fireKeyDown(keyHandler, goog.events.KeyCodes.B, undefined, undefined, true); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.B, undefined, undefined, |
| true); |
| assertEquals('B with control down should fire a key event', |
| goog.events.KeyCodes.B, |
| keyEvent.keyCode); |
| assertTrue('Ctrl should be down.', keyEvent.ctrlKey); |
| assertFalse('Should not have repeat=true on the first key press.', |
| keyEvent.repeat); |
| // Fire one repeated keydown event. |
| fireKeyDown(keyHandler, goog.events.KeyCodes.B, undefined, undefined, true); |
| assertEquals('A with control down should fire a key event', |
| goog.events.KeyCodes.B, |
| keyEvent.keyCode); |
| assertTrue('Should have repeat=true on key repeat.', |
| keyEvent.repeat); |
| assertTrue('Ctrl should be down.', keyEvent.ctrlKey); |
| } |
| |
| |
| /** |
| * Tests special cases for IE9. |
| */ |
| function testIe9StyleKeyHandling() { |
| goog.userAgent.OPERA = false; |
| goog.userAgent.IE = true; |
| goog.userAgent.GECKO = false; |
| goog.userAgent.WEBKIT = false; |
| goog.userAgent.MAC = false; |
| goog.userAgent.WINDOWS = true; |
| goog.userAgent.LINUX = false; |
| goog.userAgent.VERSION = 9; |
| goog.userAgent.DOCUMENT_MODE = 9; |
| goog.events.KeyHandler.USES_KEYDOWN_ = true; |
| |
| var keyEvent, keyHandler = new goog.events.KeyHandler(); |
| goog.events.listen(keyHandler, goog.events.KeyHandler.EventType.KEY, |
| function(e) { keyEvent = e; }); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.ENTER); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.ENTER); |
| assertEquals('Enter should fire a key event with the keycode 13', |
| goog.events.KeyCodes.ENTER, |
| keyEvent.keyCode); |
| assertEquals('Enter should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| } |
| |
| |
| /** |
| * Tests the key handler for the Gecko behavior. |
| */ |
| function testGeckoStyleKeyHandling() { |
| goog.userAgent.OPERA = false; |
| goog.userAgent.IE = false; |
| goog.userAgent.GECKO = true; |
| goog.userAgent.WEBKIT = false; |
| goog.userAgent.MAC = false; |
| goog.userAgent.WINDOWS = true; |
| goog.userAgent.LINUX = false; |
| goog.events.KeyHandler.USES_KEYDOWN_ = false; |
| |
| var keyEvent, keyHandler = new goog.events.KeyHandler(); |
| goog.events.listen(keyHandler, goog.events.KeyHandler.EventType.KEY, |
| function(e) { keyEvent = e; }); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.ENTER); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.ENTER); |
| assertEquals('Enter should fire a key event with the keycode 13', |
| goog.events.KeyCodes.ENTER, |
| keyEvent.keyCode); |
| assertEquals('Enter should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.ESC); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.ESC); |
| assertEquals('Esc should fire a key event with the keycode 27', |
| goog.events.KeyCodes.ESC, |
| keyEvent.keyCode); |
| assertEquals('Esc should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.UP); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.UP); |
| assertEquals('Up should fire a key event with the keycode 38', |
| goog.events.KeyCodes.UP, |
| keyEvent.keyCode); |
| assertEquals('Up should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.SEVEN, undefined, undefined, |
| undefined, undefined, true); |
| fireKeyPress(keyHandler, undefined, 38, undefined, undefined, undefined, |
| true); |
| assertEquals('Shift+7 should fire a key event with the keycode 55', |
| goog.events.KeyCodes.SEVEN, |
| keyEvent.keyCode); |
| assertEquals('Shift+7 should fire a key event with the charcode 38', |
| 38, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.A); |
| fireKeyPress(keyHandler, undefined, 97); |
| assertEquals('Lower case a should fire a key event with the keycode 65', |
| goog.events.KeyCodes.A, |
| keyEvent.keyCode); |
| assertEquals('Lower case a should fire a key event with the charcode 97', |
| 97, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.A); |
| fireKeyPress(keyHandler, undefined, 65); |
| assertEquals('Upper case A should fire a key event with the keycode 65', |
| goog.events.KeyCodes.A, |
| keyEvent.keyCode); |
| assertEquals('Upper case A should fire a key event with the charcode 65', |
| 65, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.DELETE); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.DELETE); |
| assertEquals('Delete should fire a key event with the keycode 46', |
| goog.events.KeyCodes.DELETE, |
| keyEvent.keyCode); |
| assertEquals('Delete should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.PERIOD); |
| fireKeyPress(keyHandler, undefined, 46); |
| assertEquals('Period should fire a key event with the keycode 190', |
| goog.events.KeyCodes.PERIOD, |
| keyEvent.keyCode); |
| assertEquals('Period should fire a key event with the charcode 46', |
| 46, |
| keyEvent.charCode); |
| } |
| |
| |
| /** |
| * Tests the key handler for the Safari 3 behavior. |
| */ |
| function testSafari3StyleKeyHandling() { |
| goog.userAgent.OPERA = false; |
| goog.userAgent.IE = false; |
| goog.userAgent.GECKO = false; |
| goog.userAgent.WEBKIT = true; |
| goog.userAgent.MAC = true; |
| goog.userAgent.WINDOWS = false; |
| goog.userAgent.LINUX = false; |
| goog.events.KeyHandler.USES_KEYDOWN_ = true; |
| goog.userAgent.VERSION = 525.3; |
| |
| var keyEvent, keyHandler = new goog.events.KeyHandler(); |
| // Make sure all events are caught while testing |
| goog.events.listen(keyHandler, goog.events.KeyHandler.EventType.KEY, |
| function(e) { keyEvent = e; }); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.ENTER); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.ENTER); |
| assertEquals('Enter should fire a key event with the keycode 13', |
| goog.events.KeyCodes.ENTER, |
| keyEvent.keyCode); |
| assertEquals('Enter should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| fireKeyUp(keyHandler, goog.events.KeyCodes.ENTER); |
| |
| // Add a listener to ensure that an extra ENTER event is not dispatched |
| // by a subsequent keypress. |
| var enterCheck = goog.events.listen(keyHandler, |
| goog.events.KeyHandler.EventType.KEY, |
| function(e) { |
| assertNotEquals('Unexpected ENTER keypress dispatched', |
| e.keyCode, goog.events.KeyCodes.ENTER); |
| }); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.ESC); |
| assertEquals('Esc should fire a key event with the keycode 27', |
| goog.events.KeyCodes.ESC, |
| keyEvent.keyCode); |
| assertEquals('Esc should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.ESC); |
| goog.events.unlistenByKey(enterCheck); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.UP); |
| assertEquals('Up should fire a key event with the keycode 38', |
| goog.events.KeyCodes.UP, |
| keyEvent.keyCode); |
| assertEquals('Up should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.SEVEN, undefined, undefined, |
| undefined, undefined, true); |
| fireKeyPress(keyHandler, 38, 38, undefined, undefined, undefined, true); |
| assertEquals('Shift+7 should fire a key event with the keycode 55', |
| goog.events.KeyCodes.SEVEN, |
| keyEvent.keyCode); |
| assertEquals('Shift+7 should fire a key event with the charcode 38', |
| 38, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.A); |
| fireKeyPress(keyHandler, 97, 97); |
| assertEquals('Lower case a should fire a key event with the keycode 65', |
| goog.events.KeyCodes.A, |
| keyEvent.keyCode); |
| assertEquals('Lower case a should fire a key event with the charcode 97', |
| 97, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.A); |
| fireKeyPress(keyHandler, 65, 65); |
| assertEquals('Upper case A should fire a key event with the keycode 65', |
| goog.events.KeyCodes.A, |
| keyEvent.keyCode); |
| assertEquals('Upper case A should fire a key event with the charcode 65', |
| 65, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.CTRL); |
| fireKeyDown(keyHandler, goog.events.KeyCodes.A, null, null, true /*ctrl*/); |
| assertEquals('A with control down should fire a key event', |
| goog.events.KeyCodes.A, |
| keyEvent.keyCode); |
| |
| // Test that Alt-Tab outside the window doesn't break things. |
| fireKeyDown(keyHandler, goog.events.KeyCodes.ALT); |
| keyEvent.keyCode = -1; // Reset the event. |
| fireKeyDown(keyHandler, goog.events.KeyCodes.A); |
| assertEquals('Should not have dispatched an Alt-A', -1, keyEvent.keyCode); |
| fireKeyPress(keyHandler, 65, 65); |
| assertEquals('Alt should be ignored since it isn\'t currently depressed', |
| goog.events.KeyCodes.A, |
| keyEvent.keyCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.DELETE); |
| assertEquals('Delete should fire a key event with the keycode 46', |
| goog.events.KeyCodes.DELETE, |
| keyEvent.keyCode); |
| assertEquals('Delete should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.PERIOD); |
| fireKeyPress(keyHandler, 46, 46); |
| assertEquals('Period should fire a key event with the keycode 190', |
| goog.events.KeyCodes.PERIOD, |
| keyEvent.keyCode); |
| assertEquals('Period should fire a key event with the charcode 46', |
| 46, |
| keyEvent.charCode); |
| |
| // Safari sends zero key code for non-latin characters. |
| fireKeyDown(keyHandler, 0, 0); |
| fireKeyPress(keyHandler, 1092, 1092); |
| assertEquals('Cyrillic small letter "Ef" should fire a key event with ' + |
| 'the keycode 0', |
| 0, |
| keyEvent.keyCode); |
| assertEquals('Cyrillic small letter "Ef" should fire a key event with ' + |
| 'the charcode 1092', |
| 1092, |
| keyEvent.charCode); |
| } |
| |
| |
| /** |
| * Tests the key handler for the Opera behavior. |
| */ |
| function testOperaStyleKeyHandling() { |
| goog.userAgent.OPERA = true; |
| goog.userAgent.IE = false; |
| goog.userAgent.GECKO = false; |
| goog.userAgent.WEBKIT = false; |
| goog.userAgent.MAC = false; |
| goog.userAgent.WINDOWS = true; |
| goog.userAgent.LINUX = false; |
| goog.events.KeyHandler.USES_KEYDOWN_ = false; |
| |
| var keyEvent, keyHandler = new goog.events.KeyHandler(); |
| goog.events.listen(keyHandler, goog.events.KeyHandler.EventType.KEY, |
| function(e) { keyEvent = e; }); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.ENTER); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.ENTER); |
| assertEquals('Enter should fire a key event with the keycode 13', |
| goog.events.KeyCodes.ENTER, |
| keyEvent.keyCode); |
| assertEquals('Enter should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.ESC); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.ESC); |
| assertEquals('Esc should fire a key event with the keycode 27', |
| goog.events.KeyCodes.ESC, |
| keyEvent.keyCode); |
| assertEquals('Esc should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.UP); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.UP); |
| assertEquals('Up should fire a key event with the keycode 38', |
| goog.events.KeyCodes.UP, |
| keyEvent.keyCode); |
| assertEquals('Up should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.SEVEN, undefined, undefined, |
| undefined, undefined, true); |
| fireKeyPress(keyHandler, 38, undefined, undefined, undefined, undefined, |
| true); |
| assertEquals('Shift+7 should fire a key event with the keycode 55', |
| goog.events.KeyCodes.SEVEN, |
| keyEvent.keyCode); |
| assertEquals('Shift+7 should fire a key event with the charcode 38', |
| 38, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.A); |
| fireKeyPress(keyHandler, 97); |
| assertEquals('Lower case a should fire a key event with the keycode 65', |
| goog.events.KeyCodes.A, |
| keyEvent.keyCode); |
| assertEquals('Lower case a should fire a key event with the charcode 97', |
| 97, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.A); |
| fireKeyPress(keyHandler, 65); |
| assertEquals('Upper case A should fire a key event with the keycode 65', |
| goog.events.KeyCodes.A, |
| keyEvent.keyCode); |
| assertEquals('Upper case A should fire a key event with the charcode 65', |
| 65, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.DELETE); |
| fireKeyPress(keyHandler, goog.events.KeyCodes.DELETE); |
| assertEquals('Delete should fire a key event with the keycode 46', |
| goog.events.KeyCodes.DELETE, |
| keyEvent.keyCode); |
| assertEquals('Delete should fire a key event with the charcode 0', |
| 0, |
| keyEvent.charCode); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.PERIOD); |
| fireKeyPress(keyHandler, 46); |
| assertEquals('Period should fire a key event with the keycode 190', |
| goog.events.KeyCodes.PERIOD, |
| keyEvent.keyCode); |
| assertEquals('Period should fire a key event with the charcode 46', |
| 46, |
| keyEvent.charCode); |
| } |
| |
| function testGeckoOnMacAltHandling() { |
| goog.userAgent.OPERA = false; |
| goog.userAgent.IE = false; |
| goog.userAgent.GECKO = true; |
| goog.userAgent.WEBKIT = false; |
| goog.userAgent.MAC = true; |
| goog.userAgent.WINDOWS = false; |
| goog.userAgent.LINUX = false; |
| goog.events.KeyHandler.SAVE_ALT_FOR_KEYPRESS_ = true; |
| |
| var keyEvent, keyHandler = new goog.events.KeyHandler(); |
| goog.events.listen(keyHandler, goog.events.KeyHandler.EventType.KEY, |
| function(e) { keyEvent = e; }); |
| |
| fireKeyDown(keyHandler, goog.events.KeyCodes.COMMA, 0, null, false, |
| true, false); |
| fireKeyPress(keyHandler, 0, 8804, null, false, false, false); |
| assertEquals('should fire a key event with COMMA', |
| goog.events.KeyCodes.COMMA, |
| keyEvent.keyCode); |
| assertEquals('should fire a key event with alt key set', |
| true, |
| keyEvent.altKey); |
| |
| // Scenario: alt down, a down, a press, a up (should say alt is true), |
| // alt up. |
| keyEvent = undefined; |
| fireKeyDown(keyHandler, 18, 0, null, false, true, false); |
| fireKeyDown(keyHandler, goog.events.KeyCodes.A, 0, null, false, true, |
| false); |
| fireKeyPress(keyHandler, 0, 229, null, false, false, false); |
| assertEquals('should fire a key event with alt key set', |
| true, |
| keyEvent.altKey); |
| fireKeyUp(keyHandler, 0, 229, null, false, true, false); |
| assertEquals('alt key should still be set', |
| true, |
| keyEvent.altKey); |
| fireKeyUp(keyHandler, 18, 0, null, false, false, false); |
| } |
| |
| function testGeckoEqualSign() { |
| goog.userAgent.OPERA = false; |
| goog.userAgent.IE = false; |
| goog.userAgent.GECKO = true; |
| goog.userAgent.WEBKIT = false; |
| goog.userAgent.MAC = false; |
| goog.userAgent.WINDOWS = true; |
| goog.userAgent.LINUX = false; |
| goog.events.KeyHandler.USES_KEYDOWN_ = false; |
| |
| var keyEvent, keyHandler = new goog.events.KeyHandler(); |
| goog.events.listen(keyHandler, goog.events.KeyHandler.EventType.KEY, |
| function(e) { keyEvent = e; }); |
| |
| fireKeyDown(keyHandler, 61, 0); |
| fireKeyPress(keyHandler, 0, 61); |
| assertEquals('= should fire should fire a key event with the keyCode 187', |
| goog.events.KeyCodes.EQUALS, |
| keyEvent.keyCode); |
| assertEquals('= should fire a key event with the charCode 61', |
| goog.events.KeyCodes.FF_EQUALS, |
| keyEvent.charCode); |
| } |
| |
| function testMacGeckoSlash() { |
| goog.userAgent.OPERA = false; |
| goog.userAgent.IE = false; |
| goog.userAgent.GECKO = true; |
| goog.userAgent.WEBKIT = false; |
| goog.userAgent.MAC = true; |
| goog.userAgent.WINDOWS = false; |
| goog.userAgent.LINUX = false; |
| goog.events.KeyHandler.USES_KEYDOWN_ = false; |
| |
| var keyEvent, keyHandler = new goog.events.KeyHandler(); |
| goog.events.listen(keyHandler, goog.events.KeyHandler.EventType.KEY, |
| function(e) { keyEvent = e; }); |
| |
| fireKeyDown(keyHandler, 0, 63, null, false, false, true); |
| fireKeyPress(keyHandler, 0, 63, null, false, false, true); |
| assertEquals('/ should fire a key event with the keyCode 191', |
| goog.events.KeyCodes.SLASH, |
| keyEvent.keyCode); |
| assertEquals('? should fire a key event with the charCode 63', |
| goog.events.KeyCodes.QUESTION_MARK, |
| keyEvent.charCode); |
| } |
| |
| function testGetElement() { |
| var target = goog.dom.createDom('div'); |
| var target2 = goog.dom.createDom('div'); |
| var keyHandler = new goog.events.KeyHandler(); |
| assertNull(keyHandler.getElement()); |
| |
| keyHandler.attach(target); |
| assertEquals(target, keyHandler.getElement()); |
| |
| keyHandler.attach(target2); |
| assertNotEquals(target, keyHandler.getElement()); |
| assertEquals(target2, keyHandler.getElement()); |
| |
| var doc = goog.dom.getDocument(); |
| keyHandler.attach(doc); |
| assertEquals(doc, keyHandler.getElement()); |
| |
| keyHandler = new goog.events.KeyHandler(doc); |
| assertEquals(doc, keyHandler.getElement()); |
| |
| keyHandler = new goog.events.KeyHandler(target); |
| assertEquals(target, keyHandler.getElement()); |
| } |
| |
| function testDetach() { |
| var target = goog.dom.createDom('div'); |
| var keyHandler = new goog.events.KeyHandler(target); |
| assertEquals(target, keyHandler.getElement()); |
| |
| fireKeyDown(keyHandler, 0, 63, null, false, false, true); |
| fireKeyPress(keyHandler, 0, 63, null, false, false, true); |
| keyHandler.detach(); |
| |
| assertNull(keyHandler.getElement()); |
| // All listeners should be cleared. |
| assertNull(keyHandler.keyDownKey_); |
| assertNull(keyHandler.keyPressKey_); |
| assertNull(keyHandler.keyUpKey_); |
| // All key related state should be cleared. |
| assertEquals('Last key should be -1', -1, keyHandler.lastKey_); |
| assertEquals('keycode should be -1', -1, keyHandler.keyCode_); |
| } |
| |
| function testCapturePhase() { |
| var gotInCapturePhase; |
| var gotInBubblePhase; |
| |
| var target = goog.dom.createDom('div'); |
| goog.events.listen( |
| new goog.events.KeyHandler(target, false /* bubble */), |
| goog.events.KeyHandler.EventType.KEY, |
| function() { |
| gotInBubblePhase = true; |
| assertTrue(gotInCapturePhase); |
| }); |
| goog.events.listen( |
| new goog.events.KeyHandler(target, true /* capture */), |
| goog.events.KeyHandler.EventType.KEY, |
| function() { |
| gotInCapturePhase = true; |
| }); |
| |
| goog.testing.events.fireKeySequence(target, goog.events.KeyCodes.ESC); |
| assertTrue(gotInBubblePhase); |
| } |
| |
| function fireKeyDown(keyHandler, keyCode, opt_charCode, opt_keyIdentifier, |
| opt_ctrlKey, opt_altKey, opt_shiftKey) { |
| var fakeEvent = createFakeKeyEvent( |
| goog.events.EventType.KEYDOWN, keyCode, opt_charCode, opt_keyIdentifier, |
| opt_ctrlKey, opt_altKey, opt_shiftKey); |
| keyHandler.handleKeyDown_(fakeEvent); |
| return fakeEvent.returnValue_; |
| } |
| |
| function fireKeyPress(keyHandler, keyCode, opt_charCode, opt_keyIdentifier, |
| opt_ctrlKey, opt_altKey, opt_shiftKey) { |
| var fakeEvent = createFakeKeyEvent( |
| goog.events.EventType.KEYPRESS, keyCode, opt_charCode, |
| opt_keyIdentifier, opt_ctrlKey, opt_altKey, opt_shiftKey); |
| keyHandler.handleEvent(fakeEvent); |
| return fakeEvent.returnValue_; |
| } |
| |
| function fireKeyUp(keyHandler, keyCode, opt_charCode, opt_keyIdentifier, |
| opt_ctrlKey, opt_altKey, opt_shiftKey) { |
| var fakeEvent = createFakeKeyEvent( |
| goog.events.EventType.KEYUP, keyCode, opt_charCode, |
| opt_keyIdentifier, opt_ctrlKey, opt_altKey, opt_shiftKey); |
| keyHandler.handleKeyup_(fakeEvent); |
| return fakeEvent.returnValue_; |
| } |
| |
| function createFakeKeyEvent(type, keyCode, opt_charCode, opt_keyIdentifier, |
| opt_ctrlKey, opt_altKey, opt_shiftKey) { |
| var event = { |
| type: type, |
| keyCode: keyCode, |
| charCode: opt_charCode || undefined, |
| keyIdentifier: opt_keyIdentifier || undefined, |
| ctrlKey: opt_ctrlKey || false, |
| altKey: opt_altKey || false, |
| shiftKey: opt_shiftKey || false, |
| timeStamp: goog.now() |
| }; |
| return new goog.events.BrowserEvent(event); |
| } |