Updating trunk VERSION from 2139.0 to 2140.0
[chromium-blink-merge.git] / ui / events / x / events_x_unittest.cc
blobe64fc197221e98bb4880becdf07b6d9f7b3e5454
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.
5 #include <cstring>
6 #include <set>
8 #include <X11/extensions/XInput2.h>
9 #include <X11/Xlib.h>
10 #include <X11/Xutil.h>
11 #include <X11/XKBlib.h>
13 // Generically-named #defines from Xlib that conflict with symbols in GTest.
14 #undef Bool
15 #undef None
17 #include "base/memory/scoped_ptr.h"
18 #include "testing/gtest/include/gtest/gtest.h"
19 #include "ui/events/event.h"
20 #include "ui/events/event_constants.h"
21 #include "ui/events/event_utils.h"
22 #include "ui/events/test/events_test_utils.h"
23 #include "ui/events/test/events_test_utils_x11.h"
24 #include "ui/events/x/device_data_manager_x11.h"
25 #include "ui/events/x/touch_factory_x11.h"
26 #include "ui/gfx/point.h"
28 namespace ui {
30 namespace {
32 // Initializes the passed-in Xlib event.
33 void InitButtonEvent(XEvent* event,
34 bool is_press,
35 const gfx::Point& location,
36 int button,
37 int state) {
38 memset(event, 0, sizeof(*event));
40 // We don't bother setting fields that the event code doesn't use, such as
41 // x_root/y_root and window/root/subwindow.
42 XButtonEvent* button_event = &(event->xbutton);
43 button_event->type = is_press ? ButtonPress : ButtonRelease;
44 button_event->x = location.x();
45 button_event->y = location.y();
46 button_event->button = button;
47 button_event->state = state;
50 // Initializes the passed-in Xlib event.
51 void InitKeyEvent(Display* display,
52 XEvent* event,
53 bool is_press,
54 int keycode,
55 int state) {
56 memset(event, 0, sizeof(*event));
58 // We don't bother setting fields that the event code doesn't use, such as
59 // x_root/y_root and window/root/subwindow.
60 XKeyEvent* key_event = &(event->xkey);
61 key_event->display = display;
62 key_event->type = is_press ? KeyPress : KeyRelease;
63 key_event->keycode = keycode;
64 key_event->state = state;
67 // Returns true if the keysym maps to a KeyEvent with the EF_FUNCTION_KEY
68 // flag set, or the keysym maps to a zero key code.
69 bool HasFunctionKeyFlagSetIfSupported(Display* display, int x_keysym) {
70 XEvent event;
71 int x_keycode = XKeysymToKeycode(display, x_keysym);
72 // Exclude keysyms for which the server has no corresponding keycode.
73 if (x_keycode) {
74 InitKeyEvent(display, &event, true, x_keycode, 0);
75 ui::KeyEvent ui_key_event(&event);
76 return (ui_key_event.flags() & ui::EF_FUNCTION_KEY);
78 return true;
81 } // namespace
83 class EventsXTest : public testing::Test {
84 public:
85 EventsXTest() {}
86 virtual ~EventsXTest() {}
88 virtual void SetUp() OVERRIDE {
89 DeviceDataManagerX11::CreateInstance();
90 ui::TouchFactory::GetInstance()->ResetForTest();
92 private:
93 DISALLOW_COPY_AND_ASSIGN(EventsXTest);
96 TEST_F(EventsXTest, ButtonEvents) {
97 XEvent event;
98 gfx::Point location(5, 10);
99 gfx::Vector2d offset;
101 InitButtonEvent(&event, true, location, 1, 0);
102 EXPECT_EQ(ui::ET_MOUSE_PRESSED, ui::EventTypeFromNative(&event));
103 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, ui::EventFlagsFromNative(&event));
104 EXPECT_EQ(location, ui::EventLocationFromNative(&event));
106 InitButtonEvent(&event, true, location, 2, Button1Mask | ShiftMask);
107 EXPECT_EQ(ui::ET_MOUSE_PRESSED, ui::EventTypeFromNative(&event));
108 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_MIDDLE_MOUSE_BUTTON |
109 ui::EF_SHIFT_DOWN,
110 ui::EventFlagsFromNative(&event));
111 EXPECT_EQ(location, ui::EventLocationFromNative(&event));
113 InitButtonEvent(&event, false, location, 3, 0);
114 EXPECT_EQ(ui::ET_MOUSE_RELEASED, ui::EventTypeFromNative(&event));
115 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, ui::EventFlagsFromNative(&event));
116 EXPECT_EQ(location, ui::EventLocationFromNative(&event));
118 // Scroll up.
119 InitButtonEvent(&event, true, location, 4, 0);
120 EXPECT_EQ(ui::ET_MOUSEWHEEL, ui::EventTypeFromNative(&event));
121 EXPECT_EQ(0, ui::EventFlagsFromNative(&event));
122 EXPECT_EQ(location, ui::EventLocationFromNative(&event));
123 offset = ui::GetMouseWheelOffset(&event);
124 EXPECT_GT(offset.y(), 0);
125 EXPECT_EQ(0, offset.x());
127 // Scroll down.
128 InitButtonEvent(&event, true, location, 5, 0);
129 EXPECT_EQ(ui::ET_MOUSEWHEEL, ui::EventTypeFromNative(&event));
130 EXPECT_EQ(0, ui::EventFlagsFromNative(&event));
131 EXPECT_EQ(location, ui::EventLocationFromNative(&event));
132 offset = ui::GetMouseWheelOffset(&event);
133 EXPECT_LT(offset.y(), 0);
134 EXPECT_EQ(0, offset.x());
136 // Scroll left.
137 InitButtonEvent(&event, true, location, 6, 0);
138 EXPECT_EQ(ui::ET_MOUSEWHEEL, ui::EventTypeFromNative(&event));
139 EXPECT_EQ(0, ui::EventFlagsFromNative(&event));
140 EXPECT_EQ(location, ui::EventLocationFromNative(&event));
141 offset = ui::GetMouseWheelOffset(&event);
142 EXPECT_EQ(0, offset.y());
143 EXPECT_GT(offset.x(), 0);
145 // Scroll right.
146 InitButtonEvent(&event, true, location, 7, 0);
147 EXPECT_EQ(ui::ET_MOUSEWHEEL, ui::EventTypeFromNative(&event));
148 EXPECT_EQ(0, ui::EventFlagsFromNative(&event));
149 EXPECT_EQ(location, ui::EventLocationFromNative(&event));
150 offset = ui::GetMouseWheelOffset(&event);
151 EXPECT_EQ(0, offset.y());
152 EXPECT_LT(offset.x(), 0);
154 // TODO(derat): Test XInput code.
157 TEST_F(EventsXTest, AvoidExtraEventsOnWheelRelease) {
158 XEvent event;
159 gfx::Point location(5, 10);
161 InitButtonEvent(&event, true, location, 4, 0);
162 EXPECT_EQ(ui::ET_MOUSEWHEEL, ui::EventTypeFromNative(&event));
164 // We should return ET_UNKNOWN for the release event instead of returning
165 // ET_MOUSEWHEEL; otherwise we'll scroll twice for each scrollwheel step.
166 InitButtonEvent(&event, false, location, 4, 0);
167 EXPECT_EQ(ui::ET_UNKNOWN, ui::EventTypeFromNative(&event));
169 // TODO(derat): Test XInput code.
172 TEST_F(EventsXTest, EnterLeaveEvent) {
173 XEvent event;
174 event.xcrossing.type = EnterNotify;
175 event.xcrossing.x = 10;
176 event.xcrossing.y = 20;
177 event.xcrossing.x_root = 110;
178 event.xcrossing.y_root = 120;
180 // Mouse enter events are converted to mouse move events to be consistent with
181 // the way views handle mouse enter. See comments for EnterNotify case in
182 // ui::EventTypeFromNative for more details.
183 EXPECT_EQ(ui::ET_MOUSE_MOVED, ui::EventTypeFromNative(&event));
184 EXPECT_EQ("10,20", ui::EventLocationFromNative(&event).ToString());
185 EXPECT_EQ("110,120", ui::EventSystemLocationFromNative(&event).ToString());
187 event.xcrossing.type = LeaveNotify;
188 event.xcrossing.x = 30;
189 event.xcrossing.y = 40;
190 event.xcrossing.x_root = 230;
191 event.xcrossing.y_root = 240;
192 EXPECT_EQ(ui::ET_MOUSE_EXITED, ui::EventTypeFromNative(&event));
193 EXPECT_EQ("30,40", ui::EventLocationFromNative(&event).ToString());
194 EXPECT_EQ("230,240", ui::EventSystemLocationFromNative(&event).ToString());
197 TEST_F(EventsXTest, ClickCount) {
198 XEvent event;
199 gfx::Point location(5, 10);
201 for (int i = 1; i <= 3; ++i) {
202 InitButtonEvent(&event, true, location, 1, 0);
204 MouseEvent mouseev(&event);
205 EXPECT_EQ(ui::ET_MOUSE_PRESSED, mouseev.type());
206 EXPECT_EQ(i, mouseev.GetClickCount());
209 InitButtonEvent(&event, false, location, 1, 0);
211 MouseEvent mouseev(&event);
212 EXPECT_EQ(ui::ET_MOUSE_RELEASED, mouseev.type());
213 EXPECT_EQ(i, mouseev.GetClickCount());
218 #if defined(USE_XI2_MT)
219 TEST_F(EventsXTest, TouchEventBasic) {
220 std::vector<unsigned int> devices;
221 devices.push_back(0);
222 ui::SetUpTouchDevicesForTest(devices);
223 std::vector<Valuator> valuators;
225 // Init touch begin with tracking id 5, touch id 0.
226 valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_MAJOR, 20));
227 valuators.push_back(
228 Valuator(DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.3f));
229 valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_PRESSURE, 100));
230 ui::ScopedXI2Event scoped_xevent;
231 scoped_xevent.InitTouchEvent(
232 0, XI_TouchBegin, 5, gfx::Point(10, 10), valuators);
233 EXPECT_EQ(ui::ET_TOUCH_PRESSED, ui::EventTypeFromNative(scoped_xevent));
234 EXPECT_EQ("10,10", ui::EventLocationFromNative(scoped_xevent).ToString());
235 EXPECT_EQ(GetTouchId(scoped_xevent), 0);
236 EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 10);
237 EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.15f);
238 EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.1f);
240 // Touch update, with new orientation info.
241 valuators.clear();
242 valuators.push_back(
243 Valuator(DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.5f));
244 scoped_xevent.InitTouchEvent(
245 0, XI_TouchUpdate, 5, gfx::Point(20, 20), valuators);
246 EXPECT_EQ(ui::ET_TOUCH_MOVED, ui::EventTypeFromNative(scoped_xevent));
247 EXPECT_EQ("20,20", ui::EventLocationFromNative(scoped_xevent).ToString());
248 EXPECT_EQ(GetTouchId(scoped_xevent), 0);
249 EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 10);
250 EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.25f);
251 EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.1f);
253 // Another touch with tracking id 6, touch id 1.
254 valuators.clear();
255 valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_MAJOR, 100));
256 valuators.push_back(Valuator(
257 DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.9f));
258 valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_PRESSURE, 500));
259 scoped_xevent.InitTouchEvent(
260 0, XI_TouchBegin, 6, gfx::Point(200, 200), valuators);
261 EXPECT_EQ(ui::ET_TOUCH_PRESSED, ui::EventTypeFromNative(scoped_xevent));
262 EXPECT_EQ("200,200", ui::EventLocationFromNative(scoped_xevent).ToString());
263 EXPECT_EQ(GetTouchId(scoped_xevent), 1);
264 EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 50);
265 EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.45f);
266 EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.5f);
268 // Touch with tracking id 5 should have old radius/angle value and new pressue
269 // value.
270 valuators.clear();
271 valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_PRESSURE, 50));
272 scoped_xevent.InitTouchEvent(
273 0, XI_TouchEnd, 5, gfx::Point(30, 30), valuators);
274 EXPECT_EQ(ui::ET_TOUCH_RELEASED, ui::EventTypeFromNative(scoped_xevent));
275 EXPECT_EQ("30,30", ui::EventLocationFromNative(scoped_xevent).ToString());
276 EXPECT_EQ(GetTouchId(scoped_xevent), 0);
277 EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 10);
278 EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.25f);
279 EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.05f);
281 // Touch with tracking id 6 should have old angle/pressure value and new
282 // radius value.
283 valuators.clear();
284 valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_MAJOR, 50));
285 scoped_xevent.InitTouchEvent(
286 0, XI_TouchEnd, 6, gfx::Point(200, 200), valuators);
287 EXPECT_EQ(ui::ET_TOUCH_RELEASED, ui::EventTypeFromNative(scoped_xevent));
288 EXPECT_EQ("200,200", ui::EventLocationFromNative(scoped_xevent).ToString());
289 EXPECT_EQ(GetTouchId(scoped_xevent), 1);
290 EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 25);
291 EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.45f);
292 EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.5f);
295 int GetTouchIdForTrackingId(uint32 tracking_id) {
296 int slot = 0;
297 bool success =
298 TouchFactory::GetInstance()->QuerySlotForTrackingID(tracking_id, &slot);
299 if (success)
300 return slot;
301 return -1;
304 TEST_F(EventsXTest, TouchEventIdRefcounting) {
305 std::vector<unsigned int> devices;
306 devices.push_back(0);
307 ui::SetUpTouchDevicesForTest(devices);
308 std::vector<Valuator> valuators;
310 const int kTrackingId0 = 5;
311 const int kTrackingId1 = 7;
313 // Increment ref count once for first touch.
314 ui::ScopedXI2Event xpress0;
315 xpress0.InitTouchEvent(
316 0, XI_TouchBegin, kTrackingId0, gfx::Point(10, 10), valuators);
317 scoped_ptr<ui::TouchEvent> upress0(new ui::TouchEvent(xpress0));
318 EXPECT_EQ(0, GetTouchIdForTrackingId(kTrackingId0));
320 // Increment ref count 4 times for second touch.
321 ui::ScopedXI2Event xpress1;
322 xpress1.InitTouchEvent(
323 0, XI_TouchBegin, kTrackingId1, gfx::Point(20, 20), valuators);
325 for (int i = 0; i < 4; ++i) {
326 ui::TouchEvent upress1(xpress1);
327 EXPECT_EQ(1, GetTouchIdForTrackingId(kTrackingId1));
330 ui::ScopedXI2Event xrelease1;
331 xrelease1.InitTouchEvent(
332 0, XI_TouchEnd, kTrackingId1, gfx::Point(10, 10), valuators);
334 // Decrement ref count 3 times for second touch.
335 for (int i = 0; i < 3; ++i) {
336 ui::TouchEvent urelease1(xrelease1);
337 EXPECT_EQ(1, GetTouchIdForTrackingId(kTrackingId1));
340 // This should clear the touch id of the second touch.
341 scoped_ptr<ui::TouchEvent> urelease1(new ui::TouchEvent(xrelease1));
342 urelease1.reset();
343 EXPECT_EQ(-1, GetTouchIdForTrackingId(kTrackingId1));
345 // This should clear the touch id of the first touch.
346 ui::ScopedXI2Event xrelease0;
347 xrelease0.InitTouchEvent(
348 0, XI_TouchEnd, kTrackingId0, gfx::Point(10, 10), valuators);
349 scoped_ptr<ui::TouchEvent> urelease0(new ui::TouchEvent(xrelease0));
350 urelease0.reset();
351 EXPECT_EQ(-1, GetTouchIdForTrackingId(kTrackingId0));
353 #endif
355 TEST_F(EventsXTest, NumpadKeyEvents) {
356 XEvent event;
357 Display* display = gfx::GetXDisplay();
359 struct {
360 bool is_numpad_key;
361 int x_keysym;
362 } keys[] = {
363 // XK_KP_Space and XK_KP_Equal are the extrema in the conventional
364 // keysymdef.h numbering.
365 { true, XK_KP_Space },
366 { true, XK_KP_Equal },
367 // Other numpad keysyms. (This is actually exhaustive in the current list.)
368 { true, XK_KP_Tab },
369 { true, XK_KP_Enter },
370 { true, XK_KP_F1 },
371 { true, XK_KP_F2 },
372 { true, XK_KP_F3 },
373 { true, XK_KP_F4 },
374 { true, XK_KP_Home },
375 { true, XK_KP_Left },
376 { true, XK_KP_Up },
377 { true, XK_KP_Right },
378 { true, XK_KP_Down },
379 { true, XK_KP_Prior },
380 { true, XK_KP_Page_Up },
381 { true, XK_KP_Next },
382 { true, XK_KP_Page_Down },
383 { true, XK_KP_End },
384 { true, XK_KP_Begin },
385 { true, XK_KP_Insert },
386 { true, XK_KP_Delete },
387 { true, XK_KP_Multiply },
388 { true, XK_KP_Add },
389 { true, XK_KP_Separator },
390 { true, XK_KP_Subtract },
391 { true, XK_KP_Decimal },
392 { true, XK_KP_Divide },
393 { true, XK_KP_0 },
394 { true, XK_KP_1 },
395 { true, XK_KP_2 },
396 { true, XK_KP_3 },
397 { true, XK_KP_4 },
398 { true, XK_KP_5 },
399 { true, XK_KP_6 },
400 { true, XK_KP_7 },
401 { true, XK_KP_8 },
402 { true, XK_KP_9 },
403 // Largest keysym preceding XK_KP_Space.
404 { false, XK_Num_Lock },
405 // Smallest keysym following XK_KP_Equal.
406 { false, XK_F1 },
407 // Non-numpad analogues of numpad keysyms.
408 { false, XK_Tab },
409 { false, XK_Return },
410 { false, XK_F1 },
411 { false, XK_F2 },
412 { false, XK_F3 },
413 { false, XK_F4 },
414 { false, XK_Home },
415 { false, XK_Left },
416 { false, XK_Up },
417 { false, XK_Right },
418 { false, XK_Down },
419 { false, XK_Prior },
420 { false, XK_Page_Up },
421 { false, XK_Next },
422 { false, XK_Page_Down },
423 { false, XK_End },
424 { false, XK_Insert },
425 { false, XK_Delete },
426 { false, XK_multiply },
427 { false, XK_plus },
428 { false, XK_minus },
429 { false, XK_period },
430 { false, XK_slash },
431 { false, XK_0 },
432 { false, XK_1 },
433 { false, XK_2 },
434 { false, XK_3 },
435 { false, XK_4 },
436 { false, XK_5 },
437 { false, XK_6 },
438 { false, XK_7 },
439 { false, XK_8 },
440 { false, XK_9 },
441 // Miscellaneous other keysyms.
442 { false, XK_BackSpace },
443 { false, XK_Scroll_Lock },
444 { false, XK_Multi_key },
445 { false, XK_Select },
446 { false, XK_Num_Lock },
447 { false, XK_Shift_L },
448 { false, XK_space },
449 { false, XK_A },
452 for (size_t k = 0; k < ARRAYSIZE_UNSAFE(keys); ++k) {
453 int x_keycode = XKeysymToKeycode(display, keys[k].x_keysym);
454 // Exclude keysyms for which the server has no corresponding keycode.
455 if (x_keycode) {
456 InitKeyEvent(display, &event, true, x_keycode, 0);
457 // int keysym = XLookupKeysym(&event.xkey, 0);
458 // if (keysym) {
459 ui::KeyEvent ui_key_event(&event);
460 EXPECT_EQ(keys[k].is_numpad_key ? ui::EF_NUMPAD_KEY : 0,
461 ui_key_event.flags() & ui::EF_NUMPAD_KEY);
466 TEST_F(EventsXTest, FunctionKeyEvents) {
467 Display* display = gfx::GetXDisplay();
469 // Min function key code minus 1.
470 EXPECT_FALSE(HasFunctionKeyFlagSetIfSupported(display, XK_F1 - 1));
471 // All function keys.
472 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F1));
473 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F2));
474 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F3));
475 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F4));
476 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F5));
477 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F6));
478 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F7));
479 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F8));
480 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F9));
481 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F10));
482 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F11));
483 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F12));
484 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F13));
485 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F14));
486 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F15));
487 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F16));
488 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F17));
489 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F18));
490 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F19));
491 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F20));
492 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F21));
493 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F22));
494 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F23));
495 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F24));
496 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F25));
497 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F26));
498 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F27));
499 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F28));
500 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F29));
501 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F30));
502 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F31));
503 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F32));
504 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F33));
505 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F34));
506 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F35));
507 // Max function key code plus 1.
508 EXPECT_FALSE(HasFunctionKeyFlagSetIfSupported(display, XK_F35 + 1));
511 #if defined(USE_XI2_MT)
512 // Verifies that the type of events from a disabled keyboard is ET_UNKNOWN, but
513 // that an exception list of keys can still be processed.
514 TEST_F(EventsXTest, DisableKeyboard) {
515 DeviceDataManagerX11* device_data_manager =
516 static_cast<DeviceDataManagerX11*>(
517 DeviceDataManager::GetInstance());
518 unsigned int blocked_device_id = 1;
519 unsigned int other_device_id = 2;
520 device_data_manager->DisableDevice(blocked_device_id);
522 scoped_ptr<std::set<KeyboardCode> > excepted_keys(new std::set<KeyboardCode>);
523 excepted_keys->insert(VKEY_B);
524 device_data_manager->SetDisabledKeyboardAllowedKeys(excepted_keys.Pass());
526 ScopedXI2Event xev;
527 // A is not allowed on the blocked keyboard, and should return ET_UNKNOWN.
528 xev.InitGenericKeyEvent(blocked_device_id, ui::ET_KEY_PRESSED, ui::VKEY_A, 0);
529 EXPECT_EQ(ui::ET_UNKNOWN, ui::EventTypeFromNative(xev));
531 // The B key is allowed as an exception, and should return KEY_PRESSED.
532 xev.InitGenericKeyEvent(blocked_device_id, ui::ET_KEY_PRESSED, ui::VKEY_B, 0);
533 EXPECT_EQ(ui::ET_KEY_PRESSED, ui::EventTypeFromNative(xev));
535 // Both A and B are allowed on an unblocked keyboard device.
536 xev.InitGenericKeyEvent(other_device_id, ui::ET_KEY_PRESSED, ui::VKEY_A, 0);
537 EXPECT_EQ(ui::ET_KEY_PRESSED, ui::EventTypeFromNative(xev));
538 xev.InitGenericKeyEvent(other_device_id, ui::ET_KEY_PRESSED, ui::VKEY_B, 0);
539 EXPECT_EQ(ui::ET_KEY_PRESSED, ui::EventTypeFromNative(xev));
541 device_data_manager->EnableDevice(blocked_device_id);
542 device_data_manager->SetDisabledKeyboardAllowedKeys(
543 scoped_ptr<std::set<KeyboardCode> >());
545 // A key returns KEY_PRESSED as per usual now that keyboard was re-enabled.
546 xev.InitGenericKeyEvent(blocked_device_id, ui::ET_KEY_PRESSED, ui::VKEY_A, 0);
547 EXPECT_EQ(ui::ET_KEY_PRESSED, ui::EventTypeFromNative(xev));
550 // Verifies that the type of events from a disabled mouse is ET_UNKNOWN.
551 TEST_F(EventsXTest, DisableMouse) {
552 DeviceDataManagerX11* device_data_manager =
553 static_cast<DeviceDataManagerX11*>(
554 DeviceDataManager::GetInstance());
555 unsigned int blocked_device_id = 1;
556 unsigned int other_device_id = 2;
557 std::vector<unsigned int> device_list;
558 device_list.push_back(blocked_device_id);
559 device_list.push_back(other_device_id);
560 TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
562 device_data_manager->DisableDevice(blocked_device_id);
564 ScopedXI2Event xev;
565 xev.InitGenericButtonEvent(blocked_device_id, ET_MOUSE_PRESSED, gfx::Point(),
566 EF_LEFT_MOUSE_BUTTON);
567 EXPECT_EQ(ui::ET_UNKNOWN, ui::EventTypeFromNative(xev));
569 xev.InitGenericButtonEvent(other_device_id, ET_MOUSE_PRESSED, gfx::Point(),
570 EF_LEFT_MOUSE_BUTTON);
571 EXPECT_EQ(ui::ET_MOUSE_PRESSED, ui::EventTypeFromNative(xev));
573 device_data_manager->EnableDevice(blocked_device_id);
575 xev.InitGenericButtonEvent(blocked_device_id, ET_MOUSE_PRESSED, gfx::Point(),
576 EF_LEFT_MOUSE_BUTTON);
577 EXPECT_EQ(ui::ET_MOUSE_PRESSED, ui::EventTypeFromNative(xev));
579 #endif // defined(USE_XI2_MT)
581 #if !defined(OS_CHROMEOS)
582 TEST_F(EventsXTest, ImeFabricatedKeyEvents) {
583 Display* display = gfx::GetXDisplay();
585 unsigned int state_to_be_fabricated[] = {
586 0, ShiftMask, LockMask, ShiftMask | LockMask,
588 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(state_to_be_fabricated); ++i) {
589 unsigned int state = state_to_be_fabricated[i];
590 for (int is_char = 0; is_char < 2; ++is_char) {
591 XEvent x_event;
592 InitKeyEvent(display, &x_event, true, 0, state);
593 ui::KeyEvent key_event(&x_event);
594 if (is_char) {
595 KeyEventTestApi test_event(&key_event);
596 test_event.set_is_char(true);
598 EXPECT_TRUE(key_event.flags() & ui::EF_IME_FABRICATED_KEY);
602 unsigned int state_to_be_not_fabricated[] = {
603 ControlMask, Mod1Mask, Mod2Mask, ShiftMask | ControlMask,
605 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(state_to_be_not_fabricated); ++i) {
606 unsigned int state = state_to_be_not_fabricated[i];
607 for (int is_char = 0; is_char < 2; ++is_char) {
608 XEvent x_event;
609 InitKeyEvent(display, &x_event, true, 0, state);
610 ui::KeyEvent key_event(&x_event);
611 if (is_char) {
612 KeyEventTestApi test_event(&key_event);
613 test_event.set_is_char(true);
615 EXPECT_FALSE(key_event.flags() & ui::EF_IME_FABRICATED_KEY);
619 #endif
621 } // namespace ui