chrome/test/webdriver/webdriver_key_converter_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6 #include <vector>
   7
   8 #include "base/string16.h"
   9 #include "base/utf_string_conversions.h"
  10 #include "chrome/test/automation/automation_json_requests.h"
  11 #include "chrome/test/webdriver/webdriver_key_converter.h"
  12 #include "chrome/test/webdriver/webdriver_test_util.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace webdriver {
  16
  17 void CheckEvents(const string16& keys,
  18                  WebKeyEvent expected_events[],
  19                  bool release_modifiers,
  20                  size_t expected_size,
  21                  int expected_modifiers) {
  22   int modifiers = 0;
  23   std::vector<WebKeyEvent> events;
  24   std::string error_msg;
  25   EXPECT_TRUE(ConvertKeysToWebKeyEvents(keys, Logger(),
  26                                         release_modifiers,
  27                                         &modifiers, &events, &error_msg));
  28   EXPECT_EQ(expected_size, events.size());
  29   for (size_t i = 0; i < events.size() && i < expected_size; ++i) {
  30     EXPECT_EQ(expected_events[i].type, events[i].type);
  31     EXPECT_EQ(expected_events[i].key_code, events[i].key_code);
  32     EXPECT_EQ(expected_events[i].unmodified_text, events[i].unmodified_text);
  33     EXPECT_EQ(expected_events[i].modified_text, events[i].modified_text);
  34     EXPECT_EQ(expected_events[i].modifiers, events[i].modifiers);
  35   }
  36   EXPECT_EQ(expected_modifiers, modifiers);
  37 }
  38
  39 void CheckEventsReleaseModifiers(const string16& keys,
  40                                  WebKeyEvent expected_events[],
  41                                  size_t expected_size) {
  42   CheckEvents(keys, expected_events, true /* release_modifier */,
  43       expected_size, 0 /* expected_modifiers */);
  44 }
  45
  46 void CheckEventsReleaseModifiers(const std::string& keys,
  47                                  WebKeyEvent expected_events[],
  48                                  size_t expected_size) {
  49   CheckEventsReleaseModifiers(UTF8ToUTF16(keys),
  50       expected_events, expected_size);
  51 }
  52
  53 void CheckNonShiftChar(ui::KeyboardCode key_code, char character) {
  54   int modifiers = 0;
  55   std::string char_string;
  56   char_string.push_back(character);
  57   std::vector<WebKeyEvent> events;
  58   std::string error_msg;
  59   EXPECT_TRUE(ConvertKeysToWebKeyEvents(ASCIIToUTF16(char_string), Logger(),
  60                                         true /* release_modifiers*/,
  61                                         &modifiers, &events, &error_msg));
  62   ASSERT_EQ(3u, events.size()) << "Char: " << character;
  63   EXPECT_EQ(key_code, events[0].key_code) << "Char: " << character;
  64   ASSERT_EQ(1u, events[1].modified_text.length()) << "Char: " << character;
  65   ASSERT_EQ(1u, events[1].unmodified_text.length()) << "Char: " << character;
  66   EXPECT_EQ(character, events[1].modified_text[0]) << "Char: " << character;
  67   EXPECT_EQ(character, events[1].unmodified_text[0]) << "Char: " << character;
  68   EXPECT_EQ(key_code, events[2].key_code) << "Char: " << character;
  69 }
  70
  71 void CheckShiftChar(ui::KeyboardCode key_code, char character, char lower) {
  72   int modifiers = 0;
  73   std::string char_string;
  74   char_string.push_back(character);
  75   std::vector<WebKeyEvent> events;
  76   std::string error_msg;
  77   EXPECT_TRUE(ConvertKeysToWebKeyEvents(ASCIIToUTF16(char_string), Logger(),
  78                                         true /* release_modifiers*/,
  79                                         &modifiers, &events, &error_msg));
  80   ASSERT_EQ(5u, events.size()) << "Char: " << character;
  81   EXPECT_EQ(ui::VKEY_SHIFT, events[0].key_code) << "Char: " << character;
  82   EXPECT_EQ(key_code, events[1].key_code) << "Char: " << character;
  83   ASSERT_EQ(1u, events[2].modified_text.length()) << "Char: " << character;
  84   ASSERT_EQ(1u, events[2].unmodified_text.length()) << "Char: " << character;
  85   EXPECT_EQ(character, events[2].modified_text[0]) << "Char: " << character;
  86   EXPECT_EQ(lower, events[2].unmodified_text[0]) << "Char: " << character;
  87   EXPECT_EQ(key_code, events[3].key_code) << "Char: " << character;
  88   EXPECT_EQ(ui::VKEY_SHIFT, events[4].key_code) << "Char: " << character;
  89 }
  90
  91 TEST(WebDriverKeyConverter, SingleChar) {
  92   WebKeyEvent event_array[] = {
  93       CreateKeyDownEvent(ui::VKEY_H, 0),
  94       CreateCharEvent("h", "h", 0),
  95       CreateKeyUpEvent(ui::VKEY_H, 0)};
  96   CheckEventsReleaseModifiers("h", event_array, arraysize(event_array));
  97 }
  98
  99 TEST(WebDriverKeyConverter, SingleNumber) {
 100   WebKeyEvent event_array[] = {
 101       CreateKeyDownEvent(ui::VKEY_1, 0),
 102       CreateCharEvent("1", "1", 0),
 103       CreateKeyUpEvent(ui::VKEY_1, 0)};
 104   CheckEventsReleaseModifiers("1", event_array, arraysize(event_array));
 105 }
 106
 107 TEST(WebDriverKeyConverter, MultipleChars) {
 108   WebKeyEvent event_array[] = {
 109       CreateKeyDownEvent(ui::VKEY_H, 0),
 110       CreateCharEvent("h", "h", 0),
 111       CreateKeyUpEvent(ui::VKEY_H, 0),
 112       CreateKeyDownEvent(ui::VKEY_E, 0),
 113       CreateCharEvent("e", "e", 0),
 114       CreateKeyUpEvent(ui::VKEY_E, 0),
 115       CreateKeyDownEvent(ui::VKEY_Y, 0),
 116       CreateCharEvent("y", "y", 0),
 117       CreateKeyUpEvent(ui::VKEY_Y, 0)};
 118   CheckEventsReleaseModifiers("hey", event_array, arraysize(event_array));
 119 }
 120
 121 TEST(WebDriverKeyConverter, WebDriverSpecialChar) {
 122   WebKeyEvent event_array[] = {
 123       CreateKeyDownEvent(ui::VKEY_SPACE, 0),
 124       CreateCharEvent(" ", " ", 0),
 125       CreateKeyUpEvent(ui::VKEY_SPACE, 0)};
 126   string16 keys;
 127   keys.push_back(static_cast<char16>(0xE00DU));
 128   CheckEventsReleaseModifiers(keys, event_array, arraysize(event_array));
 129 }
 130
 131 TEST(WebDriverKeyConverter, WebDriverSpecialNonCharKey) {
 132   WebKeyEvent event_array[] = {
 133       CreateKeyDownEvent(ui::VKEY_F1, 0),
 134       CreateKeyUpEvent(ui::VKEY_F1, 0)};
 135   string16 keys;
 136   keys.push_back(static_cast<char16>(0xE031U));
 137   CheckEventsReleaseModifiers(keys, event_array, arraysize(event_array));
 138 }
 139
 140 TEST(WebDriverKeyConverter, FrenchKeyOnEnglishLayout) {
 141   WebKeyEvent event_array[] = {
 142       CreateKeyDownEvent(ui::VKEY_UNKNOWN, 0),
 143       CreateCharEvent(WideToUTF8(L"\u00E9"), WideToUTF8(L"\u00E9"), 0),
 144       CreateKeyUpEvent(ui::VKEY_UNKNOWN, 0)};
 145   CheckEventsReleaseModifiers(WideToUTF16(L"\u00E9"),
 146       event_array, arraysize(event_array));
 147 }
 148
 149 #if defined(OS_WIN)
 150 TEST(WebDriverKeyConverter, NeedsCtrlAndAlt) {
 151   RestoreKeyboardLayoutOnDestruct restore;
 152   int ctrl_and_alt = automation::kControlKeyMask | automation::kAltKeyMask;
 153   WebKeyEvent event_array[] = {
 154       CreateKeyDownEvent(ui::VKEY_CONTROL, 0),
 155       CreateKeyDownEvent(ui::VKEY_MENU, 0),
 156       CreateKeyDownEvent(ui::VKEY_Q, ctrl_and_alt),
 157       CreateCharEvent("q", "@", ctrl_and_alt),
 158       CreateKeyUpEvent(ui::VKEY_Q, ctrl_and_alt),
 159       CreateKeyUpEvent(ui::VKEY_MENU, 0),
 160       CreateKeyUpEvent(ui::VKEY_CONTROL, 0)};
 161   ASSERT_TRUE(SwitchKeyboardLayout("00000407"));
 162   CheckEventsReleaseModifiers("@", event_array, arraysize(event_array));
 163 }
 164 #endif
 165
 166 TEST(WebDriverKeyConverter, UppercaseCharDoesShift) {
 167   WebKeyEvent event_array[] = {
 168       CreateKeyDownEvent(ui::VKEY_SHIFT, 0),
 169       CreateKeyDownEvent(ui::VKEY_A, automation::kShiftKeyMask),
 170       CreateCharEvent("a", "A", automation::kShiftKeyMask),
 171       CreateKeyUpEvent(ui::VKEY_A, automation::kShiftKeyMask),
 172       CreateKeyUpEvent(ui::VKEY_SHIFT, 0)};
 173   CheckEventsReleaseModifiers("A", event_array, arraysize(event_array));
 174 }
 175
 176 TEST(WebDriverKeyConverter, UppercaseSymbolCharDoesShift) {
 177   WebKeyEvent event_array[] = {
 178       CreateKeyDownEvent(ui::VKEY_SHIFT, 0),
 179       CreateKeyDownEvent(ui::VKEY_1, automation::kShiftKeyMask),
 180       CreateCharEvent("1", "!", automation::kShiftKeyMask),
 181       CreateKeyUpEvent(ui::VKEY_1, automation::kShiftKeyMask),
 182       CreateKeyUpEvent(ui::VKEY_SHIFT, 0)};
 183   CheckEventsReleaseModifiers("!", event_array, arraysize(event_array));
 184 }
 185
 186 TEST(WebDriverKeyConverter, UppercaseCharUsesShiftOnlyIfNecessary) {
 187   WebKeyEvent event_array[] = {
 188       CreateKeyDownEvent(ui::VKEY_SHIFT, automation::kShiftKeyMask),
 189       CreateKeyDownEvent(ui::VKEY_A, automation::kShiftKeyMask),
 190       CreateCharEvent("a", "A", automation::kShiftKeyMask),
 191       CreateKeyUpEvent(ui::VKEY_A, automation::kShiftKeyMask),
 192       CreateKeyDownEvent(ui::VKEY_B, automation::kShiftKeyMask),
 193       CreateCharEvent("b", "B", automation::kShiftKeyMask),
 194       CreateKeyUpEvent(ui::VKEY_B, automation::kShiftKeyMask),
 195       CreateKeyDownEvent(ui::VKEY_C, automation::kShiftKeyMask),
 196       CreateCharEvent("c", "C", automation::kShiftKeyMask),
 197       CreateKeyUpEvent(ui::VKEY_C, automation::kShiftKeyMask),
 198       CreateKeyUpEvent(ui::VKEY_SHIFT, 0)};
 199   string16 keys;
 200   keys.push_back(static_cast<char16>(0xE008U));
 201   keys.append(UTF8ToUTF16("aBc"));
 202   CheckEventsReleaseModifiers(keys, event_array, arraysize(event_array));
 203 }
 204
 205 TEST(WebDriverKeyConverter, ToggleModifiers) {
 206   WebKeyEvent event_array[] = {
 207       CreateKeyDownEvent(ui::VKEY_SHIFT, automation::kShiftKeyMask),
 208       CreateKeyUpEvent(ui::VKEY_SHIFT, 0),
 209       CreateKeyDownEvent(ui::VKEY_CONTROL, automation::kControlKeyMask),
 210       CreateKeyUpEvent(ui::VKEY_CONTROL, 0),
 211       CreateKeyDownEvent(ui::VKEY_MENU, automation::kAltKeyMask),
 212       CreateKeyUpEvent(ui::VKEY_MENU, 0),
 213       CreateKeyDownEvent(ui::VKEY_COMMAND, automation::kMetaKeyMask),
 214       CreateKeyUpEvent(ui::VKEY_COMMAND, 0)};
 215   string16 keys;
 216   keys.push_back(static_cast<char16>(0xE008U));
 217   keys.push_back(static_cast<char16>(0xE008U));
 218   keys.push_back(static_cast<char16>(0xE009U));
 219   keys.push_back(static_cast<char16>(0xE009U));
 220   keys.push_back(static_cast<char16>(0xE00AU));
 221   keys.push_back(static_cast<char16>(0xE00AU));
 222   keys.push_back(static_cast<char16>(0xE03DU));
 223   keys.push_back(static_cast<char16>(0xE03DU));
 224   CheckEventsReleaseModifiers(keys, event_array, arraysize(event_array));
 225 }
 226
 227 TEST(WebDriverKeyConverter, AllShorthandKeys) {
 228   WebKeyEvent event_array[] = {
 229       CreateKeyDownEvent(ui::VKEY_RETURN, 0),
 230       CreateCharEvent("\r", "\r", 0),
 231       CreateKeyUpEvent(ui::VKEY_RETURN, 0),
 232       CreateKeyDownEvent(ui::VKEY_RETURN, 0),
 233       CreateCharEvent("\r", "\r", 0),
 234       CreateKeyUpEvent(ui::VKEY_RETURN, 0),
 235       CreateKeyDownEvent(ui::VKEY_TAB, 0),
 236 #if defined(USE_AURA)
 237       CreateCharEvent("\t", "\t", 0),
 238 #endif
 239       CreateKeyUpEvent(ui::VKEY_TAB, 0),
 240       CreateKeyDownEvent(ui::VKEY_BACK, 0),
 241 #if defined(USE_AURA)
 242       CreateCharEvent("\b", "\b", 0),
 243 #endif
 244       CreateKeyUpEvent(ui::VKEY_BACK, 0),
 245       CreateKeyDownEvent(ui::VKEY_SPACE, 0),
 246       CreateCharEvent(" ", " ", 0),
 247       CreateKeyUpEvent(ui::VKEY_SPACE, 0)};
 248   CheckEventsReleaseModifiers("\n\r\n\t\b ",
 249       event_array,arraysize(event_array));
 250 }
 251
 252 TEST(WebDriverKeyConverter, AllEnglishKeyboardSymbols) {
 253   string16 keys;
 254   const ui::KeyboardCode kSymbolKeyCodes[] = {
 255       ui::VKEY_OEM_3,
 256       ui::VKEY_OEM_MINUS,
 257       ui::VKEY_OEM_PLUS,
 258       ui::VKEY_OEM_4,
 259       ui::VKEY_OEM_6,
 260       ui::VKEY_OEM_5,
 261       ui::VKEY_OEM_1,
 262       ui::VKEY_OEM_7,
 263       ui::VKEY_OEM_COMMA,
 264       ui::VKEY_OEM_PERIOD,
 265       ui::VKEY_OEM_2};
 266   std::string kLowerSymbols = "`-=[]\\;',./";
 267   std::string kUpperSymbols = "~_+{}|:\"<>?";
 268   for (size_t i = 0; i < kLowerSymbols.length(); ++i)
 269     CheckNonShiftChar(kSymbolKeyCodes[i], kLowerSymbols[i]);
 270   for (size_t i = 0; i < kUpperSymbols.length(); ++i)
 271     CheckShiftChar(kSymbolKeyCodes[i], kUpperSymbols[i], kLowerSymbols[i]);
 272 }
 273
 274 TEST(WebDriverKeyConverter, AllEnglishKeyboardTextChars) {
 275   std::string kLowerChars = "0123456789abcdefghijklmnopqrstuvwxyz";
 276   std::string kUpperChars = ")!@#$%^&*(ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 277   for (size_t i = 0; i < kLowerChars.length(); ++i) {
 278     int offset = 0;
 279     if (i < 10)
 280       offset = ui::VKEY_0;
 281     else
 282       offset = ui::VKEY_0 + 7;
 283     ui::KeyboardCode expected_code = static_cast<ui::KeyboardCode>(offset + i);
 284     CheckNonShiftChar(expected_code, kLowerChars[i]);
 285   }
 286   for (size_t i = 0; i < kUpperChars.length(); ++i) {
 287     int offset = 0;
 288     if (i < 10)
 289       offset = ui::VKEY_0;
 290     else
 291       offset = ui::VKEY_0 + 7;
 292     ui::KeyboardCode expected_code = static_cast<ui::KeyboardCode>(offset + i);
 293     CheckShiftChar(expected_code, kUpperChars[i], kLowerChars[i]);
 294   }
 295 }
 296
 297 TEST(WebDriverKeyConverter, AllSpecialWebDriverKeysOnEnglishKeyboard) {
 298   const char kTextForKeys[] = {
 299 #if defined(USE_AURA)
 300       0, 0, 0, '\b', '\t', 0, '\r', '\r', 0, 0, 0, 0, 0x1B,
 301       ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x7F, ';', '=',
 302 #else
 303       0, 0, 0, 0, 0, 0, '\r', '\r', 0, 0, 0, 0, 0,
 304       ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ';', '=',
 305 #endif
 306       '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 307       '*', '+', ',', '-', '.', '/'};
 308   for (size_t i = 0; i <= 0x3D; ++i) {
 309     if (i > 0x29 && i < 0x31)
 310       continue;
 311     string16 keys;
 312     int modifiers = 0;
 313     keys.push_back(0xE000U + i);
 314     std::vector<WebKeyEvent> events;
 315     std::string error_msg;
 316     if (i == 1) {
 317       EXPECT_FALSE(ConvertKeysToWebKeyEvents(keys, Logger(),
 318                                              true /* release_modifiers*/,
 319                                              &modifiers, &events, &error_msg))
 320           << "Index: " << i;
 321       EXPECT_EQ(0u, events.size()) << "Index: " << i;
 322     } else {
 323       EXPECT_TRUE(ConvertKeysToWebKeyEvents(keys, Logger(),
 324                                             true /* release_modifiers */,
 325                                             &modifiers, &events, &error_msg))
 326           << "Index: " << i;
 327       if (i == 0) {
 328         EXPECT_EQ(0u, events.size()) << "Index: " << i;
 329       } else if (i >= arraysize(kTextForKeys) || kTextForKeys[i] == 0) {
 330         EXPECT_EQ(2u, events.size()) << "Index: " << i;
 331       } else {
 332         ASSERT_EQ(3u, events.size()) << "Index: " << i;
 333         ASSERT_EQ(1u, events[1].unmodified_text.length()) << "Index: " << i;
 334         EXPECT_EQ(kTextForKeys[i], events[1].unmodified_text[0])
 335             << "Index: " << i;
 336       }
 337     }
 338   }
 339 }
 340
 341 TEST(WebDriverKeyConverter, ModifiersState) {
 342   int shift_key_modifier = automation::kShiftKeyMask;
 343   int control_key_modifier = shift_key_modifier | automation::kControlKeyMask;
 344   int alt_key_modifier = control_key_modifier | automation::kAltKeyMask;
 345   int meta_key_modifier = alt_key_modifier | automation::kMetaKeyMask;
 346   WebKeyEvent event_array[] = {
 347       CreateKeyDownEvent(ui::VKEY_SHIFT, shift_key_modifier),
 348       CreateKeyDownEvent(ui::VKEY_CONTROL, control_key_modifier),
 349       CreateKeyDownEvent(ui::VKEY_MENU, alt_key_modifier),
 350       CreateKeyDownEvent(ui::VKEY_COMMAND, meta_key_modifier)};
 351   string16 keys;
 352   keys.push_back(static_cast<char16>(0xE008U));
 353   keys.push_back(static_cast<char16>(0xE009U));
 354   keys.push_back(static_cast<char16>(0xE00AU));
 355   keys.push_back(static_cast<char16>(0xE03DU));
 356
 357   CheckEvents(keys, event_array, false /* release_modifiers */,
 358       arraysize(event_array), meta_key_modifier);
 359 }
 360
 361 TEST(WebDriverKeyConverter, ReleaseModifiers) {
 362   WebKeyEvent event_array[] = {
 363       CreateKeyDownEvent(ui::VKEY_SHIFT, automation::kShiftKeyMask),
 364       CreateKeyDownEvent(ui::VKEY_CONTROL,
 365           automation::kShiftKeyMask | automation::kControlKeyMask),
 366       CreateKeyUpEvent(ui::VKEY_SHIFT, 0),
 367       CreateKeyUpEvent(ui::VKEY_CONTROL, 0)};
 368   string16 keys;
 369   keys.push_back(static_cast<char16>(0xE008U));
 370   keys.push_back(static_cast<char16>(0xE009U));
 371
 372   CheckEvents(keys, event_array, true /* release_modifiers */,
 373       arraysize(event_array), 0);
 374 }
 375
 376 }  // namespace webdriver