| OLD | NEW |
|---|
| (Empty) |
| 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 "testing/gtest/include/gtest/gtest.h" | |
| 6 #include "ui/base/events/event.h" | |
| 7 | |
| 8 #if defined(USE_X11) | |
| 9 #include <X11/Xlib.h> | |
| 10 #include "ui/base/x/x11_util.h" | |
| 11 #endif | |
| 12 | |
| 13 namespace ui { | |
| 14 | |
| 15 TEST(EventTest, NoNativeEvent) { | |
| 16 KeyEvent keyev(ET_KEY_PRESSED, VKEY_SPACE, 0); | |
| 17 EXPECT_FALSE(keyev.HasNativeEvent()); | |
| 18 } | |
| 19 | |
| 20 TEST(EventTest, NativeEvent) { | |
| 21 #if defined(OS_WIN) | |
| 22 MSG native_event = { NULL, WM_KEYUP, VKEY_A, 0 }; | |
| 23 KeyEvent keyev(native_event, false); | |
| 24 EXPECT_TRUE(keyev.HasNativeEvent()); | |
| 25 #elif defined(USE_X11) | |
| 26 scoped_ptr<XEvent> native_event(new XEvent); | |
| 27 InitXKeyEventForTesting(ET_KEY_RELEASED, VKEY_A, 0, native_event.get()); | |
| 28 KeyEvent keyev(native_event.get(), false); | |
| 29 EXPECT_TRUE(keyev.HasNativeEvent()); | |
| 30 #endif | |
| 31 } | |
| 32 | |
| 33 TEST(EventTest, GetCharacter) { | |
| 34 // Check if Control+Enter returns 10. | |
| 35 KeyEvent keyev1(ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN); | |
| 36 EXPECT_EQ(10, keyev1.GetCharacter()); | |
| 37 EXPECT_EQ(13, keyev1.GetUnmodifiedCharacter()); | |
| 38 // Check if Enter returns 13. | |
| 39 KeyEvent keyev2(ET_KEY_PRESSED, VKEY_RETURN, 0); | |
| 40 EXPECT_EQ(13, keyev2.GetCharacter()); | |
| 41 EXPECT_EQ(13, keyev2.GetUnmodifiedCharacter()); | |
| 42 | |
| 43 #if defined(USE_X11) | |
| 44 // For X11, test the functions with native_event() as well. crbug.com/107837 | |
| 45 scoped_ptr<XEvent> native_event(new XEvent); | |
| 46 | |
| 47 InitXKeyEventForTesting(ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN, | |
| 48 native_event.get()); | |
| 49 KeyEvent keyev3(native_event.get(), false); | |
| 50 EXPECT_EQ(10, keyev3.GetCharacter()); | |
| 51 EXPECT_EQ(13, keyev3.GetUnmodifiedCharacter()); | |
| 52 | |
| 53 InitXKeyEventForTesting(ET_KEY_PRESSED, VKEY_RETURN, 0, native_event.get()); | |
| 54 KeyEvent keyev4(native_event.get(), false); | |
| 55 EXPECT_EQ(13, keyev4.GetCharacter()); | |
| 56 EXPECT_EQ(13, keyev4.GetUnmodifiedCharacter()); | |
| 57 #endif | |
| 58 } | |
| 59 | |
| 60 TEST(EventTest, ClickCount) { | |
| 61 const gfx::Point origin(0, 0); | |
| 62 MouseEvent mouseev(ET_MOUSE_PRESSED, origin, origin, 0); | |
| 63 for (int i = 1; i <=3 ; ++i) { | |
| 64 mouseev.SetClickCount(i); | |
| 65 EXPECT_EQ(i, mouseev.GetClickCount()); | |
| 66 } | |
| 67 } | |
| 68 | |
| 69 TEST(EventTest, Repeated) { | |
| 70 const gfx::Point origin(0, 0); | |
| 71 MouseEvent mouse_ev1(ET_MOUSE_PRESSED, origin, origin, 0); | |
| 72 MouseEvent mouse_ev2(ET_MOUSE_PRESSED, origin, origin, 0); | |
| 73 MouseEvent::TestApi test_ev1(&mouse_ev1); | |
| 74 MouseEvent::TestApi test_ev2(&mouse_ev2); | |
| 75 | |
| 76 base::TimeDelta start = base::TimeDelta::FromMilliseconds(0); | |
| 77 base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1); | |
| 78 base::TimeDelta later = start + base::TimeDelta::FromMilliseconds(1000); | |
| 79 | |
| 80 // Close point. | |
| 81 test_ev1.set_location(gfx::Point(0, 0)); | |
| 82 test_ev2.set_location(gfx::Point(1, 0)); | |
| 83 test_ev1.set_time_stamp(start); | |
| 84 test_ev2.set_time_stamp(soon); | |
| 85 EXPECT_TRUE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2)); | |
| 86 | |
| 87 // Too far. | |
| 88 test_ev1.set_location(gfx::Point(0, 0)); | |
| 89 test_ev2.set_location(gfx::Point(10, 0)); | |
| 90 test_ev1.set_time_stamp(start); | |
| 91 test_ev2.set_time_stamp(soon); | |
| 92 EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2)); | |
| 93 | |
| 94 // Too long a time between clicks. | |
| 95 test_ev1.set_location(gfx::Point(0, 0)); | |
| 96 test_ev2.set_location(gfx::Point(0, 0)); | |
| 97 test_ev1.set_time_stamp(start); | |
| 98 test_ev2.set_time_stamp(later); | |
| 99 EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2)); | |
| 100 } | |
| 101 | |
| 102 // Bug 99129. | |
| 103 #if defined(USE_AURA) | |
| 104 #define MAYBE_KeyEvent FAILS_KeyEvent | |
| 105 #define MAYBE_KeyEventDirectUnicode FAILS_KeyEventDirectUnicode | |
| 106 #else | |
| 107 #define MAYBE_KeyEvent KeyEvent | |
| 108 #define MAYBE_KeyEventDirectUnicode KeyEventDirectUnicode | |
| 109 #endif | |
| 110 | |
| 111 TEST(EventTest, MAYBE_KeyEvent) { | |
| 112 static const struct { | |
| 113 KeyboardCode key_code; | |
| 114 int flags; | |
| 115 uint16 character; | |
| 116 uint16 unmodified_character; | |
| 117 } kTestData[] = { | |
| 118 { VKEY_A, 0, 'a', 'a' }, | |
| 119 { VKEY_A, EF_SHIFT_DOWN, 'A', 'A' }, | |
| 120 { VKEY_A, EF_CAPS_LOCK_DOWN, 'A', 'a' }, | |
| 121 { VKEY_A, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, 'a', 'A' }, | |
| 122 { VKEY_A, EF_CONTROL_DOWN, 0x01, 'a' }, | |
| 123 { VKEY_A, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x01', 'A' }, | |
| 124 { VKEY_Z, 0, 'z', 'z' }, | |
| 125 { VKEY_Z, EF_SHIFT_DOWN, 'Z', 'Z' }, | |
| 126 { VKEY_Z, EF_CAPS_LOCK_DOWN, 'Z', 'z' }, | |
| 127 { VKEY_Z, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, 'z', 'Z' }, | |
| 128 { VKEY_Z, EF_CONTROL_DOWN, '\x1A', 'z' }, | |
| 129 { VKEY_Z, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x1A', 'Z' }, | |
| 130 | |
| 131 { VKEY_2, EF_CONTROL_DOWN, '\0', '2' }, | |
| 132 { VKEY_2, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0', '@' }, | |
| 133 { VKEY_6, EF_CONTROL_DOWN, '\0', '6' }, | |
| 134 { VKEY_6, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x1E', '^' }, | |
| 135 { VKEY_OEM_MINUS, EF_CONTROL_DOWN, '\0', '-' }, | |
| 136 { VKEY_OEM_MINUS, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x1F', '_'}, | |
| 137 { VKEY_OEM_4, EF_CONTROL_DOWN, '\x1B', '[' }, | |
| 138 { VKEY_OEM_4, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0', '{' }, | |
| 139 { VKEY_OEM_5, EF_CONTROL_DOWN, '\x1C', '\\' }, | |
| 140 { VKEY_OEM_5, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0', '|' }, | |
| 141 { VKEY_OEM_6, EF_CONTROL_DOWN, '\x1D', ']' }, | |
| 142 { VKEY_OEM_6, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0', '}' }, | |
| 143 { VKEY_RETURN, EF_CONTROL_DOWN, '\x0A', '\r' }, | |
| 144 | |
| 145 { VKEY_0, 0, '0', '0' }, | |
| 146 { VKEY_0, EF_SHIFT_DOWN, ')', ')' }, | |
| 147 { VKEY_0, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, ')', ')' }, | |
| 148 { VKEY_0, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0', ')' }, | |
| 149 | |
| 150 { VKEY_9, 0, '9', '9' }, | |
| 151 { VKEY_9, EF_SHIFT_DOWN, '(', '(' }, | |
| 152 { VKEY_9, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, '(', '(' }, | |
| 153 { VKEY_9, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0', '(' }, | |
| 154 | |
| 155 { VKEY_NUMPAD0, EF_CONTROL_DOWN, '\0', '0' }, | |
| 156 { VKEY_NUMPAD0, EF_SHIFT_DOWN, '0', '0' }, | |
| 157 | |
| 158 { VKEY_NUMPAD9, EF_CONTROL_DOWN, '\0', '9' }, | |
| 159 { VKEY_NUMPAD9, EF_SHIFT_DOWN, '9', '9' }, | |
| 160 | |
| 161 { VKEY_TAB, EF_CONTROL_DOWN, '\0', '\t' }, | |
| 162 { VKEY_TAB, EF_SHIFT_DOWN, '\t', '\t' }, | |
| 163 | |
| 164 { VKEY_MULTIPLY, EF_CONTROL_DOWN, '\0', '*' }, | |
| 165 { VKEY_MULTIPLY, EF_SHIFT_DOWN, '*', '*' }, | |
| 166 { VKEY_ADD, EF_CONTROL_DOWN, '\0', '+' }, | |
| 167 { VKEY_ADD, EF_SHIFT_DOWN, '+', '+' }, | |
| 168 { VKEY_SUBTRACT, EF_CONTROL_DOWN, '\0', '-' }, | |
| 169 { VKEY_SUBTRACT, EF_SHIFT_DOWN, '-', '-' }, | |
| 170 { VKEY_DECIMAL, EF_CONTROL_DOWN, '\0', '.' }, | |
| 171 { VKEY_DECIMAL, EF_SHIFT_DOWN, '.', '.' }, | |
| 172 { VKEY_DIVIDE, EF_CONTROL_DOWN, '\0', '/' }, | |
| 173 { VKEY_DIVIDE, EF_SHIFT_DOWN, '/', '/' }, | |
| 174 | |
| 175 { VKEY_OEM_1, EF_CONTROL_DOWN, '\0', ';' }, | |
| 176 { VKEY_OEM_1, EF_SHIFT_DOWN, ':', ':' }, | |
| 177 { VKEY_OEM_PLUS, EF_CONTROL_DOWN, '\0', '=' }, | |
| 178 { VKEY_OEM_PLUS, EF_SHIFT_DOWN, '+', '+' }, | |
| 179 { VKEY_OEM_COMMA, EF_CONTROL_DOWN, '\0', ',' }, | |
| 180 { VKEY_OEM_COMMA, EF_SHIFT_DOWN, '<', '<' }, | |
| 181 { VKEY_OEM_PERIOD, EF_CONTROL_DOWN, '\0', '.' }, | |
| 182 { VKEY_OEM_PERIOD, EF_SHIFT_DOWN, '>', '>' }, | |
| 183 { VKEY_OEM_3, EF_CONTROL_DOWN, '\0', '`' }, | |
| 184 { VKEY_OEM_3, EF_SHIFT_DOWN, '~', '~' }, | |
| 185 }; | |
| 186 | |
| 187 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestData); ++i) { | |
| 188 KeyEvent key(ET_KEY_PRESSED, kTestData[i].key_code, kTestData[i].flags); | |
| 189 EXPECT_EQ(kTestData[i].character, key.GetCharacter()) | |
| 190 << " Index:" << i << " key_code:" << kTestData[i].key_code; | |
| 191 EXPECT_EQ(kTestData[i].unmodified_character, key.GetUnmodifiedCharacter()) | |
| 192 << " Index:" << i << " key_code:" << kTestData[i].key_code; | |
| 193 } | |
| 194 } | |
| 195 | |
| 196 TEST(EventTest, MAYBE_KeyEventDirectUnicode) { | |
| 197 KeyEvent key(ET_KEY_PRESSED, VKEY_UNKNOWN, EF_SHIFT_DOWN); | |
| 198 key.set_character(0x1234U); | |
| 199 key.set_unmodified_character(0x4321U); | |
| 200 EXPECT_EQ(0x1234U, key.GetCharacter()); | |
| 201 EXPECT_EQ(0x4321U, key.GetUnmodifiedCharacter()); | |
| 202 KeyEvent key2(ET_KEY_RELEASED, VKEY_UNKNOWN, EF_CONTROL_DOWN); | |
| 203 key2.set_character(0x4321U); | |
| 204 key2.set_unmodified_character(0x1234U); | |
| 205 EXPECT_EQ(0x4321U, key2.GetCharacter()); | |
| 206 EXPECT_EQ(0x1234U, key2.GetUnmodifiedCharacter()); | |
| 207 } | |
| 208 | |
| 209 TEST(EventTest, NormalizeKeyEventFlags) { | |
| 210 #if defined(USE_X11) | |
| 211 // Normalize flags when KeyEvent is created from XEvent. | |
| 212 { | |
| 213 scoped_ptr<XEvent> native_event(new XEvent); | |
| 214 InitXKeyEventForTesting(ET_KEY_PRESSED, VKEY_SHIFT, EF_SHIFT_DOWN, | |
| 215 native_event.get()); | |
| 216 KeyEvent keyev(native_event.get(), false); | |
| 217 EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags()); | |
| 218 } | |
| 219 { | |
| 220 scoped_ptr<XEvent> native_event(new XEvent); | |
| 221 InitXKeyEventForTesting(ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN, | |
| 222 native_event.get()); | |
| 223 KeyEvent keyev(native_event.get(), false); | |
| 224 EXPECT_EQ(EF_NONE, keyev.flags()); | |
| 225 } | |
| 226 { | |
| 227 scoped_ptr<XEvent> native_event(new XEvent); | |
| 228 InitXKeyEventForTesting(ET_KEY_PRESSED, VKEY_CONTROL, EF_CONTROL_DOWN, | |
| 229 native_event.get()); | |
| 230 KeyEvent keyev(native_event.get(), false); | |
| 231 EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags()); | |
| 232 } | |
| 233 { | |
| 234 scoped_ptr<XEvent> native_event(new XEvent); | |
| 235 InitXKeyEventForTesting(ET_KEY_RELEASED, VKEY_CONTROL, EF_CONTROL_DOWN, | |
| 236 native_event.get()); | |
| 237 KeyEvent keyev(native_event.get(), false); | |
| 238 EXPECT_EQ(EF_NONE, keyev.flags()); | |
| 239 } | |
| 240 { | |
| 241 scoped_ptr<XEvent> native_event(new XEvent); | |
| 242 InitXKeyEventForTesting(ET_KEY_PRESSED, VKEY_MENU, EF_ALT_DOWN, | |
| 243 native_event.get()); | |
| 244 KeyEvent keyev(native_event.get(), false); | |
| 245 EXPECT_EQ(EF_ALT_DOWN, keyev.flags()); | |
| 246 } | |
| 247 { | |
| 248 scoped_ptr<XEvent> native_event(new XEvent); | |
| 249 InitXKeyEventForTesting(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN, | |
| 250 native_event.get()); | |
| 251 KeyEvent keyev(native_event.get(), false); | |
| 252 EXPECT_EQ(EF_NONE, keyev.flags()); | |
| 253 } | |
| 254 #endif | |
| 255 | |
| 256 // Do not normalize flags for synthesized events without | |
| 257 // KeyEvent::NormalizeFlags called explicitly. | |
| 258 { | |
| 259 KeyEvent keyev(ET_KEY_PRESSED, VKEY_SHIFT, EF_SHIFT_DOWN); | |
| 260 EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags()); | |
| 261 } | |
| 262 { | |
| 263 KeyEvent keyev(ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN); | |
| 264 EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags()); | |
| 265 keyev.NormalizeFlags(); | |
| 266 EXPECT_EQ(EF_NONE, keyev.flags()); | |
| 267 } | |
| 268 { | |
| 269 KeyEvent keyev(ET_KEY_PRESSED, VKEY_CONTROL, EF_CONTROL_DOWN); | |
| 270 EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags()); | |
| 271 } | |
| 272 { | |
| 273 KeyEvent keyev(ET_KEY_RELEASED, VKEY_CONTROL, EF_CONTROL_DOWN); | |
| 274 EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags()); | |
| 275 keyev.NormalizeFlags(); | |
| 276 EXPECT_EQ(EF_NONE, keyev.flags()); | |
| 277 } | |
| 278 { | |
| 279 KeyEvent keyev(ET_KEY_PRESSED, VKEY_MENU, EF_ALT_DOWN); | |
| 280 EXPECT_EQ(EF_ALT_DOWN, keyev.flags()); | |
| 281 } | |
| 282 { | |
| 283 KeyEvent keyev(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN); | |
| 284 EXPECT_EQ(EF_ALT_DOWN, keyev.flags()); | |
| 285 keyev.NormalizeFlags(); | |
| 286 EXPECT_EQ(EF_NONE, keyev.flags()); | |
| 287 } | |
| 288 } | |
| 289 | |
| 290 } // namespace ui | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10908127:
events: Move EventTarget into Event. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src