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 24 namespace { 25 26 static 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 33 const char kTestDevicePath[] = "/dev/input/test-device"; 34 35 } // namespace 36 37 namespace ui { 38 39 class 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 73 MockTouchEventConverterEvdev::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 103 void 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. 117 class 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. 153 TEST_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 189 TEST_F(TouchEventConverterEvdevTest, NoEvents) { 190 ui::MockTouchEventConverterEvdev* dev = device(); 191 dev->ConfigureReadMock(NULL, 0, 0); 192 EXPECT_EQ(0u, dev->size()); 193 } 194 195 TEST_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 250 TEST_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 287 TEST_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 427 TEST_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 449 TEST_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 486 TEST_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
