test_dom_keyboard_event.html (23953B)
1 <!DOCTYPE HTML> 2 <html> 3 <head> 4 <title>Test for DOM KeyboardEvent</title> 5 <script src="/tests/SimpleTest/SimpleTest.js"></script> 6 <script src="/tests/SimpleTest/EventUtils.js"></script> 7 <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> 8 </head> 9 <body> 10 <p id="display"></p> 11 <p><input type="text" id="input"></p> 12 <p><input type="text" id="input_readonly" readonly></p> 13 <p><textarea id="textarea"></textarea></p> 14 <div id="content" style="display: none"> 15 16 </div> 17 <pre id="test"> 18 <script type="application/javascript"> 19 20 SimpleTest.waitForExplicitFinish(); 21 SimpleTest.waitForFocus(runTests, window); 22 23 function testInitializingUntrustedEvent() 24 { 25 const kTests = [ 26 // initKeyEvent 27 { createEventArg: "KeyboardEvent", useInitKeyboardEvent: false, 28 type: "keydown", bubbles: true, cancelable: true, view: null, 29 ctrlKey: false, altKey: false, shiftKey: false, metaKey: false, 30 keyCode: 0x00, charCode: 0x00, detail: 0, key: "", location: 0, 31 }, // 0 32 33 { createEventArg: "keyboardevent", useInitKeyboardEvent: false, 34 type: "keyup", bubbles: false, cancelable: true, view: window, 35 ctrlKey: true, altKey: false, shiftKey: false, metaKey: false, 36 keyCode: 0x10, charCode: 0x00, detail: 0, key: "", location: 0, 37 }, // 1 38 39 { createEventArg: "Keyboardevent", useInitKeyboardEvent: false, 40 type: "keypress", bubbles: true, cancelable: false, view: null, 41 ctrlKey: false, altKey: true, shiftKey: false, metaKey: false, 42 keyCode: 0x11, charCode: 0x30, detail: 0, key: "", location: 0, 43 }, // 2 44 45 { createEventArg: "keyboardEvent", useInitKeyboardEvent: false, 46 type: "boo", bubbles: false, cancelable: false, view: window, 47 ctrlKey: false, altKey: false, shiftKey: true, metaKey: false, 48 keyCode: 0x30, charCode: 0x40, detail: 0, key: "", location: 0, 49 }, // 3 50 51 { createEventArg: "KeyBoardEvent", useInitKeyboardEvent: false, 52 type: "foo", bubbles: true, cancelable: true, view: null, 53 ctrlKey: false, altKey: false, shiftKey: false, metaKey: true, 54 keyCode: 0x00, charCode: 0x50, detail: 0, key: "", location: 0, 55 }, // 4 56 57 { createEventArg: "keyboardevEnt", useInitKeyboardEvent: false, 58 type: "bar", bubbles: false, cancelable: true, view: window, 59 ctrlKey: true, altKey: true, shiftKey: false, metaKey: false, 60 keyCode: 0x00, charCode: 0x60, detail: 0, key: "", location: 0, 61 }, // 5 62 63 { createEventArg: "KeyboaRdevent", useInitKeyboardEvent: false, 64 type: "keydown", bubbles: true, cancelable: false, view: null, 65 ctrlKey: false, altKey: true, shiftKey: false, metaKey: true, 66 keyCode: 0x30, charCode: 0x00, detail: 0, key: "", location: 0, 67 }, // 6 68 69 { createEventArg: "KEYBOARDEVENT", useInitKeyboardEvent: false, 70 type: "keyup", bubbles: false, cancelable: false, view: window, 71 ctrlKey: true, altKey: false, shiftKey: true, metaKey: false, 72 keyCode: 0x10, charCode: 0x80, detail: 0, key: "", location: 0, 73 }, // 7 74 75 { createEventArg: "KeyboardEvent", useInitKeyboardEvent: false, 76 type: "keypress", bubbles: false, cancelable: false, view: window, 77 ctrlKey: true, altKey: false, shiftKey: true, metaKey: true, 78 keyCode: 0x10, charCode: 0x80, detail: 0, key: "", location: 0, 79 }, // 8 80 81 { createEventArg: "KeyboardEvent", useInitKeyboardEvent: false, 82 type: "foo", bubbles: false, cancelable: false, view: window, 83 ctrlKey: true, altKey: true, shiftKey: true, metaKey: true, 84 keyCode: 0x10, charCode: 0x80, detail: 0, key: "", location: 0, 85 }, // 9 86 87 // initKeyboardEvent 88 { createEventArg: "KeyboardEvent", useInitKeyboardEvent: true, 89 type: "keydown", bubbles: true, cancelable: true, view: null, 90 ctrlKey: false, altKey: false, shiftKey: false, metaKey: false, 91 keyCode: 0x00, charCode: 0x00, key: "", location: 0, 92 }, // 10 93 94 { createEventArg: "keyboardevent", useInitKeyboardEvent: true, 95 type: "keyup", bubbles: false, cancelable: true, view: window, 96 ctrlKey: true, altKey: false, shiftKey: false, metaKey: false, 97 keyCode: 0x00, charCode: 0x00, key: "Unidentified", location: 1, 98 }, // 11 99 100 { createEventArg: "Keyboardevent", useInitKeyboardEvent: true, 101 type: "keypress", bubbles: true, cancelable: false, view: null, 102 ctrlKey: false, altKey: true, shiftKey: false, metaKey: false, 103 keyCode: 0x00, charCode: 0x00, key: "FooBar", location: 2, 104 }, // 12 105 106 { createEventArg: "keyboardevent", useInitKeyboardEvent: true, 107 type: "foo", bubbles: true, cancelable: true, view: null, 108 ctrlKey: false, altKey: false, shiftKey: false, metaKey: true, 109 keyCode: 0x00, charCode: 0x00, key: "a", location: 0, 110 }, // 13 111 112 { createEventArg: "KeyBoardEvent", useInitKeyboardEvent: true, 113 type: "", bubbles: false, cancelable: false, view: null, 114 ctrlKey: true, altKey: true, shiftKey: true, metaKey: true, 115 keyCode: 0x00, charCode: 0x00, key: "3", location: 0, 116 }, // 14 117 118 { createEventArg: "keyboardevEnt", useInitKeyboardEvent: true, 119 type: "", bubbles: false, cancelable: false, view: null, 120 ctrlKey: false, altKey: false, shiftKey: true, metaKey: false, 121 keyCode: 0x00, charCode: 0x00, key: "3", location: 6, 122 }, // 15 123 124 { createEventArg: "KeyboaRdevent", useInitKeyboardEvent: true, 125 type: "", bubbles: false, cancelable: false, view: null, 126 ctrlKey: false, altKey: true, shiftKey: false, metaKey: false, 127 keyCode: 0x00, charCode: 0x00, key: "", location: 4, 128 }, // 16 129 ]; 130 131 const kOtherModifierName = [ 132 "CapsLock", "NumLock", "ScrollLock", "Symbol", "SymbolLock", "Fn", "FnLock", "AltGraph" 133 ]; 134 135 const kInvalidModifierName = [ 136 "shift", "control", "alt", "meta", "capslock", "numlock", "scrolllock", 137 "symbollock", "fn", "OS", "altgraph", "Invalid", "Shift Control", 138 "Win", "Scroll" 139 ]; 140 141 const kIsInitKeyEventAvailable = 142 SpecialPowers.getBoolPref("dom.keyboardevent.init_key_event.enabled", false); 143 144 for (var i = 0; i < kTests.length; i++) { 145 var description = "testInitializingUntrustedEvent, Index: " + i + ", "; 146 const kTest = kTests[i]; 147 var e = document.createEvent(kTest.createEventArg); 148 if (kTest.useInitKeyboardEvent) { 149 e.initKeyboardEvent(kTest.type, kTest.bubbles, kTest.cancelable, 150 kTest.view, kTest.key, kTest.location, 151 kTest.ctrlKey, kTest.altKey, kTest.shiftKey, 152 kTest.metaKey); 153 } else { 154 if (!kIsInitKeyEventAvailable) { 155 continue; 156 } 157 e.initKeyEvent(kTest.type, kTest.bubbles, kTest.cancelable, kTest.view, 158 kTest.ctrlKey, kTest.altKey, kTest.shiftKey, kTest.metaKey, 159 kTest.keyCode, kTest.charCode); 160 } 161 is(e.toString(), "[object KeyboardEvent]", 162 description + 'class string should be "KeyboardEvent"'); 163 164 for (var attr in kTest) { 165 if (attr == "createEventArg" || attr == "useInitKeyboardEvent" || attr == "modifiersList") { 166 continue; 167 } 168 if (!kTest.useInitKeyboardEvent && attr == "keyCode") { 169 // If this is keydown, keyup of keypress event, keycod must be correct. 170 if (kTest.type == "keydown" || kTest.type == "keyup" || kTest.type == "keypress") { 171 is(e[attr], kTest[attr], description + attr + " returns wrong value"); 172 // Otherwise, should be always zero (why?) 173 } else { 174 is(e[attr], 0, description + attr + " returns non-zero for invalid event"); 175 } 176 } else if (!kTest.useInitKeyboardEvent && attr == "charCode") { 177 // If this is keydown or keyup event, charCode always 0. 178 if (kTest.type == "keydown" || kTest.type == "keyup") { 179 is(e[attr], 0, description + attr + " returns non-zero for keydown or keyup event"); 180 // If this is keypress event, charCode must be correct. 181 } else if (kTest.type == "keypress") { 182 is(e[attr], kTest[attr], description + attr + " returns wrong value"); 183 // Otherwise, we have a bug. 184 } else { 185 if (e[attr] != kTest[attr]) { // avoid random unexpected pass. 186 todo_is(e[attr], kTest[attr], description + attr + " returns wrong value"); 187 } 188 } 189 } else { 190 is(e[attr], kTest[attr], description + attr + " returns wrong value"); 191 } 192 } 193 is(e.isTrusted, false, description + "isTrusted returns wrong value"); 194 195 // getModifierState() tests 196 is(e.getModifierState("Shift"), kTest.shiftKey, 197 description + "getModifierState(\"Shift\") returns wrong value"); 198 is(e.getModifierState("Control"), kTest.ctrlKey, 199 description + "getModifierState(\"Control\") returns wrong value"); 200 is(e.getModifierState("Alt"), kTest.altKey, 201 description + "getModifierState(\"Alt\") returns wrong value"); 202 is(e.getModifierState("Meta"), kTest.metaKey, 203 description + "getModifierState(\"Meta\") returns wrong value"); 204 205 for (var j = 0; j < kOtherModifierName.length; j++) { 206 ok(!e.getModifierState(kOtherModifierName[j]), 207 description + "getModifierState(\"" + kOtherModifierName[j] + "\") returns wrong value"); 208 } 209 for (var k = 0; k < kInvalidModifierName.length; k++) { 210 ok(!e.getModifierState(kInvalidModifierName[k]), 211 description + "getModifierState(\"" + kInvalidModifierName[k] + "\") returns wrong value"); 212 } 213 } 214 } 215 216 function testSynthesizedKeyLocation() 217 { 218 const kTests = [ 219 { key: "a", isModifier: false, isPrintable: true, 220 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false, 221 keyCode: KeyboardEvent.DOM_VK_A, 222 location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD }, 223 }, 224 { key: "KEY_Shift", isModifier: true, isPrintable: false, 225 event: { shiftKey: true, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false, 226 keyCode: KeyboardEvent.DOM_VK_SHIFT, 227 location: KeyboardEvent.DOM_KEY_LOCATION_LEFT }, 228 }, 229 { key: "KEY_Shift", isModifier: true, isPrintable: false, 230 event: { shiftKey: true, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false, 231 keyCode: KeyboardEvent.DOM_VK_SHIFT, 232 location: KeyboardEvent.DOM_KEY_LOCATION_RIGHT }, 233 }, 234 { key: "KEY_Control", isModifier: true, isPrintable: false, 235 event: { shiftKey: false, ctrlKey: true, altKey: false, metaKey: false, numLockKey: false, 236 keyCode: KeyboardEvent.DOM_VK_CONTROL, 237 location: KeyboardEvent.DOM_KEY_LOCATION_LEFT }, 238 }, 239 { key: "KEY_Control", isModifier: true, isPrintable: false, 240 event: { shiftKey: false, ctrlKey: true, altKey: false, metaKey: false, numLockKey: false, 241 keyCode: KeyboardEvent.DOM_VK_CONTROL, 242 location: KeyboardEvent.DOM_KEY_LOCATION_RIGHT }, 243 }, 244 /* XXX Alt key activates menubar even if we consume the key events. 245 { key: "KEY_Alt", isModifier: true, isPrintable: false, 246 event: { shiftKey: false, ctrlKey: false, altKey: true, metaKey: false, numLockKey: false, 247 keyCode: KeyboardEvent.DOM_VK_ALT, 248 location: KeyboardEvent.DOM_KEY_LOCATION_LEFT }, 249 }, 250 { key: "KEY_Alt", isModifier: true, isPrintable: false, 251 event: { shiftKey: false, ctrlKey: false, altKey: true, metaKey: false, numLockKey: false, 252 keyCode: KeyboardEvent.DOM_VK_ALT, 253 location: KeyboardEvent.DOM_KEY_LOCATION_RIGHT }, 254 }, 255 */ 256 { key: "KEY_Meta", isModifier: true, isPrintable: false, 257 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: true, numLockKey: false, 258 keyCode: KeyboardEvent.DOM_VK_META, 259 location: KeyboardEvent.DOM_KEY_LOCATION_LEFT }, 260 }, 261 { key: "KEY_Meta", isModifier: true, isPrintable: false, 262 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: true, numLockKey: false, 263 keyCode: KeyboardEvent.DOM_VK_META, 264 location: KeyboardEvent.DOM_KEY_LOCATION_RIGHT }, 265 }, 266 { key: "KEY_ArrowDown", isModifier: false, isPrintable: false, 267 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false, 268 keyCode: KeyboardEvent.DOM_VK_DOWN, 269 location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD }, 270 }, 271 { key: "KEY_ArrowDown", isModifier: false, isPrintable: false, 272 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false, 273 keyCode: KeyboardEvent.DOM_VK_DOWN, 274 location: KeyboardEvent.DOM_KEY_LOCATION_NUMPAD }, 275 }, 276 { key: "5", isModifier: false, isPrintable: true, 277 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false, 278 keyCode: KeyboardEvent.DOM_VK_5, 279 location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD }, 280 }, 281 { key: "5", isModifier: false, isPrintable: true, 282 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: true, 283 keyCode: KeyboardEvent.DOM_VK_NUMPAD5, 284 location: KeyboardEvent.DOM_KEY_LOCATION_NUMPAD }, 285 }, 286 { key: "+", isModifier: false, isPrintable: true, 287 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false, 288 keyCode: KeyboardEvent.DOM_VK_EQUALS, 289 location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD }, 290 }, 291 { key: "+", isModifier: false, isPrintable: true, 292 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: true, 293 keyCode: KeyboardEvent.DOM_VK_ADD, 294 location: KeyboardEvent.DOM_KEY_LOCATION_NUMPAD }, 295 }, 296 { key: "KEY_Enter", isModifier: false, isPrintable: true, 297 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false, 298 keyCode: KeyboardEvent.DOM_VK_RETURN, 299 location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD }, 300 }, 301 { key: "KEY_Enter", isModifier: false, isPrintable: true, 302 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false, 303 keyCode: KeyboardEvent.DOM_VK_RETURN, 304 location: KeyboardEvent.DOM_KEY_LOCATION_NUMPAD }, 305 }, 306 { key: "KEY_NumLock", isModifier: true, isPrintable: false, 307 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false, 308 keyCode: KeyboardEvent.DOM_VK_NUM_LOCK, 309 location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD }, 310 }, 311 { key: "KEY_Insert", isModifier: false, isPrintable: false, 312 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false, 313 keyCode: KeyboardEvent.DOM_VK_INSERT, 314 location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD }, 315 }, 316 { key: "KEY_Insert", isModifier: false, isPrintable: false, 317 event: { shiftKey: false, ctrlKey: false, altKey: false, metaKey: false, numLockKey: false, 318 keyCode: KeyboardEvent.DOM_VK_INSERT, 319 location: KeyboardEvent.DOM_KEY_LOCATION_NUMPAD }, 320 }, 321 ]; 322 323 function getLocationName(aLocation) 324 { 325 switch (aLocation) { 326 case KeyboardEvent.DOM_KEY_LOCATION_STANDARD: 327 return "DOM_KEY_LOCATION_STANDARD"; 328 case KeyboardEvent.DOM_KEY_LOCATION_LEFT: 329 return "DOM_KEY_LOCATION_LEFT"; 330 case KeyboardEvent.DOM_KEY_LOCATION_RIGHT: 331 return "DOM_KEY_LOCATION_RIGHT"; 332 case KeyboardEvent.DOM_KEY_LOCATION_NUMPAD: 333 return "DOM_KEY_LOCATION_NUMPAD"; 334 default: 335 return "Invalid value (" + aLocation + ")"; 336 } 337 } 338 339 var currentTest, description; 340 var events = { keydown: false, keypress: false, keyup: false }; 341 342 function handler(aEvent) 343 { 344 is(aEvent.location, currentTest.event.location, 345 description + "location of " + aEvent.type + " was invalid"); 346 events[aEvent.type] = true; 347 if (aEvent.type != "keydown" || 348 (currentTest.event.isModifier && aEvent.type == "keydown")) { 349 aEvent.preventDefault(); 350 } 351 } 352 353 window.addEventListener("keydown", handler, true); 354 window.addEventListener("keypress", handler, true); 355 window.addEventListener("keyup", handler, true); 356 357 for (var i = 0; i < kTests.length; i++) { 358 currentTest = kTests[i]; 359 events = { keydown: false, keypress: false, keyup: false }; 360 description = "testSynthesizedKeyLocation, " + i + ", key: " + 361 currentTest.key + ", location: " + 362 getLocationName(currentTest.event.location) + ": "; 363 synthesizeKey(currentTest.key, currentTest.event); 364 ok(events.keydown, description + "keydown event wasn't fired"); 365 if (currentTest.isPrintable) { 366 ok(events.keypress, description + "keypress event wasn't fired for printable key"); 367 } else { 368 ok(!events.keypress, description + "keypress event was fired for non-printable key"); 369 } 370 ok(events.keyup, description + "keyup event wasn't fired"); 371 } 372 373 window.removeEventListener("keydown", handler, true); 374 window.removeEventListener("keypress", handler, true); 375 window.removeEventListener("keyup", handler, true); 376 } 377 378 // We're using TextEventDispatcher to decide if we should keypress event 379 // on content in the default event group. So, we can test if keypress 380 // event is NOT fired unexpectedly with synthesizeKey(). 381 function testEnterKeyPressEvent() 382 { 383 let keydownFired, keypressFired, beforeinputFired; 384 function onEvent(aEvent) { 385 switch (aEvent.type) { 386 case "keydown": 387 keydownFired = true; 388 break; 389 case "keypress": 390 keypressFired = true; 391 break; 392 case "beforeinput": 393 beforeinputFired = true; 394 break; 395 } 396 } 397 398 for (let targetId of ["input", "textarea", "input_readonly"]) { 399 let target = document.getElementById(targetId); 400 401 function reset() { 402 keydownFired = keypressFired = beforeinputFired = false; 403 target.value = ""; 404 } 405 406 target.addEventListener("keydown", onEvent); 407 target.addEventListener("keypress", onEvent); 408 target.addEventListener("beforeinput", onEvent); 409 410 const kDescription = "<" + targetId.replace("_", " ") + ">: "; 411 let isEditable = !kDescription.includes("readonly"); 412 let isTextarea = kDescription.includes("textarea"); 413 414 target.focus(); 415 416 reset(); 417 synthesizeKey("KEY_Enter"); 418 is(keydownFired, true, 419 kDescription + "keydown event should be fired when Enter key is pressed"); 420 is(keypressFired, true, 421 kDescription + "keypress event should be fired when Enter key is pressed"); 422 if (isEditable) { 423 ok(beforeinputFired, 424 kDescription + "beforeinput event should be fired (if it's enabled) when Enter key is pressed"); 425 } else { 426 is(beforeinputFired, false, 427 kDescription + "beforeinput event shouldn't be fired when Enter key is pressed"); 428 } 429 if (isTextarea) { 430 is(target.value, "\n", 431 kDescription + "Enter key should cause inputting a line break in <textarea>"); 432 } else { 433 is(target.value, "", 434 kDescription + "Enter key should not cause inputting a line break"); 435 } 436 437 reset(); 438 synthesizeKey("KEY_Enter", {shiftKey: true}); 439 is(keydownFired, true, 440 kDescription + "keydown event should be fired when Shift + Enter key is pressed"); 441 is(keypressFired, true, 442 kDescription + "keypress event should be fired when Shift + Enter key is pressed"); 443 if (isEditable) { 444 ok(beforeinputFired, 445 kDescription + "beforeinput event should be fired (if it's enabled) when Shift + Enter key is pressed"); 446 } else { 447 is(beforeinputFired, false, 448 kDescription + "beforeinput event shouldn't be fired when Shift + Enter key is pressed"); 449 } 450 if (isTextarea) { 451 is(target.value, "\n", 452 kDescription + "Shift + Enter key should cause inputting a line break in <textarea>"); 453 } else { 454 is(target.value, "", 455 kDescription + "Shift + Enter key should not cause inputting a line break"); 456 } 457 458 reset(); 459 synthesizeKey("KEY_Enter", {ctrlKey: true}); 460 is(keydownFired, true, 461 kDescription + "keydown event should be fired when Ctrl + Enter key is pressed"); 462 is(keypressFired, true, 463 kDescription + "keypress event should be fired when Ctrl + Enter key is pressed"); 464 is(beforeinputFired, false, 465 kDescription + "beforeinput event shouldn't be fired when Ctrl + Enter key is pressed"); 466 is(target.value, "", 467 kDescription + "Ctrl + Enter key should not cause inputting a line break"); 468 469 reset(); 470 synthesizeKey("KEY_Enter", {altKey: true}); 471 is(keydownFired, true, 472 kDescription + "keydown event should be fired when Alt + Enter key is pressed"); 473 ok(!keypressFired, 474 kDescription + "keypress event shouldn't be fired when Alt + Enter key is pressed in strict keypress dispatching mode"); 475 is(beforeinputFired, false, 476 kDescription + "beforeinput event shouldn't be fired when Alt + Enter key is pressed"); 477 is(target.value, "", 478 kDescription + "Alt + Enter key should not cause inputting a line break"); 479 480 reset(); 481 synthesizeKey("KEY_Enter", {metaKey: true}); 482 is(keydownFired, true, 483 kDescription + "keydown event should be fired when Meta + Enter key is pressed"); 484 ok(!keypressFired, 485 kDescription + "keypress event shouldn't be fired when Meta + Enter key is pressed in strict keypress dispatching mode"); 486 is(beforeinputFired, false, 487 kDescription + "beforeinput event shouldn't be fired when Meta + Enter key is pressed"); 488 is(target.value, "", 489 kDescription + "Meta + Enter key should not cause inputting a line break"); 490 491 reset(); 492 synthesizeKey("KEY_Enter", {shiftKey: true, ctrlKey: true}); 493 is(keydownFired, true, 494 kDescription + "keydown event should be fired when Ctrl + Shift + Enter key is pressed"); 495 ok(!keypressFired, 496 kDescription + "keypress event shouldn't be fired when Ctrl + Shift + Enter key is pressed in strict keypress dispatching mode"); 497 is(beforeinputFired, false, 498 kDescription + "beforeinput event shouldn't be fired when Ctrl + Shift + Enter key is pressed"); 499 is(target.value, "", 500 kDescription + "Ctrl + Shift + Enter key should not cause inputting a line break"); 501 502 reset(); 503 synthesizeKey("KEY_Enter", {shiftKey: true, altKey: true}); 504 is(keydownFired, true, 505 kDescription + "keydown event should be fired when Alt + Shift + Enter key is pressed"); 506 ok(!keypressFired, 507 kDescription + "keypress event shouldn't be fired when Alt + Shift + Enter key is pressed in strict keypress dispatching mode"); 508 is(beforeinputFired, false, 509 kDescription + "beforeinput event shouldn't be fired when Alt + Shift + Enter key is pressed"); 510 is(target.value, "", 511 kDescription + "Alt + Shift + Enter key should not cause inputting a line break"); 512 513 reset(); 514 synthesizeKey("KEY_Enter", {shiftKey: true, metaKey: true}); 515 is(keydownFired, true, 516 kDescription + "keydown event should be fired when Meta + Shift + Enter key is pressed"); 517 ok(!keypressFired, 518 kDescription + "keypress event shouldn't be fired when Meta + Shift + Enter key is pressed in strict keypress dispatching mode"); 519 is(beforeinputFired, false, 520 kDescription + "beforeinput event shouldn't be fired when Meta + Shift + Enter key is pressed"); 521 is(target.value, "", 522 kDescription + "Meta + Shift + Enter key should not cause inputting a line break"); 523 524 target.removeEventListener("keydown", onEvent); 525 target.removeEventListener("keypress", onEvent); 526 target.removeEventListener("beforeinput", onEvent); 527 } 528 } 529 530 function runTests() 531 { 532 testInitializingUntrustedEvent(); 533 testSynthesizedKeyLocation(); 534 testEnterKeyPressEvent(); 535 SimpleTest.finish(); 536 } 537 538 </script> 539 </pre> 540 </body> 541 </html>