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 } 351
