third_party/WebKit/Source/web/tests/KeyboardTest.cpp

   1 /*
   2  * Copyright (C) 2010 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32
  33 #include "core/editing/EditingBehavior.h"
  34 #include "core/editing/Editor.h"
  35 #include "core/events/EventTarget.h"
  36 #include "core/events/KeyboardEvent.h"
  37 #include "core/frame/Settings.h"
  38 #include "platform/KeyboardCodes.h"
  39 #include "public/web/WebInputEvent.h"
  40 #include "web/WebInputEventConversion.h"
  41 #include <gtest/gtest.h>
  42
  43 namespace blink {
  44
  45 class KeyboardTest : public testing::Test {
  46 public:
  47
  48     // Pass a WebKeyboardEvent into the EditorClient and get back the string
  49     // name of which editing event that key causes.
  50     // E.g., sending in the enter key gives back "InsertNewline".
  51     const char* interpretKeyEvent(
  52         const WebKeyboardEvent& webKeyboardEvent,
  53         PlatformEvent::Type keyType)
  54     {
  55         PlatformKeyboardEventBuilder evt(webKeyboardEvent);
  56         evt.setKeyType(keyType);
  57         RefPtrWillBeRawPtr<KeyboardEvent> keyboardEvent = KeyboardEvent::create(evt, 0);
  58         OwnPtr<Settings> settings = Settings::create();
  59         EditingBehavior behavior(settings->editingBehaviorType());
  60         return behavior.interpretKeyEvent(*keyboardEvent);
  61     }
  62
  63     // Set up a WebKeyboardEvent KEY_DOWN event with key code and modifiers.
  64     void setupKeyDownEvent(WebKeyboardEvent* keyboardEvent,
  65                            char keyCode,
  66                            int modifiers)
  67     {
  68         keyboardEvent->windowsKeyCode = keyCode;
  69         keyboardEvent->modifiers = modifiers;
  70         keyboardEvent->type = WebInputEvent::KeyDown;
  71         keyboardEvent->text[0] = keyCode;
  72         keyboardEvent->setKeyIdentifierFromWindowsKeyCode();
  73     }
  74
  75     // Like interpretKeyEvent, but with pressing down OSModifier+|keyCode|.
  76     // OSModifier is the platform's standard modifier key: control on most
  77     // platforms, but meta (command) on Mac.
  78     const char* interpretOSModifierKeyPress(char keyCode)
  79     {
  80         WebKeyboardEvent keyboardEvent;
  81 #if OS(MACOSX)
  82         WebInputEvent::Modifiers osModifier = WebInputEvent::MetaKey;
  83 #else
  84         WebInputEvent::Modifiers osModifier = WebInputEvent::ControlKey;
  85 #endif
  86         setupKeyDownEvent(&keyboardEvent, keyCode, osModifier);
  87         return interpretKeyEvent(keyboardEvent, PlatformEvent::RawKeyDown);
  88     }
  89
  90     // Like interpretKeyEvent, but with pressing down ctrl+|keyCode|.
  91     const char* interpretCtrlKeyPress(char keyCode)
  92     {
  93         WebKeyboardEvent keyboardEvent;
  94         setupKeyDownEvent(&keyboardEvent, keyCode, WebInputEvent::ControlKey);
  95         return interpretKeyEvent(keyboardEvent, PlatformEvent::RawKeyDown);
  96     }
  97
  98     // Like interpretKeyEvent, but with typing a tab.
  99     const char* interpretTab(int modifiers)
 100     {
 101         WebKeyboardEvent keyboardEvent;
 102         setupKeyDownEvent(&keyboardEvent, '\t', modifiers);
 103         return interpretKeyEvent(keyboardEvent, PlatformEvent::Char);
 104     }
 105
 106     // Like interpretKeyEvent, but with typing a newline.
 107     const char* interpretNewLine(int modifiers)
 108     {
 109         WebKeyboardEvent keyboardEvent;
 110         setupKeyDownEvent(&keyboardEvent, '\r', modifiers);
 111         return interpretKeyEvent(keyboardEvent, PlatformEvent::Char);
 112     }
 113
 114     // A name for "no modifiers set".
 115     static const int noModifiers = 0;
 116 };
 117
 118 TEST_F(KeyboardTest, TestCtrlReturn)
 119 {
 120     EXPECT_STREQ("InsertNewline", interpretCtrlKeyPress(0xD));
 121 }
 122
 123 TEST_F(KeyboardTest, TestOSModifierZ)
 124 {
 125 #if !OS(MACOSX)
 126     EXPECT_STREQ("Undo", interpretOSModifierKeyPress('Z'));
 127 #endif
 128 }
 129
 130 TEST_F(KeyboardTest, TestOSModifierY)
 131 {
 132 #if !OS(MACOSX)
 133     EXPECT_STREQ("Redo", interpretOSModifierKeyPress('Y'));
 134 #endif
 135 }
 136
 137 TEST_F(KeyboardTest, TestOSModifierA)
 138 {
 139 #if !OS(MACOSX)
 140     EXPECT_STREQ("SelectAll", interpretOSModifierKeyPress('A'));
 141 #endif
 142 }
 143
 144 TEST_F(KeyboardTest, TestOSModifierX)
 145 {
 146 #if !OS(MACOSX)
 147     EXPECT_STREQ("Cut", interpretOSModifierKeyPress('X'));
 148 #endif
 149 }
 150
 151 TEST_F(KeyboardTest, TestOSModifierC)
 152 {
 153 #if !OS(MACOSX)
 154     EXPECT_STREQ("Copy", interpretOSModifierKeyPress('C'));
 155 #endif
 156 }
 157
 158 TEST_F(KeyboardTest, TestOSModifierV)
 159 {
 160 #if !OS(MACOSX)
 161     EXPECT_STREQ("Paste", interpretOSModifierKeyPress('V'));
 162 #endif
 163 }
 164
 165 TEST_F(KeyboardTest, TestEscape)
 166 {
 167     WebKeyboardEvent keyboardEvent;
 168     setupKeyDownEvent(&keyboardEvent, VKEY_ESCAPE, noModifiers);
 169
 170     const char* result = interpretKeyEvent(keyboardEvent,
 171                                            PlatformEvent::RawKeyDown);
 172     EXPECT_STREQ("Cancel", result);
 173 }
 174
 175 TEST_F(KeyboardTest, TestInsertTab)
 176 {
 177     EXPECT_STREQ("InsertTab", interpretTab(noModifiers));
 178 }
 179
 180 TEST_F(KeyboardTest, TestInsertBackTab)
 181 {
 182     EXPECT_STREQ("InsertBacktab", interpretTab(WebInputEvent::ShiftKey));
 183 }
 184
 185 TEST_F(KeyboardTest, TestInsertNewline)
 186 {
 187     EXPECT_STREQ("InsertNewline", interpretNewLine(noModifiers));
 188 }
 189
 190 TEST_F(KeyboardTest, TestInsertNewline2)
 191 {
 192     EXPECT_STREQ("InsertNewline", interpretNewLine(WebInputEvent::ControlKey));
 193 }
 194
 195 TEST_F(KeyboardTest, TestInsertLineBreak)
 196 {
 197     EXPECT_STREQ("InsertLineBreak", interpretNewLine(WebInputEvent::ShiftKey));
 198 }
 199
 200 TEST_F(KeyboardTest, TestInsertNewline3)
 201 {
 202     EXPECT_STREQ("InsertNewline", interpretNewLine(WebInputEvent::AltKey));
 203 }
 204
 205 TEST_F(KeyboardTest, TestInsertNewline4)
 206 {
 207     int modifiers = WebInputEvent::AltKey | WebInputEvent::ShiftKey;
 208     const char* result = interpretNewLine(modifiers);
 209     EXPECT_STREQ("InsertNewline", result);
 210 }
 211
 212 } // namespace blink