Andreas Hocevar
729 lines
26 KiB
JavaScript
729 lines
26 KiB
JavaScript
// 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.CAMINO = 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.CAMINO = 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.CAMINO = 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.CAMINO = 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, 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.CAMINO = 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.CAMINO = 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.CAMINO = false;
|
|
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.CAMINO = 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, 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.CAMINO = false;
|
|
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);
|
|
}
|