src/ui/events/ozone/evdev/key_event_converter_unittest.cc

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