tests/test.keyboard.js

   1 var assert = chai.assert;
   2 var expect = chai.expect;
   3
   4 import { Keyboard } from '../core/input/devices.js';
   5 import keysyms from '../core/input/keysymdef.js';
   6 import * as KeyboardUtil from '../core/input/util.js';
   7
   8 /* jshint newcap: false, expr: true */
   9 describe('Key Event Handling', function() {
  10     "use strict";
  11
  12     // The real KeyboardEvent constructor might not work everywhere we
  13     // want to run these tests
  14     function keyevent(typeArg, KeyboardEventInit) {
  15         var e = { type: typeArg };
  16         for (var key in KeyboardEventInit) {
  17             e[key] = KeyboardEventInit[key];
  18         }
  19         e.stopPropagation = sinon.spy();
  20         e.preventDefault = sinon.spy();
  21         return e;
  22     };
  23
  24     describe('Decode Keyboard Events', function() {
  25         it('should decode keydown events', function(done) {
  26             var kbd = new Keyboard({
  27             onKeyEvent: function(keysym, code, down) {
  28                 expect(keysym).to.be.equal(0x61);
  29                 expect(code).to.be.equal('KeyA');
  30                 expect(down).to.be.equal(true);
  31                 done();
  32             }});
  33             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
  34         });
  35         it('should decode keyup events', function(done) {
  36             var calls = 0;
  37             var kbd = new Keyboard({
  38             onKeyEvent: function(keysym, code, down) {
  39                 expect(keysym).to.be.equal(0x61);
  40                 expect(code).to.be.equal('KeyA');
  41                 if (calls++ === 1) {
  42                     expect(down).to.be.equal(false);
  43                     done();
  44                 }
  45             }});
  46             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
  47             kbd._handleKeyUp(keyevent('keyup', {code: 'KeyA', key: 'a'}));
  48         });
  49
  50         describe('Legacy keypress Events', function() {
  51             it('should wait for keypress when needed', function() {
  52                 var callback = sinon.spy();
  53                 var kbd = new Keyboard({onKeyEvent: callback});
  54                 kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', keyCode: 0x41}));
  55                 expect(callback).to.not.have.been.called;
  56             });
  57             it('should decode keypress events', function(done) {
  58                 var kbd = new Keyboard({
  59                 onKeyEvent: function(keysym, code, down) {
  60                     expect(keysym).to.be.equal(0x61);
  61                     expect(code).to.be.equal('KeyA');
  62                     expect(down).to.be.equal(true);
  63                     done();
  64                 }});
  65                 kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', keyCode: 0x41}));
  66                 kbd._handleKeyPress(keyevent('keypress', {code: 'KeyA', charCode: 0x61}));
  67             });
  68             it('should ignore keypress with different code', function() {
  69                 var callback = sinon.spy();
  70                 var kbd = new Keyboard({onKeyEvent: callback});
  71                 kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', keyCode: 0x41}));
  72                 kbd._handleKeyPress(keyevent('keypress', {code: 'KeyB', charCode: 0x61}));
  73                 expect(callback).to.not.have.been.called;
  74             });
  75             it('should handle keypress with missing code', function(done) {
  76                 var kbd = new Keyboard({
  77                 onKeyEvent: function(keysym, code, down) {
  78                     expect(keysym).to.be.equal(0x61);
  79                     expect(code).to.be.equal('KeyA');
  80                     expect(down).to.be.equal(true);
  81                     done();
  82                 }});
  83                 kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', keyCode: 0x41}));
  84                 kbd._handleKeyPress(keyevent('keypress', {charCode: 0x61}));
  85             });
  86         });
  87
  88         describe('suppress the right events at the right time', function() {
  89             it('should suppress anything with a valid key', function() {
  90                 var kbd = new Keyboard({});
  91                 var evt = keyevent('keydown', {code: 'KeyA', key: 'a'});
  92                 kbd._handleKeyDown(evt);
  93                 expect(evt.preventDefault).to.have.been.called;
  94                 evt = keyevent('keyup', {code: 'KeyA', key: 'a'});
  95                 kbd._handleKeyUp(evt);
  96                 expect(evt.preventDefault).to.have.been.called;
  97             });
  98             it('should not suppress keys without key', function() {
  99                 var kbd = new Keyboard({});
 100                 var evt = keyevent('keydown', {code: 'KeyA', keyCode: 0x41});
 101                 kbd._handleKeyDown(evt);
 102                 expect(evt.preventDefault).to.not.have.been.called;
 103             });
 104             it('should suppress the following keypress event', function() {
 105                 var kbd = new Keyboard({});
 106                 var evt = keyevent('keydown', {code: 'KeyA', keyCode: 0x41});
 107                 kbd._handleKeyDown(evt);
 108                 var evt = keyevent('keypress', {code: 'KeyA', charCode: 0x41});
 109                 kbd._handleKeyPress(evt);
 110                 expect(evt.preventDefault).to.have.been.called;
 111             });
 112         });
 113     });
 114
 115     describe('Track Key State', function() {
 116         it('should send release using the same keysym as the press', function(done) {
 117             var kbd = new Keyboard({
 118             onKeyEvent: function(keysym, code, down) {
 119                 expect(keysym).to.be.equal(0x61);
 120                 expect(code).to.be.equal('KeyA');
 121                 if (!down) {
 122                     done();
 123                 }
 124             }});
 125             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
 126             kbd._handleKeyUp(keyevent('keyup', {code: 'KeyA', key: 'b'}));
 127         });
 128         it('should send the same keysym for multiple presses', function() {
 129             var count = 0;
 130             var kbd = new Keyboard({
 131             onKeyEvent: function(keysym, code, down) {
 132                 expect(keysym).to.be.equal(0x61);
 133                 expect(code).to.be.equal('KeyA');
 134                 expect(down).to.be.equal(true);
 135                 count++;
 136             }});
 137             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
 138             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'b'}));
 139             expect(count).to.be.equal(2);
 140         });
 141         it('should do nothing on keyup events if no keys are down', function() {
 142             var callback = sinon.spy();
 143             var kbd = new Keyboard({onKeyEvent: callback});
 144             kbd._handleKeyUp(keyevent('keyup', {code: 'KeyA', key: 'a'}));
 145             expect(callback).to.not.have.been.called;
 146         });
 147     });
 148
 149     describe('Escape Modifiers', function() {
 150         var origNavigator;
 151         beforeEach(function () {
 152             // window.navigator is a protected read-only property in many
 153             // environments, so we need to redefine it whilst running these
 154             // tests.
 155             origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
 156             if (origNavigator === undefined) {
 157                 // Object.getOwnPropertyDescriptor() doesn't work
 158                 // properly in any version of IE
 159                 this.skip();
 160             }
 161
 162             Object.defineProperty(window, "navigator", {value: {}});
 163             if (window.navigator.platform !== undefined) {
 164                 // Object.defineProperty() doesn't work properly in old
 165                 // versions of Chrome
 166                 this.skip();
 167             }
 168
 169             window.navigator.platform = "Windows x86_64";
 170         });
 171         afterEach(function () {
 172             Object.defineProperty(window, "navigator", origNavigator);
 173         });
 174
 175         it('should generate fake undo/redo events on press when a char modifier is down', function() {
 176             var times_called = 0;
 177             var kbd = new Keyboard({
 178             onKeyEvent: function(keysym, code, down) {
 179                 switch(times_called++) {
 180                 case 0:
 181                     expect(keysym).to.be.equal(0xFFE3);
 182                     expect(code).to.be.equal('ControlLeft');
 183                     expect(down).to.be.equal(true);
 184                     break;
 185                 case 1:
 186                     expect(keysym).to.be.equal(0xFFE9);
 187                     expect(code).to.be.equal('AltLeft');
 188                     expect(down).to.be.equal(true);
 189                     break;
 190                 case 2:
 191                     expect(keysym).to.be.equal(0xFFE9);
 192                     expect(code).to.be.equal('Unidentified');
 193                     expect(down).to.be.equal(false);
 194                     break;
 195                 case 3:
 196                     expect(keysym).to.be.equal(0xFFE3);
 197                     expect(code).to.be.equal('Unidentified');
 198                     expect(down).to.be.equal(false);
 199                     break;
 200                 case 4:
 201                     expect(keysym).to.be.equal(0x61);
 202                     expect(code).to.be.equal('KeyA');
 203                     expect(down).to.be.equal(true);
 204                     break;
 205                 case 5:
 206                     expect(keysym).to.be.equal(0xFFE9);
 207                     expect(code).to.be.equal('Unidentified');
 208                     expect(down).to.be.equal(true);
 209                     break;
 210                 case 6:
 211                     expect(keysym).to.be.equal(0xFFE3);
 212                     expect(code).to.be.equal('Unidentified');
 213                     expect(down).to.be.equal(true);
 214                     break;
 215                 }
 216             }});
 217             // First the modifier combo
 218             kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control'}));
 219             kbd._handleKeyDown(keyevent('keydown', {code: 'AltLeft', key: 'Alt'}));
 220             // Next a normal character
 221             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
 222             expect(times_called).to.be.equal(7);
 223         });
 224         it('should no do anything on key release', function() {
 225             var times_called = 0;
 226             var kbd = new Keyboard({
 227             onKeyEvent: function(keysym, code, down) {
 228                 switch(times_called++) {
 229                 case 7:
 230                     expect(keysym).to.be.equal(0x61);
 231                     expect(code).to.be.equal('KeyA');
 232                     expect(down).to.be.equal(false);
 233                     break;
 234                 }
 235             }});
 236             // First the modifier combo
 237             kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control'}));
 238             kbd._handleKeyDown(keyevent('keydown', {code: 'AltLeft', key: 'Alt'}));
 239             // Next a normal character
 240             kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
 241             kbd._handleKeyUp(keyevent('keyup', {code: 'KeyA', key: 'a'}));
 242             expect(times_called).to.be.equal(8);
 243         });
 244         it('should not consider a char modifier to be down on the modifier key itself', function() {
 245             var times_called = 0;
 246             var kbd = new Keyboard({
 247             onKeyEvent: function(keysym, code, down) {
 248                 switch(times_called++) {
 249                 case 0:
 250                     expect(keysym).to.be.equal(0xFFE3);
 251                     expect(code).to.be.equal('ControlLeft');
 252                     expect(down).to.be.equal(true);
 253                     break;
 254                 case 1:
 255                     expect(keysym).to.be.equal(0xFFE9);
 256                     expect(code).to.be.equal('AltLeft');
 257                     expect(down).to.be.equal(true);
 258                     break;
 259                 case 2:
 260                     expect(keysym).to.be.equal(0xFFE3);
 261                     expect(code).to.be.equal('ControlLeft');
 262                     expect(down).to.be.equal(true);
 263                     break;
 264                 }
 265             }});
 266             // First the modifier combo
 267             kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control'}));
 268             kbd._handleKeyDown(keyevent('keydown', {code: 'AltLeft', key: 'Alt'}));
 269             // Then one of the keys again
 270             kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control'}));
 271             expect(times_called).to.be.equal(3);
 272         });
 273     });
 274 });