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
16namespace ui {
17
18const char kTestDevicePath[] = "/dev/input/test-device";
19
20class 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
47void MockKeyEventConverterEvdev::DispatchEventForTest(Event* event) {
48  dispatched_events_.push_back(new KeyEvent(*static_cast<KeyEvent*>(event)));
49}
50
51}  // namespace ui
52
53// Test fixture.
54class 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
93TEST_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
122TEST_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
169TEST_F(KeyEventConverterEvdevTest, NoEvents) {
170  ui::MockKeyEventConverterEvdev* dev = device();
171  dev->ProcessEvents(NULL, 0);
172  EXPECT_EQ(0u, dev->size());
173}
174
175TEST_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
222TEST_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
287TEST_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