Debian Codegraph @

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

raw
1 // Copyright 2010 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.ImeHandlerTest');
16 goog.setTestOnly('goog.events.ImeHandlerTest');
17
18 goog.require('goog.array');
19 goog.require('goog.dom');
20 goog.require('goog.events');
21 goog.require('goog.events.ImeHandler');
22 goog.require('goog.events.KeyCodes');
23 goog.require('goog.object');
24 goog.require('goog.string');
25 goog.require('goog.testing.PropertyReplacer');
26 goog.require('goog.testing.events');
27 goog.require('goog.testing.events.Event');
28 goog.require('goog.testing.jsunit');
29 goog.require('goog.userAgent');
30
31 var sandbox;
32 var imeHandler;
33 var eventsFired;
34 var stubs = new goog.testing.PropertyReplacer();
35 var eventTypes = goog.events.ImeHandler.EventType;
36
37 function setUp() {
38 sandbox = goog.dom.getElement('sandbox');
39 }
40
41 function initImeHandler() {
42 goog.events.ImeHandler.USES_COMPOSITION_EVENTS = goog.userAgent.GECKO ||
43 (goog.userAgent.WEBKIT && goog.userAgent.isVersionOrHigher(532));
44 imeHandler = new goog.events.ImeHandler(sandbox);
45 eventsFired = [];
46 goog.events.listen(
47 imeHandler, goog.object.getValues(goog.events.ImeHandler.EventType),
48 function(e) { eventsFired.push(e.type); });
49 }
50
51 function tearDown() {
52 imeHandler.dispose();
53 imeHandler = null;
54
55 stubs.reset();
56 }
57
58 function tearDownPage() {
59 // Set up a test bed.
60 sandbox.innerHTML = '<div contentEditable="true">hello world</div>';
61 initImeHandler();
62
63 function unshiftEvent(e) {
64 last10Events.unshift(
65 e.type + ':' + e.keyCode + ':' +
66 goog.string.htmlEscape(goog.dom.getTextContent(sandbox)));
67 last10Events.length = Math.min(last10Events.length, 10);
68 goog.dom.getElement('logger').innerHTML = last10Events.join('<br>');
69 }
70
71 var last10Events = [];
72 goog.events.listen(
73 imeHandler, goog.object.getValues(goog.events.ImeHandler.EventType),
74 unshiftEvent);
75 goog.events.listen(sandbox, ['keydown', 'textInput'], unshiftEvent);
76 }
77
78 function assertEventsFired(var_args) {
79 assertArrayEquals(goog.array.clone(arguments), eventsFired);
80 }
81
82 function fireInputEvent(type) {
83 return goog.testing.events.fireBrowserEvent(
84 new goog.testing.events.Event(type, sandbox));
85 }
86
87 function fireImeKeySequence() {
88 return fireKeySequence(goog.events.KeyCodes.WIN_IME);
89 }
90
91 function fireKeySequence(keyCode) {
92 return (
93 goog.testing.events.fireBrowserEvent(
94 new goog.testing.events.Event('textInput', sandbox)) &
95 goog.testing.events.fireKeySequence(sandbox, keyCode));
96 }
97
98 function testHandleKeyDown_GeckoCompositionEvents() {
99 // This test verifies that our IME functions can dispatch IME events to
100 // InputHandler in the expected order on Gecko.
101
102 // Set the userAgent used for this test to Firefox.
103 setUserAgent('GECKO');
104 stubs.set(goog.userAgent, 'MAC', false);
105 initImeHandler();
106
107 fireInputEvent('compositionstart');
108 assertImeMode();
109
110 fireInputEvent('compositionupdate');
111 fireInputEvent('compositionupdate');
112
113 fireInputEvent('compositionend');
114
115 assertEventsFired(
116 eventTypes.START, eventTypes.UPDATE, eventTypes.UPDATE, eventTypes.END);
117 assertNotImeMode();
118 }
119
120
121 /**
122 * Verifies that our IME functions can dispatch IME events to the input handler
123 * in the expected order on Chrome. jsUnitFarm does not have Linux Chrome or
124 * Mac Chrome. So, we manually change the platform and run this test three
125 * times.
126 */
127 function testChromeCompositionEventsLinux() {
128 runChromeCompositionEvents('LINUX');
129 }
130
131 function testChromeCompositionEventsMac() {
132 runChromeCompositionEvents('MAC');
133 }
134
135 function testChromeCompositionEventsWindows() {
136 runChromeCompositionEvents('WINDOWS');
137 }
138
139 function runChromeCompositionEvents(platform) {
140 setUserAgent('WEBKIT');
141 setVersion(532);
142 stubs.set(goog.userAgent, platform, true);
143 initImeHandler();
144
145 fireImeKeySequence();
146
147 fireInputEvent('compositionstart');
148 assertImeMode();
149
150 fireInputEvent('compositionupdate');
151 fireInputEvent('compositionupdate');
152
153 fireInputEvent('compositionend');
154 assertEventsFired(
155 eventTypes.START, eventTypes.UPDATE, eventTypes.UPDATE, eventTypes.END);
156 assertNotImeMode();
157 }
158
159
160 /**
161 * Ensures that the IME mode turn on/off correctly.
162 */
163 function testHandlerKeyDownForIme_imeOnOff() {
164 setUserAgent('IE');
165 initImeHandler();
166
167 // Send a WIN_IME keyDown event and see whether IME mode turns on.
168 fireImeKeySequence();
169 assertImeMode();
170
171 // Send keyDown events which should not turn off IME mode and see whether
172 // IME mode holds on.
173 fireKeySequence(goog.events.KeyCodes.SHIFT);
174 assertImeMode();
175
176 fireKeySequence(goog.events.KeyCodes.CTRL);
177 assertImeMode();
178
179 // Send a keyDown event with keyCode = ENTER and see whether IME mode
180 // turns off.
181 fireKeySequence(goog.events.KeyCodes.ENTER);
182 assertNotImeMode();
183
184 assertEventsFired(eventTypes.START, eventTypes.END);
185 }
186
187
188 /**
189 * Ensures that IME mode turns off when keyup events which are involved
190 * in committing IME text occurred in Safari.
191 */
192 function testHandleKeyUpForSafari() {
193 setUserAgent('WEBKIT');
194 setVersion(531);
195 initImeHandler();
196
197 fireImeKeySequence();
198 assertImeMode();
199
200 fireKeySequence(goog.events.KeyCodes.ENTER);
201 assertNotImeMode();
202 }
203
204
205 /**
206 * SCIM on Linux will fire WIN_IME keycodes for random characters.
207 * Fortunately, all Linux-based browsers use composition events.
208 * This test just verifies that we ignore the WIN_IME keycodes.
209 */
210 function testScimFiresWinImeKeycodesGeckoLinux() {
211 setUserAgent('GECKO');
212 assertScimInputIgnored();
213 }
214
215 function testScimFiresWinImeKeycodesChromeLinux() {
216 setUserAgent('WEBKIT');
217 setVersion(532);
218 assertScimInputIgnored();
219 }
220
221 function assertScimInputIgnored() {
222 initImeHandler();
223
224 fireImeKeySequence();
225 assertNotImeMode();
226
227 fireInputEvent('compositionstart');
228 assertImeMode();
229
230 fireImeKeySequence();
231 assertImeMode();
232
233 fireInputEvent('compositionend');
234 assertNotImeMode();
235 }
236
237 var userAgents = ['IE', 'GECKO', 'WEBKIT'];
238
239 function setUserAgent(userAgent) {
240 for (var i = 0; i < userAgents.length; i++) {
241 stubs.set(goog.userAgent, userAgents[i], userAgents[i] == userAgent);
242 }
243 }
244
245 function setVersion(version) {
246 goog.userAgent.VERSION = version;
247 goog.userAgent.isVersionOrHigherCache_ = {};
248 }
249
250 function assertImeMode() {
251 assertTrue('Should be in IME mode.', imeHandler.isImeMode());
252 }
253
254 function assertNotImeMode() {
255 assertFalse('Should not be in IME mode.', imeHandler.isImeMode());
256 }