Small test and ChromeDriver fixes to enable additional tests.

chrome/test/webdriver/webdriver_key_converter_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 #include <vector>
 
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/test/automation/automation_json_requests.h"
 #include "chrome/test/webdriver/webdriver_key_converter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace webdriver {
 
 void CheckEvents(const string16& keys,
                  WebKeyEvent expected_events[],
                  size_t expected_size) {
   std::vector<WebKeyEvent> events;
-  ConvertKeysToWebKeyEvents(keys, &events);
+  std::string error_msg;
+  EXPECT_TRUE(ConvertKeysToWebKeyEvents(keys, &events, &error_msg));
   EXPECT_EQ(expected_size, events.size());
   for (size_t i = 0; i < events.size() && i < expected_size; ++i) {
     EXPECT_EQ(expected_events[i].type, events[i].type);
     EXPECT_EQ(expected_events[i].key_code, events[i].key_code);
     EXPECT_EQ(expected_events[i].unmodified_text, events[i].unmodified_text);
     EXPECT_EQ(expected_events[i].modified_text, events[i].modified_text);
     EXPECT_EQ(expected_events[i].modifiers, events[i].modifiers);
   }
 }
 
 void CheckEvents(const std::string& keys,
                  WebKeyEvent expected_events[],
                  size_t expected_size) {
   CheckEvents(UTF8ToUTF16(keys), expected_events, expected_size);
 }
 
 void CheckNonShiftChar(ui::KeyboardCode key_code, char character) {
   std::string char_string;
   char_string.push_back(character);
   std::vector<WebKeyEvent> events;
-  ConvertKeysToWebKeyEvents(ASCIIToUTF16(char_string), &events);
+  std::string error_msg;
+  EXPECT_TRUE(ConvertKeysToWebKeyEvents(ASCIIToUTF16(char_string), &events,
+                                        &error_msg));
   ASSERT_EQ(3u, events.size()) << "Char: " << character;
   EXPECT_EQ(key_code, events[0].key_code) << "Char: " << character;
   ASSERT_EQ(1u, events[1].modified_text.length()) << "Char: " << character;
   ASSERT_EQ(1u, events[1].unmodified_text.length()) << "Char: " << character;
   EXPECT_EQ(character, events[1].modified_text[0]) << "Char: " << character;
   EXPECT_EQ(character, events[1].unmodified_text[0]) << "Char: " << character;
   EXPECT_EQ(key_code, events[2].key_code) << "Char: " << character;
 }
 
 void CheckShiftChar(ui::KeyboardCode key_code, char character, char lower) {
   std::string char_string;
   char_string.push_back(character);
   std::vector<WebKeyEvent> events;
-  ConvertKeysToWebKeyEvents(ASCIIToUTF16(char_string), &events);
+  std::string error_msg;
+  EXPECT_TRUE(ConvertKeysToWebKeyEvents(ASCIIToUTF16(char_string), &events,
+                                        &error_msg));
   ASSERT_EQ(5u, events.size()) << "Char: " << character;
   EXPECT_EQ(ui::VKEY_SHIFT, events[0].key_code) << "Char: " << character;
   EXPECT_EQ(key_code, events[1].key_code) << "Char: " << character;
   ASSERT_EQ(1u, events[2].modified_text.length()) << "Char: " << character;
   ASSERT_EQ(1u, events[2].unmodified_text.length()) << "Char: " << character;
   EXPECT_EQ(character, events[2].modified_text[0]) << "Char: " << character;
   EXPECT_EQ(lower, events[2].unmodified_text[0]) << "Char: " << character;
   EXPECT_EQ(key_code, events[3].key_code) << "Char: " << character;
   EXPECT_EQ(ui::VKEY_SHIFT, events[4].key_code) << "Char: " << character;
 }
@@ skipping 123 matching lines @@
   keys.push_back(static_cast<char16>(0xE008U));
   keys.push_back(static_cast<char16>(0xE009U));
   keys.push_back(static_cast<char16>(0xE009U));
   keys.push_back(static_cast<char16>(0xE00AU));
   keys.push_back(static_cast<char16>(0xE00AU));
   keys.push_back(static_cast<char16>(0xE03DU));
   keys.push_back(static_cast<char16>(0xE03DU));
   CheckEvents(keys, event_array, arraysize(event_array));
 }
 
+TEST(WebDriverKeyConverter, AllShorthandKeys) {
+  WebKeyEvent event_array[] = {
+      CreateKeyDownEvent(ui::VKEY_RETURN, 0),
+      CreateCharEvent("\r", "\r", 0),
+      CreateKeyUpEvent(ui::VKEY_RETURN, 0),
+      CreateKeyDownEvent(ui::VKEY_RETURN, 0),
+      CreateCharEvent("\r", "\r", 0),
+      CreateKeyUpEvent(ui::VKEY_RETURN, 0),
+      CreateKeyDownEvent(ui::VKEY_TAB, 0),
+      CreateKeyUpEvent(ui::VKEY_TAB, 0),
+      CreateKeyDownEvent(ui::VKEY_BACK, 0),
+      CreateKeyUpEvent(ui::VKEY_BACK, 0),
+      CreateKeyDownEvent(ui::VKEY_SPACE, 0),
+      CreateCharEvent(" ", " ", 0),
+      CreateKeyUpEvent(ui::VKEY_SPACE, 0)};
+  CheckEvents("\n\r\n\t\b ", event_array, arraysize(event_array));
+}
+
 TEST(WebDriverKeyConverter, AllEnglishKeyboardSymbols) {
   string16 keys;
   const ui::KeyboardCode kSymbolKeyCodes[] = {
       ui::VKEY_OEM_3,
       ui::VKEY_OEM_MINUS,
       ui::VKEY_OEM_PLUS,
       ui::VKEY_OEM_4,
       ui::VKEY_OEM_6,
       ui::VKEY_OEM_5,
       ui::VKEY_OEM_1,
@@ skipping 27 matching lines @@
       offset = ui::VKEY_0;
     else
       offset = ui::VKEY_0 + 7;
     ui::KeyboardCode expected_code = static_cast<ui::KeyboardCode>(offset + i);
     CheckShiftChar(expected_code, kUpperChars[i], kLowerChars[i]);
   }
 }
 
 TEST(WebDriverKeyConverter, AllSpecialWebDriverKeysOnEnglishKeyboard) {
   const char kTextKeys[] = {
-      ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ';', '=', '0', '1', '2', '3', '4', '5',
-      '6', '7', '8', '9', '*', '+', ',', '-', '.', '/'};
+      0, 0, 0, 0, 0, 0, '\r', '\r', 0, 0, 0, 0, 0, ' ', 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, ';', '=', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+      '*', '+', ',', '-', '.', '/'};
   for (size_t i = 0; i <= 0x3D; ++i) {
     if (i > 0x29 && i < 0x31)
       continue;
     string16 keys;
     keys.push_back(0xE000U + i);
     std::vector<WebKeyEvent> events;
-    ConvertKeysToWebKeyEvents(keys, &events);
-    if (i == 0xD || (i >= 0x18 && i <= 0x29)) {
-      ASSERT_EQ(3u, events.size()) << "Index: " << i;
-      ASSERT_EQ(1u, events[1].unmodified_text.length()) << "Index: " << i;
-      EXPECT_EQ(kTextKeys[i - 0xD], events[1].unmodified_text[0])
+    std::string error_msg;
+    if (i == 1) {
+      EXPECT_FALSE(ConvertKeysToWebKeyEvents(keys, &events, &error_msg))
           << "Index: " << i;
-    } else if (i < 2) {
       EXPECT_EQ(0u, events.size()) << "Index: " << i;
     } else {
-      EXPECT_EQ(2u, events.size()) << "Index: " << i;
+      EXPECT_TRUE(ConvertKeysToWebKeyEvents(keys, &events, &error_msg))
+          << "Index: " << i;
+      if (i == 0) {
+        EXPECT_EQ(0u, events.size()) << "Index: " << i;
+      } else if (i == 6 || i == 7 || i == 0xD || (i >= 0x18 && i <= 0x29)) {
+        ASSERT_EQ(3u, events.size()) << "Index: " << i;
+        ASSERT_EQ(1u, events[1].unmodified_text.length()) << "Index: " << i;
+        EXPECT_EQ(kTextKeys[i], events[1].unmodified_text[0])
+            << "Index: " << i;
+      } else {
+        EXPECT_EQ(2u, events.size()) << "Index: " << i;
+      }
     }
   }
 }
 
 }  // namespace webdriver