ui/events/ozone/evdev/event_converter_evdev_impl_unittest.cc

   1 // Copyright 2014 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 <linux/input.h>
   6
   7 #include "base/bind.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/memory/scoped_vector.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12 #include "ui/events/event.h"
  13 #include "ui/events/keycodes/keyboard_codes.h"
  14 #include "ui/events/ozone/evdev/cursor_delegate_evdev.h"
  15 #include "ui/events/ozone/evdev/event_converter_evdev_impl.h"
  16 #include "ui/events/ozone/evdev/keyboard_evdev.h"
  17 #include "ui/events/ozone/evdev/mouse_button_map_evdev.h"
  18 #include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
  19
  20 namespace ui {
  21
  22 const char kTestDevicePath[] = "/dev/input/test-device";
  23
  24 class MockEventConverterEvdevImpl : public EventConverterEvdevImpl {
  25  public:
  26   MockEventConverterEvdevImpl(int fd,
  27                               EventModifiersEvdev* modifiers,
  28                               MouseButtonMapEvdev* button_map,
  29                               CursorDelegateEvdev* cursor,
  30                               KeyboardEvdev* keyboard,
  31                               const EventDispatchCallback& callback)
  32       : EventConverterEvdevImpl(fd,
  33                                 base::FilePath(kTestDevicePath),
  34                                 1,
  35                                 INPUT_DEVICE_UNKNOWN,
  36                                 EventDeviceInfo(),
  37                                 modifiers,
  38                                 button_map,
  39                                 cursor,
  40                                 keyboard,
  41                                 callback) {
  42     Start();
  43   }
  44   ~MockEventConverterEvdevImpl() override {}
  45
  46  private:
  47   DISALLOW_COPY_AND_ASSIGN(MockEventConverterEvdevImpl);
  48 };
  49
  50 class MockCursorEvdev : public CursorDelegateEvdev {
  51  public:
  52   MockCursorEvdev() {}
  53   ~MockCursorEvdev() override {}
  54
  55   // CursorDelegateEvdev:
  56   void MoveCursorTo(gfx::AcceleratedWidget widget,
  57                     const gfx::PointF& location) override {
  58     cursor_location_ = location;
  59   }
  60   void MoveCursorTo(const gfx::PointF& location) override {
  61     cursor_location_ = location;
  62   }
  63   void MoveCursor(const gfx::Vector2dF& delta) override {
  64     cursor_location_ = gfx::PointF(delta.x(), delta.y());
  65   }
  66   bool IsCursorVisible() override { return 1; }
  67   gfx::Rect GetCursorDisplayBounds() override {
  68     NOTIMPLEMENTED();
  69     return gfx::Rect();
  70   }
  71   gfx::PointF GetLocation() override { return cursor_location_; }
  72
  73  private:
  74   // The location of the mock cursor.
  75   gfx::PointF cursor_location_;
  76
  77   DISALLOW_COPY_AND_ASSIGN(MockCursorEvdev);
  78 };
  79
  80 }  // namespace ui
  81
  82 // Test fixture.
  83 class EventConverterEvdevImplTest : public testing::Test {
  84  public:
  85   EventConverterEvdevImplTest() {}
  86
  87   // Overridden from testing::Test:
  88   void SetUp() override {
  89     // Set up pipe to satisfy message pump (unused).
  90     int evdev_io[2];
  91     if (pipe(evdev_io))
  92       PLOG(FATAL) << "failed pipe";
  93     events_in_ = evdev_io[0];
  94     events_out_ = evdev_io[1];
  95
  96     cursor_.reset(new ui::MockCursorEvdev());
  97     modifiers_.reset(new ui::EventModifiersEvdev());
  98     button_map_.reset(new ui::MouseButtonMapEvdev());
  99
 100     const ui::EventDispatchCallback callback =
 101         base::Bind(&EventConverterEvdevImplTest::DispatchEventForTest,
 102                    base::Unretained(this));
 103     keyboard_.reset(new ui::KeyboardEvdev(
 104         modifiers_.get(),
 105         ui::KeyboardLayoutEngineManager::GetKeyboardLayoutEngine(), callback));
 106     device_.reset(new ui::MockEventConverterEvdevImpl(
 107         events_in_, modifiers_.get(), button_map_.get(), cursor_.get(),
 108         keyboard_.get(), callback));
 109   }
 110   void TearDown() override {
 111     device_.reset();
 112     keyboard_.reset();
 113     modifiers_.reset();
 114     button_map_.reset();
 115     cursor_.reset();
 116     close(events_in_);
 117     close(events_out_);
 118   }
 119
 120   ui::MockCursorEvdev* cursor() { return cursor_.get(); }
 121   ui::MockEventConverterEvdevImpl* device() { return device_.get(); }
 122   ui::EventModifiersEvdev* modifiers() { return modifiers_.get(); }
 123   ui::MouseButtonMapEvdev* button_map() { return button_map_.get(); }
 124
 125   unsigned size() { return dispatched_events_.size(); }
 126   ui::KeyEvent* dispatched_event(unsigned index) {
 127     DCHECK_GT(dispatched_events_.size(), index);
 128     ui::Event* ev = dispatched_events_[index];
 129     DCHECK(ev->IsKeyEvent());
 130     return static_cast<ui::KeyEvent*>(ev);
 131   }
 132   ui::MouseEvent* dispatched_mouse_event(unsigned index) {
 133     DCHECK_GT(dispatched_events_.size(), index);
 134     ui::Event* ev = dispatched_events_[index];
 135     DCHECK(ev->IsMouseEvent());
 136     return static_cast<ui::MouseEvent*>(ev);
 137   }
 138
 139  private:
 140   void DispatchEventForTest(scoped_ptr<ui::Event> event) {
 141     dispatched_events_.push_back(event.release());
 142   }
 143
 144   base::MessageLoopForUI ui_loop_;
 145
 146   scoped_ptr<ui::MockCursorEvdev> cursor_;
 147   scoped_ptr<ui::EventModifiersEvdev> modifiers_;
 148   scoped_ptr<ui::MouseButtonMapEvdev> button_map_;
 149   scoped_ptr<ui::KeyboardEvdev> keyboard_;
 150   scoped_ptr<ui::MockEventConverterEvdevImpl> device_;
 151
 152   ScopedVector<ui::Event> dispatched_events_;
 153
 154   int events_out_;
 155   int events_in_;
 156
 157   DISALLOW_COPY_AND_ASSIGN(EventConverterEvdevImplTest);
 158 };
 159
 160 TEST_F(EventConverterEvdevImplTest, KeyPress) {
 161   ui::MockEventConverterEvdevImpl* dev = device();
 162
 163   struct input_event mock_kernel_queue[] = {
 164       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
 165       {{0, 0}, EV_KEY, KEY_BACKSPACE, 1},
 166       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 167
 168       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
 169       {{0, 0}, EV_KEY, KEY_BACKSPACE, 0},
 170       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 171   };
 172
 173   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 174   EXPECT_EQ(2u, size());
 175
 176   ui::KeyEvent* event;
 177
 178   event = dispatched_event(0);
 179   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 180   EXPECT_EQ(ui::VKEY_BACK, event->key_code());
 181   EXPECT_EQ(0, event->flags());
 182
 183   event = dispatched_event(1);
 184   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 185   EXPECT_EQ(ui::VKEY_BACK, event->key_code());
 186   EXPECT_EQ(0, event->flags());
 187 }
 188
 189 TEST_F(EventConverterEvdevImplTest, KeyRepeat) {
 190   ui::MockEventConverterEvdevImpl* dev = device();
 191
 192   struct input_event mock_kernel_queue[] = {
 193       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
 194       {{0, 0}, EV_KEY, KEY_BACKSPACE, 1},
 195       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 196
 197       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
 198       {{0, 0}, EV_KEY, KEY_BACKSPACE, 2},
 199       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 200
 201       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
 202       {{0, 0}, EV_KEY, KEY_BACKSPACE, 2},
 203       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 204
 205       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
 206       {{0, 0}, EV_KEY, KEY_BACKSPACE, 0},
 207       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 208   };
 209
 210   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 211   EXPECT_EQ(2u, size());
 212
 213   ui::KeyEvent* event;
 214
 215   event = dispatched_event(0);
 216   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 217   EXPECT_EQ(ui::VKEY_BACK, event->key_code());
 218   EXPECT_EQ(0, event->flags());
 219
 220   event = dispatched_event(1);
 221   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 222   EXPECT_EQ(ui::VKEY_BACK, event->key_code());
 223   EXPECT_EQ(0, event->flags());
 224 }
 225
 226 TEST_F(EventConverterEvdevImplTest, NoEvents) {
 227   ui::MockEventConverterEvdevImpl* dev = device();
 228   dev->ProcessEvents(NULL, 0);
 229   EXPECT_EQ(0u, size());
 230 }
 231
 232 TEST_F(EventConverterEvdevImplTest, KeyWithModifier) {
 233   ui::MockEventConverterEvdevImpl* dev = device();
 234
 235   struct input_event mock_kernel_queue[] = {
 236       {{0, 0}, EV_MSC, MSC_SCAN, 0x700e1},
 237       {{0, 0}, EV_KEY, KEY_LEFTSHIFT, 1},
 238       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 239
 240       {{0, 0}, EV_MSC, MSC_SCAN, 0x70004},
 241       {{0, 0}, EV_KEY, KEY_A, 1},
 242       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 243
 244       {{0, 0}, EV_MSC, MSC_SCAN, 0x70004},
 245       {{0, 0}, EV_KEY, KEY_A, 0},
 246       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 247
 248       {{0, 0}, EV_MSC, MSC_SCAN, 0x700e1},
 249       {{0, 0}, EV_KEY, KEY_LEFTSHIFT, 0},
 250       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 251   };
 252
 253   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 254   EXPECT_EQ(4u, size());
 255
 256   ui::KeyEvent* event;
 257
 258   event = dispatched_event(0);
 259   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 260   EXPECT_EQ(ui::VKEY_SHIFT, event->key_code());
 261   EXPECT_EQ(ui::EF_SHIFT_DOWN, event->flags());
 262
 263   event = dispatched_event(1);
 264   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 265   EXPECT_EQ(ui::VKEY_A, event->key_code());
 266   EXPECT_EQ(ui::EF_SHIFT_DOWN, event->flags());
 267
 268   event = dispatched_event(2);
 269   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 270   EXPECT_EQ(ui::VKEY_A, event->key_code());
 271   EXPECT_EQ(ui::EF_SHIFT_DOWN, event->flags());
 272
 273   event = dispatched_event(3);
 274   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 275   EXPECT_EQ(ui::VKEY_SHIFT, event->key_code());
 276   EXPECT_EQ(0, event->flags());
 277 }
 278
 279 TEST_F(EventConverterEvdevImplTest, KeyWithDuplicateModifier) {
 280   ui::MockEventConverterEvdevImpl* dev = device();
 281
 282   struct input_event mock_kernel_queue[] = {
 283       {{0, 0}, EV_MSC, MSC_SCAN, 0x700e1},
 284       {{0, 0}, EV_KEY, KEY_LEFTCTRL, 1},
 285       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 286
 287       {{0, 0}, EV_MSC, MSC_SCAN, 0x700e5},
 288       {{0, 0}, EV_KEY, KEY_RIGHTCTRL, 1},
 289       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 290
 291       {{0, 0}, EV_MSC, MSC_SCAN, 0x7001d},
 292       {{0, 0}, EV_KEY, KEY_Z, 1},
 293       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 294
 295       {{0, 0}, EV_MSC, MSC_SCAN, 0x7001d},
 296       {{0, 0}, EV_KEY, KEY_Z, 0},
 297       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 298
 299       {{0, 0}, EV_MSC, MSC_SCAN, 0x700e1},
 300       {{0, 0}, EV_KEY, KEY_LEFTCTRL, 0},
 301       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 302
 303       {{0, 0}, EV_MSC, MSC_SCAN, 0x700e5},
 304       {{0, 0}, EV_KEY, KEY_RIGHTCTRL, 0},
 305       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 306   };
 307
 308   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 309   EXPECT_EQ(6u, size());
 310
 311   ui::KeyEvent* event;
 312
 313   event = dispatched_event(0);
 314   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 315   EXPECT_EQ(ui::VKEY_CONTROL, event->key_code());
 316   EXPECT_EQ(ui::EF_CONTROL_DOWN, event->flags());
 317
 318   event = dispatched_event(1);
 319   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 320   EXPECT_EQ(ui::VKEY_CONTROL, event->key_code());
 321   EXPECT_EQ(ui::EF_CONTROL_DOWN, event->flags());
 322
 323   event = dispatched_event(2);
 324   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 325   EXPECT_EQ(ui::VKEY_Z, event->key_code());
 326   EXPECT_EQ(ui::EF_CONTROL_DOWN, event->flags());
 327
 328   event = dispatched_event(3);
 329   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 330   EXPECT_EQ(ui::VKEY_Z, event->key_code());
 331   EXPECT_EQ(ui::EF_CONTROL_DOWN, event->flags());
 332
 333   event = dispatched_event(4);
 334   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 335   EXPECT_EQ(ui::VKEY_CONTROL, event->key_code());
 336   EXPECT_EQ(ui::EF_CONTROL_DOWN, event->flags());
 337
 338   event = dispatched_event(5);
 339   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 340   EXPECT_EQ(ui::VKEY_CONTROL, event->key_code());
 341   EXPECT_EQ(0, event->flags());
 342 }
 343
 344 TEST_F(EventConverterEvdevImplTest, KeyWithLock) {
 345   ui::MockEventConverterEvdevImpl* dev = device();
 346
 347   struct input_event mock_kernel_queue[] = {
 348       {{0, 0}, EV_MSC, MSC_SCAN, 0x70039},
 349       {{0, 0}, EV_KEY, KEY_CAPSLOCK, 1},
 350       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 351
 352       {{0, 0}, EV_MSC, MSC_SCAN, 0x70039},
 353       {{0, 0}, EV_KEY, KEY_CAPSLOCK, 0},
 354       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 355
 356       {{0, 0}, EV_MSC, MSC_SCAN, 0x70014},
 357       {{0, 0}, EV_KEY, KEY_Q, 1},
 358       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 359
 360       {{0, 0}, EV_MSC, MSC_SCAN, 0x70014},
 361       {{0, 0}, EV_KEY, KEY_Q, 0},
 362       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 363
 364       {{0, 0}, EV_MSC, MSC_SCAN, 0x70039},
 365       {{0, 0}, EV_KEY, KEY_CAPSLOCK, 1},
 366       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 367
 368       {{0, 0}, EV_MSC, MSC_SCAN, 0x70039},
 369       {{0, 0}, EV_KEY, KEY_CAPSLOCK, 0},
 370       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 371   };
 372
 373   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 374   EXPECT_EQ(6u, size());
 375
 376   ui::KeyEvent* event;
 377
 378   event = dispatched_event(0);
 379   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 380   EXPECT_EQ(ui::VKEY_CAPITAL, event->key_code());
 381   EXPECT_EQ(ui::EF_CAPS_LOCK_DOWN, event->flags());
 382
 383   event = dispatched_event(1);
 384   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 385   EXPECT_EQ(ui::VKEY_CAPITAL, event->key_code());
 386   EXPECT_EQ(ui::EF_CAPS_LOCK_DOWN, event->flags());
 387
 388   event = dispatched_event(2);
 389   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 390   EXPECT_EQ(ui::VKEY_Q, event->key_code());
 391   EXPECT_EQ(ui::EF_CAPS_LOCK_DOWN, event->flags());
 392
 393   event = dispatched_event(3);
 394   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 395   EXPECT_EQ(ui::VKEY_Q, event->key_code());
 396   EXPECT_EQ(ui::EF_CAPS_LOCK_DOWN, event->flags());
 397
 398   event = dispatched_event(4);
 399   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 400   EXPECT_EQ(ui::VKEY_CAPITAL, event->key_code());
 401   EXPECT_EQ(0, event->flags());
 402
 403   event = dispatched_event(5);
 404   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 405   EXPECT_EQ(ui::VKEY_CAPITAL, event->key_code());
 406   EXPECT_EQ(0, event->flags());
 407 }
 408
 409 TEST_F(EventConverterEvdevImplTest, MouseButton) {
 410   ui::MockEventConverterEvdevImpl* dev = device();
 411
 412   struct input_event mock_kernel_queue[] = {
 413       {{0, 0}, EV_KEY, BTN_LEFT, 1},
 414       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 415
 416       {{0, 0}, EV_KEY, BTN_LEFT, 0},
 417       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 418   };
 419
 420   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 421   EXPECT_EQ(2u, size());
 422
 423   ui::MouseEvent* event;
 424
 425   event = dispatched_mouse_event(0);
 426   EXPECT_EQ(ui::ET_MOUSE_PRESSED, event->type());
 427   EXPECT_EQ(true, event->IsLeftMouseButton());
 428
 429   event = dispatched_mouse_event(1);
 430   EXPECT_EQ(ui::ET_MOUSE_RELEASED, event->type());
 431   EXPECT_EQ(true, event->IsLeftMouseButton());
 432 }
 433
 434 TEST_F(EventConverterEvdevImplTest, MouseMove) {
 435   ui::MockEventConverterEvdevImpl* dev = device();
 436
 437   struct input_event mock_kernel_queue[] = {
 438       {{0, 0}, EV_REL, REL_X, 4},
 439       {{0, 0}, EV_REL, REL_Y, 2},
 440       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 441   };
 442
 443   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 444   EXPECT_EQ(1u, size());
 445
 446   ui::MouseEvent* event;
 447
 448   event = dispatched_mouse_event(0);
 449   EXPECT_EQ(ui::ET_MOUSE_MOVED, event->type());
 450   EXPECT_EQ(cursor()->GetLocation(), gfx::PointF(4, 2));
 451 }
 452
 453 TEST_F(EventConverterEvdevImplTest, UnmappedKeyPress) {
 454   ui::MockEventConverterEvdevImpl* dev = device();
 455
 456   struct input_event mock_kernel_queue[] = {
 457       {{0, 0}, EV_KEY, BTN_TOUCH, 1},
 458       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 459
 460       {{0, 0}, EV_KEY, BTN_TOUCH, 0},
 461       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 462   };
 463
 464   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 465   EXPECT_EQ(0u, size());
 466 }