src/ui/events/ozone/evdev/key_event_converter_evdev_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/key_event_converter_evdev.h"
  15
  16 namespace ui {
  17
  18 const char kTestDevicePath[] = "/dev/input/test-device";
  19
  20 class MockKeyEventConverterEvdev : public KeyEventConverterEvdev {
  21  public:
  22   MockKeyEventConverterEvdev(int fd, EventModifiersEvdev* modifiers)
  23       : KeyEventConverterEvdev(
  24             fd,
  25             base::FilePath(kTestDevicePath),
  26             modifiers,
  27             base::Bind(&MockKeyEventConverterEvdev::DispatchEventForTest,
  28                        base::Unretained(this))) {
  29     Start();
  30   }
  31   virtual ~MockKeyEventConverterEvdev() {};
  32
  33   unsigned size() { return dispatched_events_.size(); }
  34   KeyEvent* event(unsigned index) {
  35     DCHECK_GT(dispatched_events_.size(), index);
  36     return dispatched_events_[index];
  37   }
  38
  39   void DispatchEventForTest(Event* event);
  40
  41  private:
  42   ScopedVector<KeyEvent> dispatched_events_;
  43
  44   DISALLOW_COPY_AND_ASSIGN(MockKeyEventConverterEvdev);
  45 };
  46
  47 void MockKeyEventConverterEvdev::DispatchEventForTest(Event* event) {
  48   dispatched_events_.push_back(new KeyEvent(*static_cast<KeyEvent*>(event)));
  49 }
  50
  51 }  // namespace ui
  52
  53 // Test fixture.
  54 class KeyEventConverterEvdevTest : public testing::Test {
  55  public:
  56   KeyEventConverterEvdevTest() {}
  57
  58   // Overridden from testing::Test:
  59   virtual void SetUp() OVERRIDE {
  60
  61     // Set up pipe to satisfy message pump (unused).
  62     int evdev_io[2];
  63     if (pipe(evdev_io))
  64       PLOG(FATAL) << "failed pipe";
  65     events_in_ = evdev_io[0];
  66     events_out_ = evdev_io[1];
  67
  68     modifiers_ = new ui::EventModifiersEvdev();
  69     device_ = new ui::MockKeyEventConverterEvdev(events_in_, modifiers_);
  70   }
  71   virtual void TearDown() OVERRIDE {
  72     delete device_;
  73     delete modifiers_;
  74     close(events_in_);
  75     close(events_out_);
  76   }
  77
  78   ui::MockKeyEventConverterEvdev* device() { return device_; }
  79   ui::EventModifiersEvdev* modifiers() { return modifiers_; }
  80
  81  private:
  82   base::MessageLoopForUI ui_loop_;
  83
  84   ui::EventModifiersEvdev* modifiers_;
  85   ui::MockKeyEventConverterEvdev* device_;
  86
  87   int events_out_;
  88   int events_in_;
  89
  90   DISALLOW_COPY_AND_ASSIGN(KeyEventConverterEvdevTest);
  91 };
  92
  93 TEST_F(KeyEventConverterEvdevTest, KeyPress) {
  94   ui::MockKeyEventConverterEvdev* dev = device();
  95
  96   struct input_event mock_kernel_queue[] = {
  97       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
  98       {{0, 0}, EV_KEY, KEY_BACKSPACE, 1},
  99       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 100
 101       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
 102       {{0, 0}, EV_KEY, KEY_BACKSPACE, 0},
 103       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 104   };
 105
 106   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 107   EXPECT_EQ(2u, dev->size());
 108
 109   ui::KeyEvent* event;
 110
 111   event = dev->event(0);
 112   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 113   EXPECT_EQ(ui::VKEY_BACK, event->key_code());
 114   EXPECT_EQ(0, event->flags());
 115
 116   event = dev->event(1);
 117   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 118   EXPECT_EQ(ui::VKEY_BACK, event->key_code());
 119   EXPECT_EQ(0, event->flags());
 120 }
 121
 122 TEST_F(KeyEventConverterEvdevTest, KeyRepeat) {
 123   ui::MockKeyEventConverterEvdev* dev = device();
 124
 125   struct input_event mock_kernel_queue[] = {
 126       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
 127       {{0, 0}, EV_KEY, KEY_BACKSPACE, 1},
 128       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 129
 130       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
 131       {{0, 0}, EV_KEY, KEY_BACKSPACE, 2},
 132       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 133
 134       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
 135       {{0, 0}, EV_KEY, KEY_BACKSPACE, 2},
 136       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 137
 138       {{0, 0}, EV_MSC, MSC_SCAN, 0x7002a},
 139       {{0, 0}, EV_KEY, KEY_BACKSPACE, 0},
 140       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 141   };
 142
 143   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 144   EXPECT_EQ(4u, dev->size());
 145
 146   ui::KeyEvent* event;
 147
 148   event = dev->event(0);
 149   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 150   EXPECT_EQ(ui::VKEY_BACK, event->key_code());
 151   EXPECT_EQ(0, event->flags());
 152
 153   event = dev->event(1);
 154   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 155   EXPECT_EQ(ui::VKEY_BACK, event->key_code());
 156   EXPECT_EQ(0, event->flags());
 157
 158   event = dev->event(2);
 159   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 160   EXPECT_EQ(ui::VKEY_BACK, event->key_code());
 161   EXPECT_EQ(0, event->flags());
 162
 163   event = dev->event(3);
 164   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 165   EXPECT_EQ(ui::VKEY_BACK, event->key_code());
 166   EXPECT_EQ(0, event->flags());
 167 }
 168
 169 TEST_F(KeyEventConverterEvdevTest, NoEvents) {
 170   ui::MockKeyEventConverterEvdev* dev = device();
 171   dev->ProcessEvents(NULL, 0);
 172   EXPECT_EQ(0u, dev->size());
 173 }
 174
 175 TEST_F(KeyEventConverterEvdevTest, KeyWithModifier) {
 176   ui::MockKeyEventConverterEvdev* dev = device();
 177
 178   struct input_event mock_kernel_queue[] = {
 179       {{0, 0}, EV_MSC, MSC_SCAN, 0x700e1},
 180       {{0, 0}, EV_KEY, KEY_LEFTSHIFT, 1},
 181       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 182
 183       {{0, 0}, EV_MSC, MSC_SCAN, 0x70004},
 184       {{0, 0}, EV_KEY, KEY_A, 1},
 185       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 186
 187       {{0, 0}, EV_MSC, MSC_SCAN, 0x70004},
 188       {{0, 0}, EV_KEY, KEY_A, 0},
 189       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 190
 191       {{0, 0}, EV_MSC, MSC_SCAN, 0x700e1},
 192       {{0, 0}, EV_KEY, KEY_LEFTSHIFT, 0},
 193       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 194   };
 195
 196   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 197   EXPECT_EQ(4u, dev->size());
 198
 199   ui::KeyEvent* event;
 200
 201   event = dev->event(0);
 202   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 203   EXPECT_EQ(ui::VKEY_SHIFT, event->key_code());
 204   EXPECT_EQ(ui::EF_SHIFT_DOWN, event->flags());
 205
 206   event = dev->event(1);
 207   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 208   EXPECT_EQ(ui::VKEY_A, event->key_code());
 209   EXPECT_EQ(ui::EF_SHIFT_DOWN, event->flags());
 210
 211   event = dev->event(2);
 212   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 213   EXPECT_EQ(ui::VKEY_A, event->key_code());
 214   EXPECT_EQ(ui::EF_SHIFT_DOWN, event->flags());
 215
 216   event = dev->event(3);
 217   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 218   EXPECT_EQ(ui::VKEY_SHIFT, event->key_code());
 219   EXPECT_EQ(0, event->flags());
 220 }
 221
 222 TEST_F(KeyEventConverterEvdevTest, KeyWithDuplicateModifier) {
 223   ui::MockKeyEventConverterEvdev* dev = device();
 224
 225   struct input_event mock_kernel_queue[] = {
 226       {{0, 0}, EV_MSC, MSC_SCAN, 0x700e1},
 227       {{0, 0}, EV_KEY, KEY_LEFTCTRL, 1},
 228       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 229
 230       {{0, 0}, EV_MSC, MSC_SCAN, 0x700e5},
 231       {{0, 0}, EV_KEY, KEY_RIGHTCTRL, 1},
 232       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 233
 234       {{0, 0}, EV_MSC, MSC_SCAN, 0x7001d},
 235       {{0, 0}, EV_KEY, KEY_Z, 1},
 236       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 237
 238       {{0, 0}, EV_MSC, MSC_SCAN, 0x7001d},
 239       {{0, 0}, EV_KEY, KEY_Z, 0},
 240       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 241
 242       {{0, 0}, EV_MSC, MSC_SCAN, 0x700e1},
 243       {{0, 0}, EV_KEY, KEY_LEFTCTRL, 0},
 244       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 245
 246       {{0, 0}, EV_MSC, MSC_SCAN, 0x700e5},
 247       {{0, 0}, EV_KEY, KEY_RIGHTCTRL, 0},
 248       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 249   };
 250
 251   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 252   EXPECT_EQ(6u, dev->size());
 253
 254   ui::KeyEvent* event;
 255
 256   event = dev->event(0);
 257   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 258   EXPECT_EQ(ui::VKEY_CONTROL, event->key_code());
 259   EXPECT_EQ(ui::EF_CONTROL_DOWN, event->flags());
 260
 261   event = dev->event(1);
 262   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 263   EXPECT_EQ(ui::VKEY_CONTROL, event->key_code());
 264   EXPECT_EQ(ui::EF_CONTROL_DOWN, event->flags());
 265
 266   event = dev->event(2);
 267   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 268   EXPECT_EQ(ui::VKEY_Z, event->key_code());
 269   EXPECT_EQ(ui::EF_CONTROL_DOWN, event->flags());
 270
 271   event = dev->event(3);
 272   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 273   EXPECT_EQ(ui::VKEY_Z, event->key_code());
 274   EXPECT_EQ(ui::EF_CONTROL_DOWN, event->flags());
 275
 276   event = dev->event(4);
 277   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 278   EXPECT_EQ(ui::VKEY_CONTROL, event->key_code());
 279   EXPECT_EQ(ui::EF_CONTROL_DOWN, event->flags());
 280
 281   event = dev->event(5);
 282   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 283   EXPECT_EQ(ui::VKEY_CONTROL, event->key_code());
 284   EXPECT_EQ(0, event->flags());
 285 }
 286
 287 TEST_F(KeyEventConverterEvdevTest, KeyWithLock) {
 288   ui::MockKeyEventConverterEvdev* dev = device();
 289
 290   struct input_event mock_kernel_queue[] = {
 291       {{0, 0}, EV_MSC, MSC_SCAN, 0x70039},
 292       {{0, 0}, EV_KEY, KEY_CAPSLOCK, 1},
 293       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 294
 295       {{0, 0}, EV_MSC, MSC_SCAN, 0x70039},
 296       {{0, 0}, EV_KEY, KEY_CAPSLOCK, 0},
 297       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 298
 299       {{0, 0}, EV_MSC, MSC_SCAN, 0x70014},
 300       {{0, 0}, EV_KEY, KEY_Q, 1},
 301       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 302
 303       {{0, 0}, EV_MSC, MSC_SCAN, 0x70014},
 304       {{0, 0}, EV_KEY, KEY_Q, 0},
 305       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 306
 307       {{0, 0}, EV_MSC, MSC_SCAN, 0x70039},
 308       {{0, 0}, EV_KEY, KEY_CAPSLOCK, 1},
 309       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 310
 311       {{0, 0}, EV_MSC, MSC_SCAN, 0x70039},
 312       {{0, 0}, EV_KEY, KEY_CAPSLOCK, 0},
 313       {{0, 0}, EV_SYN, SYN_REPORT, 0},
 314   };
 315
 316   dev->ProcessEvents(mock_kernel_queue, arraysize(mock_kernel_queue));
 317   EXPECT_EQ(6u, dev->size());
 318
 319   ui::KeyEvent* event;
 320
 321   event = dev->event(0);
 322   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 323   EXPECT_EQ(ui::VKEY_CAPITAL, event->key_code());
 324   EXPECT_EQ(ui::EF_CAPS_LOCK_DOWN, event->flags());
 325
 326   event = dev->event(1);
 327   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 328   EXPECT_EQ(ui::VKEY_CAPITAL, event->key_code());
 329   EXPECT_EQ(ui::EF_CAPS_LOCK_DOWN, event->flags());
 330
 331   event = dev->event(2);
 332   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 333   EXPECT_EQ(ui::VKEY_Q, event->key_code());
 334   EXPECT_EQ(ui::EF_CAPS_LOCK_DOWN, event->flags());
 335
 336   event = dev->event(3);
 337   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 338   EXPECT_EQ(ui::VKEY_Q, event->key_code());
 339   EXPECT_EQ(ui::EF_CAPS_LOCK_DOWN, event->flags());
 340
 341   event = dev->event(4);
 342   EXPECT_EQ(ui::ET_KEY_PRESSED, event->type());
 343   EXPECT_EQ(ui::VKEY_CAPITAL, event->key_code());
 344   EXPECT_EQ(0, event->flags());
 345
 346   event = dev->event(5);
 347   EXPECT_EQ(ui::ET_KEY_RELEASED, event->type());
 348   EXPECT_EQ(ui::VKEY_CAPITAL, event->key_code());
 349   EXPECT_EQ(0, event->flags());
 350 }