1/* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include <androidfw/Input.h> 18#include <gtest/gtest.h> 19#include <binder/Parcel.h> 20 21#include <math.h> 22#include <SkMatrix.h> 23 24namespace android { 25 26class BaseTest : public testing::Test { 27protected: 28 virtual void SetUp() { } 29 virtual void TearDown() { } 30}; 31 32// --- PointerCoordsTest --- 33 34class PointerCoordsTest : public BaseTest { 35}; 36 37TEST_F(PointerCoordsTest, ClearSetsBitsToZero) { 38 PointerCoords coords; 39 coords.clear(); 40 41 ASSERT_EQ(0ULL, coords.bits); 42} 43 44TEST_F(PointerCoordsTest, AxisValues) { 45 float* valuePtr; 46 PointerCoords coords; 47 coords.clear(); 48 49 // Check invariants when no axes are present. 50 ASSERT_EQ(0, coords.getAxisValue(0)) 51 << "getAxisValue should return zero because axis is not present"; 52 ASSERT_EQ(0, coords.getAxisValue(1)) 53 << "getAxisValue should return zero because axis is not present"; 54 55 // Set first axis. 56 ASSERT_EQ(OK, coords.setAxisValue(1, 5)); 57 ASSERT_EQ(0x00000002ULL, coords.bits); 58 ASSERT_EQ(5, coords.values[0]); 59 60 ASSERT_EQ(0, coords.getAxisValue(0)) 61 << "getAxisValue should return zero because axis is not present"; 62 ASSERT_EQ(5, coords.getAxisValue(1)) 63 << "getAxisValue should return value of axis"; 64 65 // Set an axis with a higher id than all others. (appending value at the end) 66 ASSERT_EQ(OK, coords.setAxisValue(3, 2)); 67 ASSERT_EQ(0x0000000aULL, coords.bits); 68 ASSERT_EQ(5, coords.values[0]); 69 ASSERT_EQ(2, coords.values[1]); 70 71 ASSERT_EQ(0, coords.getAxisValue(0)) 72 << "getAxisValue should return zero because axis is not present"; 73 ASSERT_EQ(5, coords.getAxisValue(1)) 74 << "getAxisValue should return value of axis"; 75 ASSERT_EQ(0, coords.getAxisValue(2)) 76 << "getAxisValue should return zero because axis is not present"; 77 ASSERT_EQ(2, coords.getAxisValue(3)) 78 << "getAxisValue should return value of axis"; 79 80 // Set an axis with an id lower than all others. (prepending value at beginning) 81 ASSERT_EQ(OK, coords.setAxisValue(0, 4)); 82 ASSERT_EQ(0x0000000bULL, coords.bits); 83 ASSERT_EQ(4, coords.values[0]); 84 ASSERT_EQ(5, coords.values[1]); 85 ASSERT_EQ(2, coords.values[2]); 86 87 ASSERT_EQ(4, coords.getAxisValue(0)) 88 << "getAxisValue should return value of axis"; 89 ASSERT_EQ(5, coords.getAxisValue(1)) 90 << "getAxisValue should return value of axis"; 91 ASSERT_EQ(0, coords.getAxisValue(2)) 92 << "getAxisValue should return zero because axis is not present"; 93 ASSERT_EQ(2, coords.getAxisValue(3)) 94 << "getAxisValue should return value of axis"; 95 96 // Set an axis with an id between the others. (inserting value in the middle) 97 ASSERT_EQ(OK, coords.setAxisValue(2, 1)); 98 ASSERT_EQ(0x0000000fULL, coords.bits); 99 ASSERT_EQ(4, coords.values[0]); 100 ASSERT_EQ(5, coords.values[1]); 101 ASSERT_EQ(1, coords.values[2]); 102 ASSERT_EQ(2, coords.values[3]); 103 104 ASSERT_EQ(4, coords.getAxisValue(0)) 105 << "getAxisValue should return value of axis"; 106 ASSERT_EQ(5, coords.getAxisValue(1)) 107 << "getAxisValue should return value of axis"; 108 ASSERT_EQ(1, coords.getAxisValue(2)) 109 << "getAxisValue should return value of axis"; 110 ASSERT_EQ(2, coords.getAxisValue(3)) 111 << "getAxisValue should return value of axis"; 112 113 // Set an existing axis value in place. 114 ASSERT_EQ(OK, coords.setAxisValue(1, 6)); 115 ASSERT_EQ(0x0000000fULL, coords.bits); 116 ASSERT_EQ(4, coords.values[0]); 117 ASSERT_EQ(6, coords.values[1]); 118 ASSERT_EQ(1, coords.values[2]); 119 ASSERT_EQ(2, coords.values[3]); 120 121 ASSERT_EQ(4, coords.getAxisValue(0)) 122 << "getAxisValue should return value of axis"; 123 ASSERT_EQ(6, coords.getAxisValue(1)) 124 << "getAxisValue should return value of axis"; 125 ASSERT_EQ(1, coords.getAxisValue(2)) 126 << "getAxisValue should return value of axis"; 127 ASSERT_EQ(2, coords.getAxisValue(3)) 128 << "getAxisValue should return value of axis"; 129 130 // Set maximum number of axes. 131 for (size_t axis = 4; axis < PointerCoords::MAX_AXES; axis++) { 132 ASSERT_EQ(OK, coords.setAxisValue(axis, axis)); 133 } 134 ASSERT_EQ(PointerCoords::MAX_AXES, __builtin_popcountll(coords.bits)); 135 136 // Try to set one more axis beyond maximum number. 137 // Ensure bits are unchanged. 138 ASSERT_EQ(NO_MEMORY, coords.setAxisValue(PointerCoords::MAX_AXES, 100)); 139 ASSERT_EQ(PointerCoords::MAX_AXES, __builtin_popcountll(coords.bits)); 140} 141 142TEST_F(PointerCoordsTest, Parcel) { 143 Parcel parcel; 144 145 PointerCoords inCoords; 146 inCoords.clear(); 147 PointerCoords outCoords; 148 149 // Round trip with empty coords. 150 inCoords.writeToParcel(&parcel); 151 parcel.setDataPosition(0); 152 outCoords.readFromParcel(&parcel); 153 154 ASSERT_EQ(0ULL, outCoords.bits); 155 156 // Round trip with some values. 157 parcel.freeData(); 158 inCoords.setAxisValue(2, 5); 159 inCoords.setAxisValue(5, 8); 160 161 inCoords.writeToParcel(&parcel); 162 parcel.setDataPosition(0); 163 outCoords.readFromParcel(&parcel); 164 165 ASSERT_EQ(outCoords.bits, inCoords.bits); 166 ASSERT_EQ(outCoords.values[0], inCoords.values[0]); 167 ASSERT_EQ(outCoords.values[1], inCoords.values[1]); 168} 169 170 171// --- KeyEventTest --- 172 173class KeyEventTest : public BaseTest { 174}; 175 176TEST_F(KeyEventTest, Properties) { 177 KeyEvent event; 178 179 // Initialize and get properties. 180 const nsecs_t ARBITRARY_DOWN_TIME = 1; 181 const nsecs_t ARBITRARY_EVENT_TIME = 2; 182 event.initialize(2, AINPUT_SOURCE_GAMEPAD, AKEY_EVENT_ACTION_DOWN, 183 AKEY_EVENT_FLAG_FROM_SYSTEM, AKEYCODE_BUTTON_X, 121, 184 AMETA_ALT_ON, 1, ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME); 185 186 ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, event.getType()); 187 ASSERT_EQ(2, event.getDeviceId()); 188 ASSERT_EQ(AINPUT_SOURCE_GAMEPAD, event.getSource()); 189 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, event.getAction()); 190 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, event.getFlags()); 191 ASSERT_EQ(AKEYCODE_BUTTON_X, event.getKeyCode()); 192 ASSERT_EQ(121, event.getScanCode()); 193 ASSERT_EQ(AMETA_ALT_ON, event.getMetaState()); 194 ASSERT_EQ(1, event.getRepeatCount()); 195 ASSERT_EQ(ARBITRARY_DOWN_TIME, event.getDownTime()); 196 ASSERT_EQ(ARBITRARY_EVENT_TIME, event.getEventTime()); 197 198 // Set source. 199 event.setSource(AINPUT_SOURCE_JOYSTICK); 200 ASSERT_EQ(AINPUT_SOURCE_JOYSTICK, event.getSource()); 201} 202 203 204// --- MotionEventTest --- 205 206class MotionEventTest : public BaseTest { 207protected: 208 static const nsecs_t ARBITRARY_DOWN_TIME; 209 static const nsecs_t ARBITRARY_EVENT_TIME; 210 static const float X_OFFSET; 211 static const float Y_OFFSET; 212 213 void initializeEventWithHistory(MotionEvent* event); 214 void assertEqualsEventWithHistory(const MotionEvent* event); 215}; 216 217const nsecs_t MotionEventTest::ARBITRARY_DOWN_TIME = 1; 218const nsecs_t MotionEventTest::ARBITRARY_EVENT_TIME = 2; 219const float MotionEventTest::X_OFFSET = 1.0f; 220const float MotionEventTest::Y_OFFSET = 1.1f; 221 222void MotionEventTest::initializeEventWithHistory(MotionEvent* event) { 223 PointerProperties pointerProperties[2]; 224 pointerProperties[0].clear(); 225 pointerProperties[0].id = 1; 226 pointerProperties[0].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER; 227 pointerProperties[1].clear(); 228 pointerProperties[1].id = 2; 229 pointerProperties[1].toolType = AMOTION_EVENT_TOOL_TYPE_STYLUS; 230 231 PointerCoords pointerCoords[2]; 232 pointerCoords[0].clear(); 233 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 10); 234 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 11); 235 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 12); 236 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 13); 237 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 14); 238 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 15); 239 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 16); 240 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 17); 241 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 18); 242 pointerCoords[1].clear(); 243 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 20); 244 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 21); 245 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 22); 246 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 23); 247 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 24); 248 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 25); 249 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 26); 250 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 27); 251 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 28); 252 event->initialize(2, AINPUT_SOURCE_TOUCHSCREEN, AMOTION_EVENT_ACTION_MOVE, 253 AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED, 254 AMOTION_EVENT_EDGE_FLAG_TOP, AMETA_ALT_ON, AMOTION_EVENT_BUTTON_PRIMARY, 255 X_OFFSET, Y_OFFSET, 2.0f, 2.1f, 256 ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME, 257 2, pointerProperties, pointerCoords); 258 259 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 110); 260 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 111); 261 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 112); 262 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 113); 263 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 114); 264 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 115); 265 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 116); 266 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 117); 267 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 118); 268 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 120); 269 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 121); 270 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 122); 271 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 123); 272 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 124); 273 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 125); 274 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 126); 275 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 127); 276 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 128); 277 event->addSample(ARBITRARY_EVENT_TIME + 1, pointerCoords); 278 279 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 210); 280 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 211); 281 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 212); 282 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 213); 283 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 214); 284 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 215); 285 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 216); 286 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 217); 287 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 218); 288 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 220); 289 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 221); 290 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 222); 291 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 223); 292 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 224); 293 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 225); 294 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 226); 295 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 227); 296 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 228); 297 event->addSample(ARBITRARY_EVENT_TIME + 2, pointerCoords); 298} 299 300void MotionEventTest::assertEqualsEventWithHistory(const MotionEvent* event) { 301 // Check properties. 302 ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, event->getType()); 303 ASSERT_EQ(2, event->getDeviceId()); 304 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, event->getSource()); 305 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, event->getAction()); 306 ASSERT_EQ(AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED, event->getFlags()); 307 ASSERT_EQ(AMOTION_EVENT_EDGE_FLAG_TOP, event->getEdgeFlags()); 308 ASSERT_EQ(AMETA_ALT_ON, event->getMetaState()); 309 ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, event->getButtonState()); 310 ASSERT_EQ(X_OFFSET, event->getXOffset()); 311 ASSERT_EQ(Y_OFFSET, event->getYOffset()); 312 ASSERT_EQ(2.0f, event->getXPrecision()); 313 ASSERT_EQ(2.1f, event->getYPrecision()); 314 ASSERT_EQ(ARBITRARY_DOWN_TIME, event->getDownTime()); 315 316 ASSERT_EQ(2U, event->getPointerCount()); 317 ASSERT_EQ(1, event->getPointerId(0)); 318 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, event->getToolType(0)); 319 ASSERT_EQ(2, event->getPointerId(1)); 320 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, event->getToolType(1)); 321 322 ASSERT_EQ(2U, event->getHistorySize()); 323 324 // Check data. 325 ASSERT_EQ(ARBITRARY_EVENT_TIME, event->getHistoricalEventTime(0)); 326 ASSERT_EQ(ARBITRARY_EVENT_TIME + 1, event->getHistoricalEventTime(1)); 327 ASSERT_EQ(ARBITRARY_EVENT_TIME + 2, event->getEventTime()); 328 329 ASSERT_EQ(11, event->getHistoricalRawPointerCoords(0, 0)-> 330 getAxisValue(AMOTION_EVENT_AXIS_Y)); 331 ASSERT_EQ(21, event->getHistoricalRawPointerCoords(1, 0)-> 332 getAxisValue(AMOTION_EVENT_AXIS_Y)); 333 ASSERT_EQ(111, event->getHistoricalRawPointerCoords(0, 1)-> 334 getAxisValue(AMOTION_EVENT_AXIS_Y)); 335 ASSERT_EQ(121, event->getHistoricalRawPointerCoords(1, 1)-> 336 getAxisValue(AMOTION_EVENT_AXIS_Y)); 337 ASSERT_EQ(211, event->getRawPointerCoords(0)-> 338 getAxisValue(AMOTION_EVENT_AXIS_Y)); 339 ASSERT_EQ(221, event->getRawPointerCoords(1)-> 340 getAxisValue(AMOTION_EVENT_AXIS_Y)); 341 342 ASSERT_EQ(11, event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 0, 0)); 343 ASSERT_EQ(21, event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 1, 0)); 344 ASSERT_EQ(111, event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 0, 1)); 345 ASSERT_EQ(121, event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 1, 1)); 346 ASSERT_EQ(211, event->getRawAxisValue(AMOTION_EVENT_AXIS_Y, 0)); 347 ASSERT_EQ(221, event->getRawAxisValue(AMOTION_EVENT_AXIS_Y, 1)); 348 349 ASSERT_EQ(10, event->getHistoricalRawX(0, 0)); 350 ASSERT_EQ(20, event->getHistoricalRawX(1, 0)); 351 ASSERT_EQ(110, event->getHistoricalRawX(0, 1)); 352 ASSERT_EQ(120, event->getHistoricalRawX(1, 1)); 353 ASSERT_EQ(210, event->getRawX(0)); 354 ASSERT_EQ(220, event->getRawX(1)); 355 356 ASSERT_EQ(11, event->getHistoricalRawY(0, 0)); 357 ASSERT_EQ(21, event->getHistoricalRawY(1, 0)); 358 ASSERT_EQ(111, event->getHistoricalRawY(0, 1)); 359 ASSERT_EQ(121, event->getHistoricalRawY(1, 1)); 360 ASSERT_EQ(211, event->getRawY(0)); 361 ASSERT_EQ(221, event->getRawY(1)); 362 363 ASSERT_EQ(X_OFFSET + 10, event->getHistoricalX(0, 0)); 364 ASSERT_EQ(X_OFFSET + 20, event->getHistoricalX(1, 0)); 365 ASSERT_EQ(X_OFFSET + 110, event->getHistoricalX(0, 1)); 366 ASSERT_EQ(X_OFFSET + 120, event->getHistoricalX(1, 1)); 367 ASSERT_EQ(X_OFFSET + 210, event->getX(0)); 368 ASSERT_EQ(X_OFFSET + 220, event->getX(1)); 369 370 ASSERT_EQ(Y_OFFSET + 11, event->getHistoricalY(0, 0)); 371 ASSERT_EQ(Y_OFFSET + 21, event->getHistoricalY(1, 0)); 372 ASSERT_EQ(Y_OFFSET + 111, event->getHistoricalY(0, 1)); 373 ASSERT_EQ(Y_OFFSET + 121, event->getHistoricalY(1, 1)); 374 ASSERT_EQ(Y_OFFSET + 211, event->getY(0)); 375 ASSERT_EQ(Y_OFFSET + 221, event->getY(1)); 376 377 ASSERT_EQ(12, event->getHistoricalPressure(0, 0)); 378 ASSERT_EQ(22, event->getHistoricalPressure(1, 0)); 379 ASSERT_EQ(112, event->getHistoricalPressure(0, 1)); 380 ASSERT_EQ(122, event->getHistoricalPressure(1, 1)); 381 ASSERT_EQ(212, event->getPressure(0)); 382 ASSERT_EQ(222, event->getPressure(1)); 383 384 ASSERT_EQ(13, event->getHistoricalSize(0, 0)); 385 ASSERT_EQ(23, event->getHistoricalSize(1, 0)); 386 ASSERT_EQ(113, event->getHistoricalSize(0, 1)); 387 ASSERT_EQ(123, event->getHistoricalSize(1, 1)); 388 ASSERT_EQ(213, event->getSize(0)); 389 ASSERT_EQ(223, event->getSize(1)); 390 391 ASSERT_EQ(14, event->getHistoricalTouchMajor(0, 0)); 392 ASSERT_EQ(24, event->getHistoricalTouchMajor(1, 0)); 393 ASSERT_EQ(114, event->getHistoricalTouchMajor(0, 1)); 394 ASSERT_EQ(124, event->getHistoricalTouchMajor(1, 1)); 395 ASSERT_EQ(214, event->getTouchMajor(0)); 396 ASSERT_EQ(224, event->getTouchMajor(1)); 397 398 ASSERT_EQ(15, event->getHistoricalTouchMinor(0, 0)); 399 ASSERT_EQ(25, event->getHistoricalTouchMinor(1, 0)); 400 ASSERT_EQ(115, event->getHistoricalTouchMinor(0, 1)); 401 ASSERT_EQ(125, event->getHistoricalTouchMinor(1, 1)); 402 ASSERT_EQ(215, event->getTouchMinor(0)); 403 ASSERT_EQ(225, event->getTouchMinor(1)); 404 405 ASSERT_EQ(16, event->getHistoricalToolMajor(0, 0)); 406 ASSERT_EQ(26, event->getHistoricalToolMajor(1, 0)); 407 ASSERT_EQ(116, event->getHistoricalToolMajor(0, 1)); 408 ASSERT_EQ(126, event->getHistoricalToolMajor(1, 1)); 409 ASSERT_EQ(216, event->getToolMajor(0)); 410 ASSERT_EQ(226, event->getToolMajor(1)); 411 412 ASSERT_EQ(17, event->getHistoricalToolMinor(0, 0)); 413 ASSERT_EQ(27, event->getHistoricalToolMinor(1, 0)); 414 ASSERT_EQ(117, event->getHistoricalToolMinor(0, 1)); 415 ASSERT_EQ(127, event->getHistoricalToolMinor(1, 1)); 416 ASSERT_EQ(217, event->getToolMinor(0)); 417 ASSERT_EQ(227, event->getToolMinor(1)); 418 419 ASSERT_EQ(18, event->getHistoricalOrientation(0, 0)); 420 ASSERT_EQ(28, event->getHistoricalOrientation(1, 0)); 421 ASSERT_EQ(118, event->getHistoricalOrientation(0, 1)); 422 ASSERT_EQ(128, event->getHistoricalOrientation(1, 1)); 423 ASSERT_EQ(218, event->getOrientation(0)); 424 ASSERT_EQ(228, event->getOrientation(1)); 425} 426 427TEST_F(MotionEventTest, Properties) { 428 MotionEvent event; 429 430 // Initialize, add samples and check properties. 431 initializeEventWithHistory(&event); 432 ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&event)); 433 434 // Set source. 435 event.setSource(AINPUT_SOURCE_JOYSTICK); 436 ASSERT_EQ(AINPUT_SOURCE_JOYSTICK, event.getSource()); 437 438 // Set action. 439 event.setAction(AMOTION_EVENT_ACTION_CANCEL); 440 ASSERT_EQ(AMOTION_EVENT_ACTION_CANCEL, event.getAction()); 441 442 // Set meta state. 443 event.setMetaState(AMETA_CTRL_ON); 444 ASSERT_EQ(AMETA_CTRL_ON, event.getMetaState()); 445} 446 447TEST_F(MotionEventTest, CopyFrom_KeepHistory) { 448 MotionEvent event; 449 initializeEventWithHistory(&event); 450 451 MotionEvent copy; 452 copy.copyFrom(&event, true /*keepHistory*/); 453 454 ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&event)); 455} 456 457TEST_F(MotionEventTest, CopyFrom_DoNotKeepHistory) { 458 MotionEvent event; 459 initializeEventWithHistory(&event); 460 461 MotionEvent copy; 462 copy.copyFrom(&event, false /*keepHistory*/); 463 464 ASSERT_EQ(event.getPointerCount(), copy.getPointerCount()); 465 ASSERT_EQ(0U, copy.getHistorySize()); 466 467 ASSERT_EQ(event.getPointerId(0), copy.getPointerId(0)); 468 ASSERT_EQ(event.getPointerId(1), copy.getPointerId(1)); 469 470 ASSERT_EQ(event.getEventTime(), copy.getEventTime()); 471 472 ASSERT_EQ(event.getX(0), copy.getX(0)); 473} 474 475TEST_F(MotionEventTest, OffsetLocation) { 476 MotionEvent event; 477 initializeEventWithHistory(&event); 478 479 event.offsetLocation(5.0f, -2.0f); 480 481 ASSERT_EQ(X_OFFSET + 5.0f, event.getXOffset()); 482 ASSERT_EQ(Y_OFFSET - 2.0f, event.getYOffset()); 483} 484 485TEST_F(MotionEventTest, Scale) { 486 MotionEvent event; 487 initializeEventWithHistory(&event); 488 489 event.scale(2.0f); 490 491 ASSERT_EQ(X_OFFSET * 2, event.getXOffset()); 492 ASSERT_EQ(Y_OFFSET * 2, event.getYOffset()); 493 494 ASSERT_EQ(210 * 2, event.getRawX(0)); 495 ASSERT_EQ(211 * 2, event.getRawY(0)); 496 ASSERT_EQ((X_OFFSET + 210) * 2, event.getX(0)); 497 ASSERT_EQ((Y_OFFSET + 211) * 2, event.getY(0)); 498 ASSERT_EQ(212, event.getPressure(0)); 499 ASSERT_EQ(213, event.getSize(0)); 500 ASSERT_EQ(214 * 2, event.getTouchMajor(0)); 501 ASSERT_EQ(215 * 2, event.getTouchMinor(0)); 502 ASSERT_EQ(216 * 2, event.getToolMajor(0)); 503 ASSERT_EQ(217 * 2, event.getToolMinor(0)); 504 ASSERT_EQ(218, event.getOrientation(0)); 505} 506 507TEST_F(MotionEventTest, Parcel) { 508 Parcel parcel; 509 510 MotionEvent inEvent; 511 initializeEventWithHistory(&inEvent); 512 MotionEvent outEvent; 513 514 // Round trip. 515 inEvent.writeToParcel(&parcel); 516 parcel.setDataPosition(0); 517 outEvent.readFromParcel(&parcel); 518 519 ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&outEvent)); 520} 521 522TEST_F(MotionEventTest, Transform) { 523 // Generate some points on a circle. 524 // Each point 'i' is a point on a circle of radius ROTATION centered at (3,2) at an angle 525 // of ARC * i degrees clockwise relative to the Y axis. 526 // The geometrical representation is irrelevant to the test, it's just easy to generate 527 // and check rotation. We set the orientation to the same angle. 528 // Coordinate system: down is increasing Y, right is increasing X. 529 const float PI_180 = float(M_PI / 180); 530 const float RADIUS = 10; 531 const float ARC = 36; 532 const float ROTATION = ARC * 2; 533 534 const size_t pointerCount = 11; 535 PointerProperties pointerProperties[pointerCount]; 536 PointerCoords pointerCoords[pointerCount]; 537 for (size_t i = 0; i < pointerCount; i++) { 538 float angle = float(i * ARC * PI_180); 539 pointerProperties[i].clear(); 540 pointerProperties[i].id = i; 541 pointerCoords[i].clear(); 542 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, sinf(angle) * RADIUS + 3); 543 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, -cosf(angle) * RADIUS + 2); 544 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, angle); 545 } 546 MotionEvent event; 547 event.initialize(0, 0, AMOTION_EVENT_ACTION_MOVE, 0, 0, 0, 0, 548 0, 0, 0, 0, 0, 0, pointerCount, pointerProperties, pointerCoords); 549 float originalRawX = 0 + 3; 550 float originalRawY = -RADIUS + 2; 551 552 // Check original raw X and Y assumption. 553 ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001); 554 ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001); 555 556 // Now translate the motion event so the circle's origin is at (0,0). 557 event.offsetLocation(-3, -2); 558 559 // Offsetting the location should preserve the raw X and Y of the first point. 560 ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001); 561 ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001); 562 563 // Apply a rotation about the origin by ROTATION degrees clockwise. 564 SkMatrix matrix; 565 matrix.setRotate(ROTATION); 566 event.transform(&matrix); 567 568 // Check the points. 569 for (size_t i = 0; i < pointerCount; i++) { 570 float angle = float((i * ARC + ROTATION) * PI_180); 571 ASSERT_NEAR(sinf(angle) * RADIUS, event.getX(i), 0.001); 572 ASSERT_NEAR(-cosf(angle) * RADIUS, event.getY(i), 0.001); 573 ASSERT_NEAR(tanf(angle), tanf(event.getOrientation(i)), 0.1); 574 } 575 576 // Applying the transformation should preserve the raw X and Y of the first point. 577 ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001); 578 ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001); 579} 580 581} // namespace android 582