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 <errno.h>
6#include <fcntl.h>
7#include <linux/input.h>
8#include <unistd.h>
9
10#include <vector>
11
12#include "base/bind.h"
13#include "base/memory/scoped_ptr.h"
14#include "base/memory/scoped_vector.h"
15#include "base/posix/eintr_wrapper.h"
16#include "base/run_loop.h"
17#include "base/time/time.h"
18#include "testing/gtest/include/gtest/gtest.h"
19#include "ui/events/event.h"
20#include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
21#include "ui/events/platform/platform_event_dispatcher.h"
22#include "ui/events/platform/platform_event_source.h"
23
24namespace {
25
26static int SetNonBlocking(int fd) {
27  int flags = fcntl(fd, F_GETFL, 0);
28  if (flags == -1)
29    flags = 0;
30  return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
31}
32
33const char kTestDevicePath[] = "/dev/input/test-device";
34
35}  // namespace
36
37namespace ui {
38
39class MockTouchEventConverterEvdev : public TouchEventConverterEvdev {
40 public:
41  MockTouchEventConverterEvdev(int fd, base::FilePath path);
42  virtual ~MockTouchEventConverterEvdev() {};
43
44  void ConfigureReadMock(struct input_event* queue,
45                         long read_this_many,
46                         long queue_index);
47
48  unsigned size() { return dispatched_events_.size(); }
49  TouchEvent* event(unsigned index) { return dispatched_events_[index]; }
50
51  // Actually dispatch the event reader code.
52  void ReadNow() {
53    OnFileCanReadWithoutBlocking(read_pipe_);
54    base::RunLoop().RunUntilIdle();
55  }
56
57  void DispatchCallback(Event* event) {
58    dispatched_events_.push_back(
59        new TouchEvent(*static_cast<TouchEvent*>(event)));
60  }
61
62  virtual bool Reinitialize() OVERRIDE { return true; }
63
64 private:
65  int read_pipe_;
66  int write_pipe_;
67
68  ScopedVector<TouchEvent> dispatched_events_;
69
70  DISALLOW_COPY_AND_ASSIGN(MockTouchEventConverterEvdev);
71};
72
73MockTouchEventConverterEvdev::MockTouchEventConverterEvdev(int fd,
74                                                           base::FilePath path)
75    : TouchEventConverterEvdev(
76          fd,
77          path,
78          EventDeviceInfo(),
79          base::Bind(&MockTouchEventConverterEvdev::DispatchCallback,
80                     base::Unretained(this))) {
81  pressure_min_ = 30;
82  pressure_max_ = 60;
83
84  // TODO(rjkroege): Check test axes.
85  x_min_pixels_ = x_min_tuxels_ = 0;
86  x_num_pixels_ = x_num_tuxels_ = std::numeric_limits<int>::max();
87  y_min_pixels_ = y_min_tuxels_ = 0;
88  y_num_pixels_ = y_num_tuxels_ = std::numeric_limits<int>::max();
89
90  int fds[2];
91
92  if (pipe(fds))
93    PLOG(FATAL) << "failed pipe";
94
95  DCHECK(SetNonBlocking(fds[0]) == 0)
96      << "SetNonBlocking for pipe fd[0] failed, errno: " << errno;
97  DCHECK(SetNonBlocking(fds[1]) == 0)
98      << "SetNonBlocking for pipe fd[0] failed, errno: " << errno;
99  read_pipe_ = fds[0];
100  write_pipe_ = fds[1];
101}
102
103void MockTouchEventConverterEvdev::ConfigureReadMock(struct input_event* queue,
104                                                     long read_this_many,
105                                                     long queue_index) {
106  int nwrite = HANDLE_EINTR(write(write_pipe_,
107                                  queue + queue_index,
108                                  sizeof(struct input_event) * read_this_many));
109  DCHECK(nwrite ==
110         static_cast<int>(sizeof(struct input_event) * read_this_many))
111      << "write() failed, errno: " << errno;
112}
113
114}  // namespace ui
115
116// Test fixture.
117class TouchEventConverterEvdevTest : public testing::Test {
118 public:
119  TouchEventConverterEvdevTest() {}
120
121  // Overridden from testing::Test:
122  virtual void SetUp() OVERRIDE {
123    // Set up pipe to satisfy message pump (unused).
124    int evdev_io[2];
125    if (pipe(evdev_io))
126      PLOG(FATAL) << "failed pipe";
127    events_in_ = evdev_io[0];
128    events_out_ = evdev_io[1];
129
130    loop_ = new base::MessageLoopForUI;
131    device_ = new ui::MockTouchEventConverterEvdev(
132        events_in_, base::FilePath(kTestDevicePath));
133  }
134
135  virtual void TearDown() OVERRIDE {
136    delete device_;
137    delete loop_;
138  }
139
140  ui::MockTouchEventConverterEvdev* device() { return device_; }
141
142 private:
143  base::MessageLoop* loop_;
144  ui::MockTouchEventConverterEvdev* device_;
145
146  int events_out_;
147  int events_in_;
148
149  DISALLOW_COPY_AND_ASSIGN(TouchEventConverterEvdevTest);
150};
151
152// TODO(rjkroege): Test for valid handling of time stamps.
153TEST_F(TouchEventConverterEvdevTest, TouchDown) {
154  ui::MockTouchEventConverterEvdev* dev = device();
155
156  struct input_event mock_kernel_queue[] = {
157    {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 684},
158    {{0, 0}, EV_ABS, ABS_MT_TOUCH_MAJOR, 3},
159    {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 45},
160    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
161    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 51}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
162  };
163
164  dev->ConfigureReadMock(mock_kernel_queue, 1, 0);
165  dev->ReadNow();
166  EXPECT_EQ(0u, dev->size());
167
168  dev->ConfigureReadMock(mock_kernel_queue, 2, 1);
169  dev->ReadNow();
170  EXPECT_EQ(0u, dev->size());
171
172  dev->ConfigureReadMock(mock_kernel_queue, 3, 3);
173  dev->ReadNow();
174  EXPECT_EQ(1u, dev->size());
175
176  ui::TouchEvent* event = dev->event(0);
177  EXPECT_FALSE(event == NULL);
178
179  EXPECT_EQ(ui::ET_TOUCH_PRESSED, event->type());
180  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), event->time_stamp());
181  EXPECT_EQ(42, event->x());
182  EXPECT_EQ(51, event->y());
183  EXPECT_EQ(0, event->touch_id());
184  EXPECT_FLOAT_EQ(1.5f, event->radius_x());
185  EXPECT_FLOAT_EQ(.5f, event->force());
186  EXPECT_FLOAT_EQ(0.f, event->rotation_angle());
187}
188
189TEST_F(TouchEventConverterEvdevTest, NoEvents) {
190  ui::MockTouchEventConverterEvdev* dev = device();
191  dev->ConfigureReadMock(NULL, 0, 0);
192  EXPECT_EQ(0u, dev->size());
193}
194
195TEST_F(TouchEventConverterEvdevTest, TouchMove) {
196  ui::MockTouchEventConverterEvdev* dev = device();
197
198  struct input_event mock_kernel_queue_press[] = {
199    {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 684},
200    {{0, 0}, EV_ABS, ABS_MT_TOUCH_MAJOR, 3},
201    {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 45},
202    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
203    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 51}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
204  };
205
206  struct input_event mock_kernel_queue_move1[] = {
207    {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 50},
208    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
209    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 43}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
210  };
211
212  struct input_event mock_kernel_queue_move2[] = {
213    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 42}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
214  };
215
216  // Setup and discard a press.
217  dev->ConfigureReadMock(mock_kernel_queue_press, 6, 0);
218  dev->ReadNow();
219  EXPECT_EQ(1u, dev->size());
220
221  dev->ConfigureReadMock(mock_kernel_queue_move1, 4, 0);
222  dev->ReadNow();
223  EXPECT_EQ(2u, dev->size());
224  ui::TouchEvent* event = dev->event(1);
225  EXPECT_FALSE(event == NULL);
226
227  EXPECT_EQ(ui::ET_TOUCH_MOVED, event->type());
228  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), event->time_stamp());
229  EXPECT_EQ(42, event->x());
230  EXPECT_EQ(43, event->y());
231  EXPECT_EQ(0, event->touch_id());
232  EXPECT_FLOAT_EQ(2.f / 3.f, event->force());
233  EXPECT_FLOAT_EQ(0.f, event->rotation_angle());
234
235  dev->ConfigureReadMock(mock_kernel_queue_move2, 2, 0);
236  dev->ReadNow();
237  EXPECT_EQ(3u, dev->size());
238  event = dev->event(2);
239  EXPECT_FALSE(event == NULL);
240
241  EXPECT_EQ(ui::ET_TOUCH_MOVED, event->type());
242  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), event->time_stamp());
243  EXPECT_EQ(42, event->x());
244  EXPECT_EQ(42, event->y());
245  EXPECT_EQ(0, event->touch_id());
246  EXPECT_FLOAT_EQ(2.f / 3.f, event->force());
247  EXPECT_FLOAT_EQ(0.f, event->rotation_angle());
248}
249
250TEST_F(TouchEventConverterEvdevTest, TouchRelease) {
251  ui::MockTouchEventConverterEvdev* dev = device();
252
253  struct input_event mock_kernel_queue_press[] = {
254    {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 684},
255    {{0, 0}, EV_ABS, ABS_MT_TOUCH_MAJOR, 3},
256    {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 45},
257    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
258    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 51}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
259  };
260
261  struct input_event mock_kernel_queue_release[] = {
262    {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
263  };
264
265  // Setup and discard a press.
266  dev->ConfigureReadMock(mock_kernel_queue_press, 6, 0);
267  dev->ReadNow();
268  EXPECT_EQ(1u, dev->size());
269  ui::TouchEvent* event = dev->event(0);
270  EXPECT_FALSE(event == NULL);
271
272  dev->ConfigureReadMock(mock_kernel_queue_release, 2, 0);
273  dev->ReadNow();
274  EXPECT_EQ(2u, dev->size());
275  event = dev->event(1);
276  EXPECT_FALSE(event == NULL);
277
278  EXPECT_EQ(ui::ET_TOUCH_RELEASED, event->type());
279  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), event->time_stamp());
280  EXPECT_EQ(42, event->x());
281  EXPECT_EQ(51, event->y());
282  EXPECT_EQ(0, event->touch_id());
283  EXPECT_FLOAT_EQ(.5f, event->force());
284  EXPECT_FLOAT_EQ(0.f, event->rotation_angle());
285}
286
287TEST_F(TouchEventConverterEvdevTest, TwoFingerGesture) {
288  ui::MockTouchEventConverterEvdev* dev = device();
289
290  ui::TouchEvent* ev0;
291  ui::TouchEvent* ev1;
292
293  struct input_event mock_kernel_queue_press0[] = {
294    {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 684},
295    {{0, 0}, EV_ABS, ABS_MT_TOUCH_MAJOR, 3},
296    {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 45},
297    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
298    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 51}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
299  };
300  // Setup and discard a press.
301  dev->ConfigureReadMock(mock_kernel_queue_press0, 6, 0);
302  dev->ReadNow();
303  EXPECT_EQ(1u, dev->size());
304
305  struct input_event mock_kernel_queue_move0[] = {
306    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
307  };
308  // Setup and discard a move.
309  dev->ConfigureReadMock(mock_kernel_queue_move0, 2, 0);
310  dev->ReadNow();
311  EXPECT_EQ(2u, dev->size());
312
313  struct input_event mock_kernel_queue_move0press1[] = {
314    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0},
315    {{0, 0}, EV_ABS, ABS_MT_SLOT, 1}, {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 686},
316    {{0, 0}, EV_ABS, ABS_MT_TOUCH_MAJOR, 3},
317    {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 45},
318    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 101},
319    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 102}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
320  };
321  // Move on 0, press on 1.
322  dev->ConfigureReadMock(mock_kernel_queue_move0press1, 9, 0);
323  dev->ReadNow();
324  EXPECT_EQ(4u, dev->size());
325  ev0 = dev->event(2);
326  ev1 = dev->event(3);
327
328  // Move
329  EXPECT_EQ(ui::ET_TOUCH_MOVED, ev0->type());
330  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev0->time_stamp());
331  EXPECT_EQ(40, ev0->x());
332  EXPECT_EQ(51, ev0->y());
333  EXPECT_EQ(0, ev0->touch_id());
334  EXPECT_FLOAT_EQ(.5f, ev0->force());
335  EXPECT_FLOAT_EQ(0.f, ev0->rotation_angle());
336
337  // Press
338  EXPECT_EQ(ui::ET_TOUCH_PRESSED, ev1->type());
339  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1->time_stamp());
340  EXPECT_EQ(101, ev1->x());
341  EXPECT_EQ(102, ev1->y());
342  EXPECT_EQ(1, ev1->touch_id());
343  EXPECT_FLOAT_EQ(.5f, ev1->force());
344  EXPECT_FLOAT_EQ(0.f, ev1->rotation_angle());
345
346  // Stationary 0, Moves 1.
347  struct input_event mock_kernel_queue_stationary0_move1[] = {
348    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
349  };
350  dev->ConfigureReadMock(mock_kernel_queue_stationary0_move1, 2, 0);
351  dev->ReadNow();
352  EXPECT_EQ(5u, dev->size());
353  ev1 = dev->event(4);
354
355  EXPECT_EQ(ui::ET_TOUCH_MOVED, ev1->type());
356  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1->time_stamp());
357  EXPECT_EQ(40, ev1->x());
358  EXPECT_EQ(102, ev1->y());
359  EXPECT_EQ(1, ev1->touch_id());
360
361  EXPECT_FLOAT_EQ(.5f, ev1->force());
362  EXPECT_FLOAT_EQ(0.f, ev1->rotation_angle());
363
364  // Move 0, stationary 1.
365  struct input_event mock_kernel_queue_move0_stationary1[] = {
366    {{0, 0}, EV_ABS, ABS_MT_SLOT, 0}, {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 39},
367    {{0, 0}, EV_SYN, SYN_REPORT, 0}
368  };
369  dev->ConfigureReadMock(mock_kernel_queue_move0_stationary1, 3, 0);
370  dev->ReadNow();
371  EXPECT_EQ(6u, dev->size());
372  ev0 = dev->event(5);
373
374  EXPECT_EQ(ui::ET_TOUCH_MOVED, ev0->type());
375  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev0->time_stamp());
376  EXPECT_EQ(39, ev0->x());
377  EXPECT_EQ(51, ev0->y());
378  EXPECT_EQ(0, ev0->touch_id());
379  EXPECT_FLOAT_EQ(.5f, ev0->force());
380  EXPECT_FLOAT_EQ(0.f, ev0->rotation_angle());
381
382  // Release 0, move 1.
383  struct input_event mock_kernel_queue_release0_move1[] = {
384    {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1}, {{0, 0}, EV_ABS, ABS_MT_SLOT, 1},
385    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 38}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
386  };
387  dev->ConfigureReadMock(mock_kernel_queue_release0_move1, 4, 0);
388  dev->ReadNow();
389  EXPECT_EQ(8u, dev->size());
390  ev0 = dev->event(6);
391  ev1 = dev->event(7);
392
393  EXPECT_EQ(ui::ET_TOUCH_RELEASED, ev0->type());
394  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev0->time_stamp());
395  EXPECT_EQ(39, ev0->x());
396  EXPECT_EQ(51, ev0->y());
397  EXPECT_EQ(0, ev0->touch_id());
398  EXPECT_FLOAT_EQ(.5f, ev0->force());
399  EXPECT_FLOAT_EQ(0.f, ev0->rotation_angle());
400
401  EXPECT_EQ(ui::ET_TOUCH_MOVED, ev1->type());
402  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1->time_stamp());
403  EXPECT_EQ(38, ev1->x());
404  EXPECT_EQ(102, ev1->y());
405  EXPECT_EQ(1, ev1->touch_id());
406  EXPECT_FLOAT_EQ(.5f, ev1->force());
407  EXPECT_FLOAT_EQ(0.f, ev1->rotation_angle());
408
409  // Release 1.
410  struct input_event mock_kernel_queue_release1[] = {
411    {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1}, {{0, 0}, EV_SYN, SYN_REPORT, 0},
412  };
413  dev->ConfigureReadMock(mock_kernel_queue_release1, 2, 0);
414  dev->ReadNow();
415  EXPECT_EQ(9u, dev->size());
416  ev1 = dev->event(8);
417
418  EXPECT_EQ(ui::ET_TOUCH_RELEASED, ev1->type());
419  EXPECT_EQ(base::TimeDelta::FromMicroseconds(0), ev1->time_stamp());
420  EXPECT_EQ(38, ev1->x());
421  EXPECT_EQ(102, ev1->y());
422  EXPECT_EQ(1, ev1->touch_id());
423  EXPECT_FLOAT_EQ(.5f, ev1->force());
424  EXPECT_FLOAT_EQ(0.f, ev1->rotation_angle());
425}
426
427TEST_F(TouchEventConverterEvdevTest, TypeA) {
428  ui::MockTouchEventConverterEvdev* dev = device();
429
430  struct input_event mock_kernel_queue_press0[] = {
431    {{0, 0}, EV_ABS, ABS_MT_TOUCH_MAJOR, 3},
432    {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 45},
433    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
434    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 51},
435    {{0, 0}, EV_SYN, SYN_MT_REPORT, 0},
436    {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 45},
437    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 61},
438    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 71},
439    {{0, 0}, EV_SYN, SYN_MT_REPORT, 0},
440    {{0, 0}, EV_SYN, SYN_REPORT, 0}
441  };
442
443  // Check that two events are generated.
444  dev->ConfigureReadMock(mock_kernel_queue_press0, 10, 0);
445  dev->ReadNow();
446  EXPECT_EQ(2u, dev->size());
447}
448
449TEST_F(TouchEventConverterEvdevTest, Unsync) {
450  ui::MockTouchEventConverterEvdev* dev = device();
451
452  struct input_event mock_kernel_queue_press0[] = {
453    {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 684},
454    {{0, 0}, EV_ABS, ABS_MT_TOUCH_MAJOR, 3},
455    {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 45},
456    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
457    {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 51}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
458  };
459
460  dev->ConfigureReadMock(mock_kernel_queue_press0, 6, 0);
461  dev->ReadNow();
462  EXPECT_EQ(1u, dev->size());
463
464  // Prepare a move with a drop.
465  struct input_event mock_kernel_queue_move0[] = {
466    {{0, 0}, EV_SYN, SYN_DROPPED, 0},
467    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
468  };
469
470  // Verify that we didn't receive it/
471  dev->ConfigureReadMock(mock_kernel_queue_move0, 3, 0);
472  dev->ReadNow();
473  EXPECT_EQ(1u, dev->size());
474
475  struct input_event mock_kernel_queue_move1[] = {
476    {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 40}, {{0, 0}, EV_SYN, SYN_REPORT, 0}
477  };
478
479  // Verify that it re-syncs after a SYN_REPORT.
480  dev->ConfigureReadMock(mock_kernel_queue_move1, 2, 0);
481  dev->ReadNow();
482  EXPECT_EQ(2u, dev->size());
483}
484
485// crbug.com/407386
486TEST_F(TouchEventConverterEvdevTest,
487       DontChangeMultitouchPositionFromLegacyAxes) {
488  ui::MockTouchEventConverterEvdev* dev = device();
489
490  struct input_event mock_kernel_queue[] = {
491      {{0, 0}, EV_ABS, ABS_MT_SLOT, 0},
492      {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 100},
493      {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 999},
494      {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 888},
495      {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 55},
496      {{0, 0}, EV_ABS, ABS_MT_SLOT, 1},
497      {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, 200},
498      {{0, 0}, EV_ABS, ABS_MT_PRESSURE, 44},
499      {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 777},
500      {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 666},
501      {{0, 0}, EV_ABS, ABS_X, 999},
502      {{0, 0}, EV_ABS, ABS_Y, 888},
503      {{0, 0}, EV_ABS, ABS_PRESSURE, 55},
504      {{0, 0}, EV_SYN, SYN_REPORT, 0},
505  };
506
507  // Check that two events are generated.
508  dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
509  dev->ReadNow();
510
511  const unsigned int kExpectedEventCount = 2;
512  EXPECT_EQ(kExpectedEventCount, dev->size());
513  if (kExpectedEventCount != dev->size())
514    return;
515
516  ui::TouchEvent* ev0 = dev->event(0);
517  ui::TouchEvent* ev1 = dev->event(1);
518
519  EXPECT_EQ(0, ev0->touch_id());
520  EXPECT_EQ(999, ev0->x());
521  EXPECT_EQ(888, ev0->y());
522  EXPECT_FLOAT_EQ(0.8333333f, ev0->force());
523
524  EXPECT_EQ(1, ev1->touch_id());
525  EXPECT_EQ(777, ev1->x());
526  EXPECT_EQ(666, ev1->y());
527  EXPECT_FLOAT_EQ(0.4666666f, ev1->force());
528}
529