javascript/atoms/test/keyboard_test.html - external/github.com/SeleniumHQ/selenium - Git at Google

 <!DOCTYPE html>
 <html>
 <head>
   <meta charset="utf-8">
   <title>keyboard_test</title>
   <link rel="stylesheet" href="/filez/_main/third_party/js/qunit/qunit.css">
   <script src="/filez/_main/third_party/js/qunit/qunit.js"></script>
   <script src="/filez/_main/third_party/js/qunit/qunit_test_runner.js"></script>
   <script src="test_bootstrap.js"></script>
   <script type="text/javascript">
     goog.require('bot.Device');
     goog.require('bot.Keyboard');
     goog.require('bot.Keyboard.Key');
     goog.require('bot.action');
     goog.require('goog.Promise');
     goog.require('goog.events');
     goog.require('goog.userAgent');
   </script>
 <body>
   <div id="qunit"></div>
   <div id="qunit-fixture"></div>
   <input id="target">
 <script type="text/javascript">
   var browser, target, keyboard;

   if (goog.userAgent.GECKO) {
     browser = 'GECKO';
   } else if (goog.userAgent.IE) {
     browser = 'IE';
   } else if (goog.userAgent.WEBKIT || goog.userAgent.EDGE) {
     browser = 'WEBKIT';
   } else {
     browser = 'UNKNOWN';
   }
   target = document.getElementById('target');
   keyboard = new bot.Keyboard();
   keyboard.moveCursor(target);

   function assertKeyEvents(assert, key, shift, browser2Codes) {
     if (browser === 'UNKNOWN') {
       assert.ok(false, 'unknown browser');
       return goog.Promise.resolve();
     }

     if (shift) {
       keyboard.pressKey(bot.Keyboard.Keys.SHIFT);
     }

     return new goog.Promise(function(success, failure) {
       var codes = browser2Codes[browser];
       var downFired = false, pressFired = false, expectPress = !!codes.press;

       goog.events.listen(target, ['keydown', 'keypress', 'keyup'], function(e) {
         e = e.getBrowserEvent();
         try {
           switch (e.type) {
             case 'keydown':
               downFired = true;
               var downCodes = codes.downUp;
               assert.strictEqual(e.keyCode, downCodes.key, 'wrong down keycode');
               assert.strictEqual(e.charCode, downCodes.char, 'wrong down charcode');
               return;
             case 'keypress':
               pressFired = true;
               assert.ok(downFired, 'keydown expected');
               assert.ok(expectPress, 'keypress not expected');
               var pressCodes = codes.press;
               assert.strictEqual(e.keyCode, pressCodes.key, 'wrong press keycode');
               assert.strictEqual(e.charCode, pressCodes.char, 'wrong press charcode');
               return;
             case 'keyup':
               assert.ok(downFired, 'keydown expected');
               if (expectPress) {
                 assert.ok(pressFired, 'keypress expected');
               }
               var upCodes = codes.downUp;
               assert.strictEqual(e.keyCode, upCodes.key, 'wrong up keycode');
               assert.strictEqual(e.charCode, upCodes.char, 'wrong up charcode');
               success();
               return;
           }
         } catch (e) {
           failure(e);
         }
       });

       keyboard.pressKey(key);
       keyboard.releaseKey(key);
     }).thenAlways(function() {
       goog.events.removeAll(target);
       if (shift) {
         keyboard.releaseKey(bot.Keyboard.Keys.SHIFT);
       }
     });
   }

   var U = undefined;

   QUnit.test('lower case', function(assert) {
     var done = assert.async();
     assertKeyEvents(assert, bot.Keyboard.Keys.G, false, {
       GECKO:  {downUp: {key: 71, char: 0}, press: {key:   0, char: 103}},
       IE:     {downUp: {key: 71, char: U}, press: {key: 103, char:   U}},
       WEBKIT: {downUp: {key: 71, char: 0}, press: {key: 103, char: 103}}
     }).then(done, function(err) { assert.ok(false, err); done(); });
   });

   QUnit.test('upper case', function(assert) {
     var done = assert.async();
     assertKeyEvents(assert, bot.Keyboard.Keys.G, true, {
       GECKO:  {downUp: {key: 71, char: 0}, press: {key:  0, char: 71}},
       IE:     {downUp: {key: 71, char: U}, press: {key: 71, char:  U}},
       WEBKIT: {downUp: {key: 71, char: 0}, press: {key: 71, char: 71}}
     }).then(done, function(err) { assert.ok(false, err); done(); });
   });

   QUnit.test('space', function(assert) {
     var done = assert.async();
     assertKeyEvents(assert, bot.Keyboard.Keys.SPACE, false, {
       GECKO:  {downUp: {key: 32, char: 0}, press: {key:  0, char: 32}},
       IE:     {downUp: {key: 32, char: U}, press: {key: 32, char:  U}},
       WEBKIT: {downUp: {key: 32, char: 0}, press: {key: 32, char: 32}}
     }).then(done, function(err) { assert.ok(false, err); done(); });
   });

   QUnit.test('punctuation without shift', function(assert) {
     var done = assert.async();
     assertKeyEvents(assert, bot.Keyboard.Keys.SEMICOLON, false, {
       GECKO:  {downUp: {key:  59, char: 0}, press: {key:  0, char: 59}},
       IE:     {downUp: {key: 186, char: U}, press: {key: 59, char:  U}},
       WEBKIT: {downUp: {key: 186, char: 0}, press: {key: 59, char: 59}}
     }).then(done, function(err) { assert.ok(false, err); done(); });
   });

   QUnit.test('punctuation with shift', function(assert) {
     var done = assert.async();
     assertKeyEvents(assert, bot.Keyboard.Keys.SEMICOLON, true, {
       GECKO:  {downUp: {key:  59, char: 0}, press: {key:  0, char: 58}},
       IE:     {downUp: {key: 186, char: U}, press: {key: 58, char:  U}},
       WEBKIT: {downUp: {key: 186, char: 0}, press: {key: 58, char: 58}}
     }).then(done, function(err) { assert.ok(false, err); done(); });
   });

   QUnit.test('enter', function(assert) {
     var done = assert.async();
     assertKeyEvents(assert, bot.Keyboard.Keys.ENTER, false, {
       GECKO:  {downUp: {key: 13, char: 0}, press: {key: 13, char:  0}},
       IE:     {downUp: {key: 13, char: U}, press: {key: 13, char:  U}},
       WEBKIT: {downUp: {key: 13, char: 0}, press: {key: 13, char: 13}}
     }).then(done, function(err) { assert.ok(false, err); done(); });
   });

   QUnit.test('arrow', function(assert) {
     var done = assert.async();
     assertKeyEvents(assert, bot.Keyboard.Keys.DOWN, false, {
       GECKO:  {downUp: {key: 40, char: 0}, press: {key: 40, char: 0}},
       IE:     {downUp: {key: 40, char: U}, press: U},
       WEBKIT: {downUp: {key: 40, char: 0}, press: U}
     }).then(done, function(err) { assert.ok(false, err); done(); });
   });

   QUnit.test('esc', function(assert) {
     var done = assert.async();
     assertKeyEvents(assert, bot.Keyboard.Keys.ESC, false, {
       GECKO:  {downUp: {key: 27, char: 0}, press: {key: 27, char: 0}},
       IE:     {downUp: {key: 27, char: U}, press: {key: 27, char: U}},
       WEBKIT: {downUp: {key: 27, char: 0}, press: U}
     }).then(done, function(err) { assert.ok(false, err); done(); });
   });

   QUnit.test('control', function(assert) {
     var done = assert.async();
     assertKeyEvents(assert, bot.Keyboard.Keys.CONTROL, false, {
       GECKO:  {downUp: {key: 17, char: 0}, press: U},
       IE:     {downUp: {key: 17, char: U}, press: U},
       WEBKIT: {downUp: {key: 17, char: 0}, press: U}
     }).then(done, function(err) { assert.ok(false, err); done(); });
   });

   QUnit.test('unknown character', function(assert) {
     var done = assert.async();
     var unknownChar = '\u7231';
     var unknownKey = bot.Keyboard.Key.fromChar(unknownChar).key;
     var cc = unknownKey.character.charCodeAt(0);
     assertKeyEvents(assert, unknownKey, false, {
       GECKO:  {downUp: {key: cc, char: 0}, press: {key:  0, char: cc}},
       IE:     {downUp: {key: cc, char: U}, press: {key: cc, char:  U}},
       WEBKIT: {downUp: {key: cc, char: 0}, press: {key: cc, char: cc}}
     }).then(done, function(err) { assert.ok(false, err); done(); });
   });

   QUnit.test('event cancel', function(assert) {
     var done = assert.async();
     var cancelEvent = function(event) {
       if (event.keyCode == 69) {
         event.preventDefault();
       }
     };
     var cancelKeydownId = goog.events.listen(target, 'keydown', cancelEvent);
     assertKeyEvents(assert, bot.Keyboard.Keys.E, false, {
       GECKO:  {downUp: {key: 69, char: 0}, press: {key: 0, char: 101}},
       IE:     {downUp: {key: 69, char: U}, press: U},
       WEBKIT: {downUp: {key: 69, char: 0}, press: U}
     }).thenAlways(function() {
       goog.events.unlistenByKey(cancelKeydownId);
     }).then(done, function(err) { assert.ok(false, err); done(); });
   });

   QUnit.test('modifier states stored', function(assert) {
     var modifiersState = new bot.Device.ModifiersState();

     assert.notOk(modifiersState.isPressed(bot.Device.Modifier.SHIFT));
     modifiersState.setPressed(bot.Device.Modifier.SHIFT, true);
     assert.ok(modifiersState.isPressed(bot.Device.Modifier.SHIFT));
     assert.ok(modifiersState.isShiftPressed());
     assert.notOk(modifiersState.isPressed(bot.Device.Modifier.CONTROL));

     modifiersState.setPressed(bot.Device.Modifier.SHIFT, false);
     assert.notOk(modifiersState.isPressed(bot.Device.Modifier.SHIFT));
   });

   QUnit.test('setting modifier twice', function(assert) {
     var modifiersState = new bot.Device.ModifiersState();
     modifiersState.setPressed(bot.Device.Modifier.SHIFT, true);
     assert.ok(modifiersState.isPressed(bot.Device.Modifier.SHIFT));
     modifiersState.setPressed(bot.Device.Modifier.SHIFT, true);
     assert.ok(modifiersState.isPressed(bot.Device.Modifier.SHIFT));
   });
 </script>
 </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="utf-8">
	<title>keyboard_test</title>
	<link rel="stylesheet" href="/filez/_main/third_party/js/qunit/qunit.css">
	<script src="/filez/_main/third_party/js/qunit/qunit.js"></script>
	<script src="/filez/_main/third_party/js/qunit/qunit_test_runner.js"></script>
	<script src="test_bootstrap.js"></script>
	<script type="text/javascript">
	goog.require('bot.Device');
	goog.require('bot.Keyboard');
	goog.require('bot.Keyboard.Key');
	goog.require('bot.action');
	goog.require('goog.Promise');
	goog.require('goog.events');
	goog.require('goog.userAgent');
	</script>
	<body>
	<div id="qunit"></div>
	<div id="qunit-fixture"></div>
	<input id="target">
	<script type="text/javascript">
	var browser, target, keyboard;

	if (goog.userAgent.GECKO) {
	browser = 'GECKO';
	} else if (goog.userAgent.IE) {
	browser = 'IE';
	} else if (goog.userAgent.WEBKIT \|\| goog.userAgent.EDGE) {
	browser = 'WEBKIT';
	} else {
	browser = 'UNKNOWN';
	}
	target = document.getElementById('target');
	keyboard = new bot.Keyboard();
	keyboard.moveCursor(target);

	function assertKeyEvents(assert, key, shift, browser2Codes) {
	if (browser === 'UNKNOWN') {
	assert.ok(false, 'unknown browser');
	return goog.Promise.resolve();
	}

	if (shift) {
	keyboard.pressKey(bot.Keyboard.Keys.SHIFT);
	}

	return new goog.Promise(function(success, failure) {
	var codes = browser2Codes[browser];
	var downFired = false, pressFired = false, expectPress = !!codes.press;

	goog.events.listen(target, ['keydown', 'keypress', 'keyup'], function(e) {
	e = e.getBrowserEvent();
	try {
	switch (e.type) {
	case 'keydown':
	downFired = true;
	var downCodes = codes.downUp;
	assert.strictEqual(e.keyCode, downCodes.key, 'wrong down keycode');
	assert.strictEqual(e.charCode, downCodes.char, 'wrong down charcode');
	return;
	case 'keypress':
	pressFired = true;
	assert.ok(downFired, 'keydown expected');
	assert.ok(expectPress, 'keypress not expected');
	var pressCodes = codes.press;
	assert.strictEqual(e.keyCode, pressCodes.key, 'wrong press keycode');
	assert.strictEqual(e.charCode, pressCodes.char, 'wrong press charcode');
	return;
	case 'keyup':
	assert.ok(downFired, 'keydown expected');
	if (expectPress) {
	assert.ok(pressFired, 'keypress expected');
	}
	var upCodes = codes.downUp;
	assert.strictEqual(e.keyCode, upCodes.key, 'wrong up keycode');
	assert.strictEqual(e.charCode, upCodes.char, 'wrong up charcode');
	success();
	return;
	}
	} catch (e) {
	failure(e);
	}
	});

	keyboard.pressKey(key);
	keyboard.releaseKey(key);
	}).thenAlways(function() {
	goog.events.removeAll(target);
	if (shift) {
	keyboard.releaseKey(bot.Keyboard.Keys.SHIFT);
	}
	});
	}

	var U = undefined;

	QUnit.test('lower case', function(assert) {
	var done = assert.async();
	assertKeyEvents(assert, bot.Keyboard.Keys.G, false, {
	GECKO: {downUp: {key: 71, char: 0}, press: {key: 0, char: 103}},
	IE: {downUp: {key: 71, char: U}, press: {key: 103, char: U}},
	WEBKIT: {downUp: {key: 71, char: 0}, press: {key: 103, char: 103}}
	}).then(done, function(err) { assert.ok(false, err); done(); });
	});

	QUnit.test('upper case', function(assert) {
	var done = assert.async();
	assertKeyEvents(assert, bot.Keyboard.Keys.G, true, {
	GECKO: {downUp: {key: 71, char: 0}, press: {key: 0, char: 71}},
	IE: {downUp: {key: 71, char: U}, press: {key: 71, char: U}},
	WEBKIT: {downUp: {key: 71, char: 0}, press: {key: 71, char: 71}}
	}).then(done, function(err) { assert.ok(false, err); done(); });
	});

	QUnit.test('space', function(assert) {
	var done = assert.async();
	assertKeyEvents(assert, bot.Keyboard.Keys.SPACE, false, {
	GECKO: {downUp: {key: 32, char: 0}, press: {key: 0, char: 32}},
	IE: {downUp: {key: 32, char: U}, press: {key: 32, char: U}},
	WEBKIT: {downUp: {key: 32, char: 0}, press: {key: 32, char: 32}}
	}).then(done, function(err) { assert.ok(false, err); done(); });
	});

	QUnit.test('punctuation without shift', function(assert) {
	var done = assert.async();
	assertKeyEvents(assert, bot.Keyboard.Keys.SEMICOLON, false, {
	GECKO: {downUp: {key: 59, char: 0}, press: {key: 0, char: 59}},
	IE: {downUp: {key: 186, char: U}, press: {key: 59, char: U}},
	WEBKIT: {downUp: {key: 186, char: 0}, press: {key: 59, char: 59}}
	}).then(done, function(err) { assert.ok(false, err); done(); });
	});

	QUnit.test('punctuation with shift', function(assert) {
	var done = assert.async();
	assertKeyEvents(assert, bot.Keyboard.Keys.SEMICOLON, true, {
	GECKO: {downUp: {key: 59, char: 0}, press: {key: 0, char: 58}},
	IE: {downUp: {key: 186, char: U}, press: {key: 58, char: U}},
	WEBKIT: {downUp: {key: 186, char: 0}, press: {key: 58, char: 58}}
	}).then(done, function(err) { assert.ok(false, err); done(); });
	});

	QUnit.test('enter', function(assert) {
	var done = assert.async();
	assertKeyEvents(assert, bot.Keyboard.Keys.ENTER, false, {
	GECKO: {downUp: {key: 13, char: 0}, press: {key: 13, char: 0}},
	IE: {downUp: {key: 13, char: U}, press: {key: 13, char: U}},
	WEBKIT: {downUp: {key: 13, char: 0}, press: {key: 13, char: 13}}
	}).then(done, function(err) { assert.ok(false, err); done(); });
	});

	QUnit.test('arrow', function(assert) {
	var done = assert.async();
	assertKeyEvents(assert, bot.Keyboard.Keys.DOWN, false, {
	GECKO: {downUp: {key: 40, char: 0}, press: {key: 40, char: 0}},
	IE: {downUp: {key: 40, char: U}, press: U},
	WEBKIT: {downUp: {key: 40, char: 0}, press: U}
	}).then(done, function(err) { assert.ok(false, err); done(); });
	});

	QUnit.test('esc', function(assert) {
	var done = assert.async();
	assertKeyEvents(assert, bot.Keyboard.Keys.ESC, false, {
	GECKO: {downUp: {key: 27, char: 0}, press: {key: 27, char: 0}},
	IE: {downUp: {key: 27, char: U}, press: {key: 27, char: U}},
	WEBKIT: {downUp: {key: 27, char: 0}, press: U}
	}).then(done, function(err) { assert.ok(false, err); done(); });
	});

	QUnit.test('control', function(assert) {
	var done = assert.async();
	assertKeyEvents(assert, bot.Keyboard.Keys.CONTROL, false, {
	GECKO: {downUp: {key: 17, char: 0}, press: U},
	IE: {downUp: {key: 17, char: U}, press: U},
	WEBKIT: {downUp: {key: 17, char: 0}, press: U}
	}).then(done, function(err) { assert.ok(false, err); done(); });
	});

	QUnit.test('unknown character', function(assert) {
	var done = assert.async();
	var unknownChar = '\u7231';
	var unknownKey = bot.Keyboard.Key.fromChar(unknownChar).key;
	var cc = unknownKey.character.charCodeAt(0);
	assertKeyEvents(assert, unknownKey, false, {
	GECKO: {downUp: {key: cc, char: 0}, press: {key: 0, char: cc}},
	IE: {downUp: {key: cc, char: U}, press: {key: cc, char: U}},
	WEBKIT: {downUp: {key: cc, char: 0}, press: {key: cc, char: cc}}
	}).then(done, function(err) { assert.ok(false, err); done(); });
	});

	QUnit.test('event cancel', function(assert) {
	var done = assert.async();
	var cancelEvent = function(event) {
	if (event.keyCode == 69) {
	event.preventDefault();
	}
	};
	var cancelKeydownId = goog.events.listen(target, 'keydown', cancelEvent);
	assertKeyEvents(assert, bot.Keyboard.Keys.E, false, {
	GECKO: {downUp: {key: 69, char: 0}, press: {key: 0, char: 101}},
	IE: {downUp: {key: 69, char: U}, press: U},
	WEBKIT: {downUp: {key: 69, char: 0}, press: U}
	}).thenAlways(function() {
	goog.events.unlistenByKey(cancelKeydownId);
	}).then(done, function(err) { assert.ok(false, err); done(); });
	});

	QUnit.test('modifier states stored', function(assert) {
	var modifiersState = new bot.Device.ModifiersState();

	assert.notOk(modifiersState.isPressed(bot.Device.Modifier.SHIFT));
	modifiersState.setPressed(bot.Device.Modifier.SHIFT, true);
	assert.ok(modifiersState.isPressed(bot.Device.Modifier.SHIFT));
	assert.ok(modifiersState.isShiftPressed());
	assert.notOk(modifiersState.isPressed(bot.Device.Modifier.CONTROL));

	modifiersState.setPressed(bot.Device.Modifier.SHIFT, false);
	assert.notOk(modifiersState.isPressed(bot.Device.Modifier.SHIFT));
	});

	QUnit.test('setting modifier twice', function(assert) {
	var modifiersState = new bot.Device.ModifiersState();
	modifiersState.setPressed(bot.Device.Modifier.SHIFT, true);
	assert.ok(modifiersState.isPressed(bot.Device.Modifier.SHIFT));
	modifiersState.setPressed(bot.Device.Modifier.SHIFT, true);
	assert.ok(modifiersState.isPressed(bot.Device.Modifier.SHIFT));
	});
	</script>
	</body>
	</html>