1 /*
2 * Copyright (C) 2017 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 #define LOG_TAG "VelocityTracker_test"
18
19 #include <array>
20 #include <chrono>
21 #include <math.h>
22
23 #include <android-base/stringprintf.h>
24 #include <gtest/gtest.h>
25 #include <input/VelocityTracker.h>
26
27 using namespace std::chrono_literals;
28 using android::base::StringPrintf;
29
30 namespace android {
31
32 constexpr int32_t DISPLAY_ID = ADISPLAY_ID_DEFAULT; // default display id
33
34 constexpr int32_t DEFAULT_POINTER_ID = 0; // pointer ID used for manually defined tests
35
36 // velocity must be in the range (1-tol)*EV <= velocity <= (1+tol)*EV
37 // here EV = expected value, tol = VELOCITY_TOLERANCE
38 constexpr float VELOCITY_TOLERANCE = 0.2;
39
40 // estimate coefficients must be within 0.001% of the target value
41 constexpr float COEFFICIENT_TOLERANCE = 0.00001;
42
43 // --- VelocityTrackerTest ---
44 class VelocityTrackerTest : public testing::Test { };
45
46 /*
47 * Similar to EXPECT_NEAR, but ensures that the difference between the two float values
48 * is at most a certain fraction of the target value.
49 * If fraction is zero, require exact match.
50 */
EXPECT_NEAR_BY_FRACTION(float actual,float target,float fraction)51 static void EXPECT_NEAR_BY_FRACTION(float actual, float target, float fraction) {
52 float tolerance = fabsf(target * fraction);
53
54 if (target == 0 && fraction != 0) {
55 // If target is zero, this would force actual == target, which is too harsh.
56 // Relax this requirement a little. The value is determined empirically from the
57 // coefficients computed by the quadratic least squares algorithms.
58 tolerance = 1E-6;
59 }
60 EXPECT_NEAR(actual, target, tolerance);
61 }
62
checkVelocity(float Vactual,float Vtarget)63 static void checkVelocity(float Vactual, float Vtarget) {
64 EXPECT_NEAR_BY_FRACTION(Vactual, Vtarget, VELOCITY_TOLERANCE);
65 }
66
checkCoefficient(float actual,float target)67 static void checkCoefficient(float actual, float target) {
68 EXPECT_NEAR_BY_FRACTION(actual, target, COEFFICIENT_TOLERANCE);
69 }
70
71 struct Position {
72 float x;
73 float y;
74
75 /**
76 * If both values are NAN, then this is considered to be an empty entry (no pointer data).
77 * If only one of the values is NAN, this is still a valid entry,
78 * because we may only care about a single axis.
79 */
isValidandroid::Position80 bool isValid() const {
81 return !(isnan(x) && isnan(y));
82 }
83 };
84
85 struct MotionEventEntry {
86 std::chrono::nanoseconds eventTime;
87 std::vector<Position> positions;
88 };
89
getValidPointers(const std::vector<Position> & positions)90 static BitSet32 getValidPointers(const std::vector<Position>& positions) {
91 BitSet32 pointers;
92 for (size_t i = 0; i < positions.size(); i++) {
93 if (positions[i].isValid()) {
94 pointers.markBit(i);
95 }
96 }
97 return pointers;
98 }
99
getChangingPointerId(BitSet32 pointers,BitSet32 otherPointers)100 static uint32_t getChangingPointerId(BitSet32 pointers, BitSet32 otherPointers) {
101 BitSet32 difference(pointers.value ^ otherPointers.value);
102 uint32_t pointerId = difference.clearFirstMarkedBit();
103 EXPECT_EQ(0U, difference.value) << "Only 1 pointer can enter or leave at a time";
104 return pointerId;
105 }
106
resolveAction(const std::vector<Position> & lastPositions,const std::vector<Position> & currentPositions,const std::vector<Position> & nextPositions)107 static int32_t resolveAction(const std::vector<Position>& lastPositions,
108 const std::vector<Position>& currentPositions,
109 const std::vector<Position>& nextPositions) {
110 BitSet32 pointers = getValidPointers(currentPositions);
111 const uint32_t pointerCount = pointers.count();
112
113 BitSet32 lastPointers = getValidPointers(lastPositions);
114 const uint32_t lastPointerCount = lastPointers.count();
115 if (lastPointerCount < pointerCount) {
116 // A new pointer is down
117 uint32_t pointerId = getChangingPointerId(pointers, lastPointers);
118 return AMOTION_EVENT_ACTION_POINTER_DOWN |
119 (pointerId << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
120 }
121
122 BitSet32 nextPointers = getValidPointers(nextPositions);
123 const uint32_t nextPointerCount = nextPointers.count();
124 if (pointerCount > nextPointerCount) {
125 // An existing pointer is leaving
126 uint32_t pointerId = getChangingPointerId(pointers, nextPointers);
127 return AMOTION_EVENT_ACTION_POINTER_UP |
128 (pointerId << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
129 }
130
131 return AMOTION_EVENT_ACTION_MOVE;
132 }
133
createMotionEventStream(const std::vector<MotionEventEntry> & motions)134 static std::vector<MotionEvent> createMotionEventStream(
135 const std::vector<MotionEventEntry>& motions) {
136 if (motions.empty()) {
137 ADD_FAILURE() << "Need at least 1 sample to create a MotionEvent. Received empty vector.";
138 }
139
140 std::vector<MotionEvent> events;
141 for (size_t i = 0; i < motions.size(); i++) {
142 const MotionEventEntry& entry = motions[i];
143 BitSet32 pointers = getValidPointers(entry.positions);
144 const uint32_t pointerCount = pointers.count();
145
146 int32_t action;
147 if (i == 0) {
148 action = AMOTION_EVENT_ACTION_DOWN;
149 EXPECT_EQ(1U, pointerCount) << "First event should only have 1 pointer";
150 } else if (i == motions.size() - 1) {
151 EXPECT_EQ(1U, pointerCount) << "Last event should only have 1 pointer";
152 action = AMOTION_EVENT_ACTION_UP;
153 } else {
154 const MotionEventEntry& previousEntry = motions[i-1];
155 const MotionEventEntry& nextEntry = motions[i+1];
156 action = resolveAction(previousEntry.positions, entry.positions, nextEntry.positions);
157 }
158
159 PointerCoords coords[pointerCount];
160 PointerProperties properties[pointerCount];
161 uint32_t pointerIndex = 0;
162 while(!pointers.isEmpty()) {
163 uint32_t pointerId = pointers.clearFirstMarkedBit();
164
165 coords[pointerIndex].clear();
166 // We are treating column positions as pointerId
167 EXPECT_TRUE(entry.positions[pointerId].isValid()) <<
168 "The entry at pointerId must be valid";
169 coords[pointerIndex].setAxisValue(AMOTION_EVENT_AXIS_X, entry.positions[pointerId].x);
170 coords[pointerIndex].setAxisValue(AMOTION_EVENT_AXIS_Y, entry.positions[pointerId].y);
171
172 properties[pointerIndex].id = pointerId;
173 properties[pointerIndex].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
174 pointerIndex++;
175 }
176 EXPECT_EQ(pointerIndex, pointerCount);
177
178 MotionEvent event;
179 event.initialize(InputEvent::nextId(), 0 /*deviceId*/, AINPUT_SOURCE_TOUCHSCREEN,
180 DISPLAY_ID, INVALID_HMAC, action, 0 /*actionButton*/, 0 /*flags*/,
181 AMOTION_EVENT_EDGE_FLAG_NONE, AMETA_NONE, 0 /*buttonState*/,
182 MotionClassification::NONE, 1 /*xScale*/, 1 /*yScale*/, 0 /*xOffset*/,
183 0 /*yOffset*/, 0 /*xPrecision*/, 0 /*yPrecision*/,
184 AMOTION_EVENT_INVALID_CURSOR_POSITION,
185 AMOTION_EVENT_INVALID_CURSOR_POSITION, 0 /*downTime*/,
186 entry.eventTime.count(), pointerCount, properties, coords);
187
188 events.emplace_back(event);
189 }
190
191 return events;
192 }
193
computeAndCheckVelocity(const char * strategy,const std::vector<MotionEventEntry> & motions,int32_t axis,float targetVelocity)194 static void computeAndCheckVelocity(const char* strategy,
195 const std::vector<MotionEventEntry>& motions, int32_t axis, float targetVelocity) {
196 VelocityTracker vt(strategy);
197 float Vx, Vy;
198
199 std::vector<MotionEvent> events = createMotionEventStream(motions);
200 for (MotionEvent event : events) {
201 vt.addMovement(&event);
202 }
203
204 vt.getVelocity(DEFAULT_POINTER_ID, &Vx, &Vy);
205
206 switch (axis) {
207 case AMOTION_EVENT_AXIS_X:
208 checkVelocity(Vx, targetVelocity);
209 break;
210 case AMOTION_EVENT_AXIS_Y:
211 checkVelocity(Vy, targetVelocity);
212 break;
213 default:
214 FAIL() << "Axis must be either AMOTION_EVENT_AXIS_X or AMOTION_EVENT_AXIS_Y";
215 }
216 }
217
computeAndCheckQuadraticEstimate(const std::vector<MotionEventEntry> & motions,const std::array<float,3> & coefficients)218 static void computeAndCheckQuadraticEstimate(const std::vector<MotionEventEntry>& motions,
219 const std::array<float, 3>& coefficients) {
220 VelocityTracker vt("lsq2");
221 std::vector<MotionEvent> events = createMotionEventStream(motions);
222 for (MotionEvent event : events) {
223 vt.addMovement(&event);
224 }
225 VelocityTracker::Estimator estimator;
226 EXPECT_TRUE(vt.getEstimator(0, &estimator));
227 for (size_t i = 0; i< coefficients.size(); i++) {
228 checkCoefficient(estimator.xCoeff[i], coefficients[i]);
229 checkCoefficient(estimator.yCoeff[i], coefficients[i]);
230 }
231 }
232
233 /*
234 * ================== VelocityTracker tests generated manually =====================================
235 */
TEST_F(VelocityTrackerTest,ThreePointsPositiveVelocityTest)236 TEST_F(VelocityTrackerTest, ThreePointsPositiveVelocityTest) {
237 // Same coordinate is reported 2 times in a row
238 // It is difficult to determine the correct answer here, but at least the direction
239 // of the reported velocity should be positive.
240 std::vector<MotionEventEntry> motions = {
241 {0ms, {{ 273, NAN}}},
242 {12585us, {{293, NAN}}},
243 {14730us, {{293, NAN}}},
244 {14730us, {{293, NAN}}}, // ACTION_UP
245 };
246 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 1600);
247 }
248
TEST_F(VelocityTrackerTest,ThreePointsZeroVelocityTest)249 TEST_F(VelocityTrackerTest, ThreePointsZeroVelocityTest) {
250 // Same coordinate is reported 3 times in a row
251 std::vector<MotionEventEntry> motions = {
252 { 0ms, {{293, NAN}} },
253 { 6132us, {{293, NAN}} },
254 { 11283us, {{293, NAN}} },
255 { 11283us, {{293, NAN}} }, // ACTION_UP
256 };
257 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 0);
258 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, 0);
259 }
260
TEST_F(VelocityTrackerTest,ThreePointsLinearVelocityTest)261 TEST_F(VelocityTrackerTest, ThreePointsLinearVelocityTest) {
262 // Fixed velocity at 5 points per 10 milliseconds
263 std::vector<MotionEventEntry> motions = {
264 { 0ms, {{0, NAN}} },
265 { 10ms, {{5, NAN}} },
266 { 20ms, {{10, NAN}} },
267 { 20ms, {{10, NAN}} }, // ACTION_UP
268 };
269 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 500);
270 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, 500);
271 }
272
273
274 /**
275 * ================== VelocityTracker tests generated by recording real events =====================
276 *
277 * To add a test, record the input coordinates and event times to all calls
278 * to void VelocityTracker::addMovement(const MotionEvent* event).
279 * Also record all calls to VelocityTracker::clear().
280 * Finally, record the output of VelocityTracker::getVelocity(...)
281 * This will give you the necessary data to create a new test.
282 *
283 * Another good way to generate this data is to use 'dumpsys input' just after the event has
284 * occurred.
285 */
286
287 // --------------- Recorded by hand on swordfish ---------------------------------------------------
TEST_F(VelocityTrackerTest,SwordfishFlingDown)288 TEST_F(VelocityTrackerTest, SwordfishFlingDown) {
289 // Recording of a fling on Swordfish that could cause a fling in the wrong direction
290 std::vector<MotionEventEntry> motions = {
291 { 0ms, {{271, 96}} },
292 { 16071042ns, {{269.786346, 106.922775}} },
293 { 35648403ns, {{267.983063, 156.660034}} },
294 { 52313925ns, {{262.638397, 220.339081}} },
295 { 68976522ns, {{266.138824, 331.581116}} },
296 { 85639375ns, {{274.79245, 428.113159}} },
297 { 96948871ns, {{274.79245, 428.113159}} },
298 { 96948871ns, {{274.79245, 428.113159}} }, // ACTION_UP
299 };
300 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 623.577637);
301 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 5970.7309);
302 }
303
304 // --------------- Recorded by hand on sailfish, generated by a script -----------------------------
305 // For some of these tests, the X-direction velocity checking has been removed, because the lsq2
306 // and the impulse VelocityTrackerStrategies did not agree within 20%.
307 // Since the flings were recorded in the Y-direction, the intentional user action should only
308 // be relevant for the Y axis.
309 // There have been also cases where lsq2 and impulse disagreed more than 20% in the Y-direction.
310 // Those recordings have been discarded because we didn't feel one strategy's interpretation was
311 // more correct than another's but didn't want to increase the tolerance for the entire test suite.
312 //
313 // There are 18 tests total below: 9 in the positive Y direction and 9 in the opposite.
314 // The recordings were loosely binned into 3 categories - slow, faster, and fast, which roughly
315 // characterizes the velocity of the finger motion.
316 // These can be treated approximately as:
317 // slow - less than 1 page gets scrolled
318 // faster - more than 1 page gets scrolled, but less than 3
319 // fast - entire list is scrolled (fling is done as hard as possible)
320
TEST_F(VelocityTrackerTest,SailfishFlingUpSlow1)321 TEST_F(VelocityTrackerTest, SailfishFlingUpSlow1) {
322 // Sailfish - fling up - slow - 1
323 std::vector<MotionEventEntry> motions = {
324 { 235089067457000ns, {{528.00, 983.00}} },
325 { 235089084684000ns, {{527.00, 981.00}} },
326 { 235089093349000ns, {{527.00, 977.00}} },
327 { 235089095677625ns, {{527.00, 975.93}} },
328 { 235089101859000ns, {{527.00, 970.00}} },
329 { 235089110378000ns, {{528.00, 960.00}} },
330 { 235089112497111ns, {{528.25, 957.51}} },
331 { 235089118760000ns, {{531.00, 946.00}} },
332 { 235089126686000ns, {{535.00, 931.00}} },
333 { 235089129316820ns, {{536.33, 926.02}} },
334 { 235089135199000ns, {{540.00, 914.00}} },
335 { 235089144297000ns, {{546.00, 896.00}} },
336 { 235089146136443ns, {{547.21, 892.36}} },
337 { 235089152923000ns, {{553.00, 877.00}} },
338 { 235089160784000ns, {{559.00, 851.00}} },
339 { 235089162955851ns, {{560.66, 843.82}} },
340 { 235089162955851ns, {{560.66, 843.82}} }, // ACTION_UP
341 };
342 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 872.794617);
343 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, 951.698181);
344 computeAndCheckVelocity("impulse",motions, AMOTION_EVENT_AXIS_Y, -3604.819336);
345 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -3044.966064);
346 }
347
348
TEST_F(VelocityTrackerTest,SailfishFlingUpSlow2)349 TEST_F(VelocityTrackerTest, SailfishFlingUpSlow2) {
350 // Sailfish - fling up - slow - 2
351 std::vector<MotionEventEntry> motions = {
352 { 235110560704000ns, {{522.00, 1107.00}} },
353 { 235110575764000ns, {{522.00, 1107.00}} },
354 { 235110584385000ns, {{522.00, 1107.00}} },
355 { 235110588421179ns, {{521.52, 1106.52}} },
356 { 235110592830000ns, {{521.00, 1106.00}} },
357 { 235110601385000ns, {{520.00, 1104.00}} },
358 { 235110605088160ns, {{519.14, 1102.27}} },
359 { 235110609952000ns, {{518.00, 1100.00}} },
360 { 235110618353000ns, {{517.00, 1093.00}} },
361 { 235110621755146ns, {{516.60, 1090.17}} },
362 { 235110627010000ns, {{517.00, 1081.00}} },
363 { 235110634785000ns, {{518.00, 1063.00}} },
364 { 235110638422450ns, {{518.87, 1052.58}} },
365 { 235110643161000ns, {{520.00, 1039.00}} },
366 { 235110651767000ns, {{524.00, 1011.00}} },
367 { 235110655089581ns, {{525.54, 1000.19}} },
368 { 235110660368000ns, {{530.00, 980.00}} },
369 { 235110660368000ns, {{530.00, 980.00}} }, // ACTION_UP
370 };
371 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -4096.583008);
372 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -3455.094238);
373 }
374
375
TEST_F(VelocityTrackerTest,SailfishFlingUpSlow3)376 TEST_F(VelocityTrackerTest, SailfishFlingUpSlow3) {
377 // Sailfish - fling up - slow - 3
378 std::vector<MotionEventEntry> motions = {
379 { 792536237000ns, {{580.00, 1317.00}} },
380 { 792541538987ns, {{580.63, 1311.94}} },
381 { 792544613000ns, {{581.00, 1309.00}} },
382 { 792552301000ns, {{583.00, 1295.00}} },
383 { 792558362309ns, {{585.13, 1282.92}} },
384 { 792560828000ns, {{586.00, 1278.00}} },
385 { 792569446000ns, {{589.00, 1256.00}} },
386 { 792575185095ns, {{591.54, 1241.41}} },
387 { 792578491000ns, {{593.00, 1233.00}} },
388 { 792587044000ns, {{597.00, 1211.00}} },
389 { 792592008172ns, {{600.28, 1195.92}} },
390 { 792594616000ns, {{602.00, 1188.00}} },
391 { 792603129000ns, {{607.00, 1167.00}} },
392 { 792608831290ns, {{609.48, 1155.83}} },
393 { 792612321000ns, {{611.00, 1149.00}} },
394 { 792620768000ns, {{615.00, 1131.00}} },
395 { 792625653873ns, {{617.32, 1121.73}} },
396 { 792629200000ns, {{619.00, 1115.00}} },
397 { 792629200000ns, {{619.00, 1115.00}} }, // ACTION_UP
398 };
399 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 574.33429);
400 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, 617.40564);
401 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -2361.982666);
402 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -2500.055664);
403 }
404
405
TEST_F(VelocityTrackerTest,SailfishFlingUpFaster1)406 TEST_F(VelocityTrackerTest, SailfishFlingUpFaster1) {
407 // Sailfish - fling up - faster - 1
408 std::vector<MotionEventEntry> motions = {
409 { 235160420675000ns, {{610.00, 1042.00}} },
410 { 235160428220000ns, {{609.00, 1026.00}} },
411 { 235160436544000ns, {{609.00, 1024.00}} },
412 { 235160441852394ns, {{609.64, 1020.82}} },
413 { 235160444878000ns, {{610.00, 1019.00}} },
414 { 235160452673000ns, {{613.00, 1006.00}} },
415 { 235160458519743ns, {{617.18, 992.06}} },
416 { 235160461061000ns, {{619.00, 986.00}} },
417 { 235160469798000ns, {{627.00, 960.00}} },
418 { 235160475186713ns, {{632.22, 943.02}} },
419 { 235160478051000ns, {{635.00, 934.00}} },
420 { 235160486489000ns, {{644.00, 906.00}} },
421 { 235160491853697ns, {{649.56, 890.56}} },
422 { 235160495177000ns, {{653.00, 881.00}} },
423 { 235160504148000ns, {{662.00, 858.00}} },
424 { 235160509231495ns, {{666.81, 845.37}} },
425 { 235160512603000ns, {{670.00, 837.00}} },
426 { 235160520366000ns, {{679.00, 814.00}} },
427 { 235160520366000ns, {{679.00, 814.00}} }, // ACTION_UP
428 };
429 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 1274.141724);
430 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, 1438.53186);
431 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -3001.4348);
432 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -3695.859619);
433 }
434
435
TEST_F(VelocityTrackerTest,SailfishFlingUpFaster2)436 TEST_F(VelocityTrackerTest, SailfishFlingUpFaster2) {
437 // Sailfish - fling up - faster - 2
438 std::vector<MotionEventEntry> motions = {
439 { 847153808000ns, {{576.00, 1264.00}} },
440 { 847171174000ns, {{576.00, 1262.00}} },
441 { 847179640000ns, {{576.00, 1257.00}} },
442 { 847185187540ns, {{577.41, 1249.22}} },
443 { 847187487000ns, {{578.00, 1246.00}} },
444 { 847195710000ns, {{581.00, 1227.00}} },
445 { 847202027059ns, {{583.93, 1209.40}} },
446 { 847204324000ns, {{585.00, 1203.00}} },
447 { 847212672000ns, {{590.00, 1176.00}} },
448 { 847218861395ns, {{594.36, 1157.11}} },
449 { 847221190000ns, {{596.00, 1150.00}} },
450 { 847230484000ns, {{602.00, 1124.00}} },
451 { 847235701400ns, {{607.56, 1103.83}} },
452 { 847237986000ns, {{610.00, 1095.00}} },
453 { 847237986000ns, {{610.00, 1095.00}} }, // ACTION_UP
454 };
455 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -4280.07959);
456 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -4241.004395);
457 }
458
459
TEST_F(VelocityTrackerTest,SailfishFlingUpFaster3)460 TEST_F(VelocityTrackerTest, SailfishFlingUpFaster3) {
461 // Sailfish - fling up - faster - 3
462 std::vector<MotionEventEntry> motions = {
463 { 235200532789000ns, {{507.00, 1084.00}} },
464 { 235200549221000ns, {{507.00, 1083.00}} },
465 { 235200557841000ns, {{507.00, 1081.00}} },
466 { 235200558051189ns, {{507.00, 1080.95}} },
467 { 235200566314000ns, {{507.00, 1078.00}} },
468 { 235200574876586ns, {{508.97, 1070.12}} },
469 { 235200575006000ns, {{509.00, 1070.00}} },
470 { 235200582900000ns, {{514.00, 1054.00}} },
471 { 235200591276000ns, {{525.00, 1023.00}} },
472 { 235200591701829ns, {{525.56, 1021.42}} },
473 { 235200600064000ns, {{542.00, 976.00}} },
474 { 235200608519000ns, {{563.00, 911.00}} },
475 { 235200608527086ns, {{563.02, 910.94}} },
476 { 235200616933000ns, {{590.00, 844.00}} },
477 { 235200616933000ns, {{590.00, 844.00}} }, // ACTION_UP
478 };
479 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -8715.686523);
480 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -7639.026367);
481 }
482
483
TEST_F(VelocityTrackerTest,SailfishFlingUpFast1)484 TEST_F(VelocityTrackerTest, SailfishFlingUpFast1) {
485 // Sailfish - fling up - fast - 1
486 std::vector<MotionEventEntry> motions = {
487 { 920922149000ns, {{561.00, 1412.00}} },
488 { 920930185000ns, {{559.00, 1377.00}} },
489 { 920930262463ns, {{558.98, 1376.66}} },
490 { 920938547000ns, {{559.00, 1371.00}} },
491 { 920947096857ns, {{562.91, 1342.68}} },
492 { 920947302000ns, {{563.00, 1342.00}} },
493 { 920955502000ns, {{577.00, 1272.00}} },
494 { 920963931021ns, {{596.87, 1190.54}} },
495 { 920963987000ns, {{597.00, 1190.00}} },
496 { 920972530000ns, {{631.00, 1093.00}} },
497 { 920980765511ns, {{671.31, 994.68}} },
498 { 920980906000ns, {{672.00, 993.00}} },
499 { 920989261000ns, {{715.00, 903.00}} },
500 { 920989261000ns, {{715.00, 903.00}} }, // ACTION_UP
501 };
502 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 5670.329102);
503 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, 5991.866699);
504 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -13021.101562);
505 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -15093.995117);
506 }
507
508
TEST_F(VelocityTrackerTest,SailfishFlingUpFast2)509 TEST_F(VelocityTrackerTest, SailfishFlingUpFast2) {
510 // Sailfish - fling up - fast - 2
511 std::vector<MotionEventEntry> motions = {
512 { 235247153233000ns, {{518.00, 1168.00}} },
513 { 235247170452000ns, {{517.00, 1167.00}} },
514 { 235247178908000ns, {{515.00, 1159.00}} },
515 { 235247179556213ns, {{514.85, 1158.39}} },
516 { 235247186821000ns, {{515.00, 1125.00}} },
517 { 235247195265000ns, {{521.00, 1051.00}} },
518 { 235247196389476ns, {{521.80, 1041.15}} },
519 { 235247203649000ns, {{538.00, 932.00}} },
520 { 235247212253000ns, {{571.00, 794.00}} },
521 { 235247213222491ns, {{574.72, 778.45}} },
522 { 235247220736000ns, {{620.00, 641.00}} },
523 { 235247220736000ns, {{620.00, 641.00}} }, // ACTION_UP
524 };
525 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -20286.958984);
526 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -20494.587891);
527 }
528
529
TEST_F(VelocityTrackerTest,SailfishFlingUpFast3)530 TEST_F(VelocityTrackerTest, SailfishFlingUpFast3) {
531 // Sailfish - fling up - fast - 3
532 std::vector<MotionEventEntry> motions = {
533 { 235302568736000ns, {{529.00, 1167.00}} },
534 { 235302576644000ns, {{523.00, 1140.00}} },
535 { 235302579395063ns, {{520.91, 1130.61}} },
536 { 235302585140000ns, {{522.00, 1130.00}} },
537 { 235302593615000ns, {{527.00, 1065.00}} },
538 { 235302596207444ns, {{528.53, 1045.12}} },
539 { 235302602102000ns, {{559.00, 872.00}} },
540 { 235302610545000ns, {{652.00, 605.00}} },
541 { 235302613019881ns, {{679.26, 526.73}} },
542 { 235302613019881ns, {{679.26, 526.73}} }, // ACTION_UP
543 };
544 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -39295.941406);
545 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -36461.421875);
546 }
547
548
TEST_F(VelocityTrackerTest,SailfishFlingDownSlow1)549 TEST_F(VelocityTrackerTest, SailfishFlingDownSlow1) {
550 // Sailfish - fling down - slow - 1
551 std::vector<MotionEventEntry> motions = {
552 { 235655749552755ns, {{582.00, 432.49}} },
553 { 235655750638000ns, {{582.00, 433.00}} },
554 { 235655758865000ns, {{582.00, 440.00}} },
555 { 235655766221523ns, {{581.16, 448.43}} },
556 { 235655767594000ns, {{581.00, 450.00}} },
557 { 235655776044000ns, {{580.00, 462.00}} },
558 { 235655782890696ns, {{579.18, 474.35}} },
559 { 235655784360000ns, {{579.00, 477.00}} },
560 { 235655792795000ns, {{578.00, 496.00}} },
561 { 235655799559531ns, {{576.27, 515.04}} },
562 { 235655800612000ns, {{576.00, 518.00}} },
563 { 235655809535000ns, {{574.00, 542.00}} },
564 { 235655816988015ns, {{572.17, 564.86}} },
565 { 235655817685000ns, {{572.00, 567.00}} },
566 { 235655825981000ns, {{569.00, 595.00}} },
567 { 235655833808653ns, {{566.26, 620.60}} },
568 { 235655834541000ns, {{566.00, 623.00}} },
569 { 235655842893000ns, {{563.00, 649.00}} },
570 { 235655842893000ns, {{563.00, 649.00}} }, // ACTION_UP
571 };
572 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, -419.749695);
573 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, -398.303894);
574 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 3309.016357);
575 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 3969.099854);
576 }
577
578
TEST_F(VelocityTrackerTest,SailfishFlingDownSlow2)579 TEST_F(VelocityTrackerTest, SailfishFlingDownSlow2) {
580 // Sailfish - fling down - slow - 2
581 std::vector<MotionEventEntry> motions = {
582 { 235671152083370ns, {{485.24, 558.28}} },
583 { 235671154126000ns, {{485.00, 559.00}} },
584 { 235671162497000ns, {{484.00, 566.00}} },
585 { 235671168750511ns, {{483.27, 573.29}} },
586 { 235671171071000ns, {{483.00, 576.00}} },
587 { 235671179390000ns, {{482.00, 588.00}} },
588 { 235671185417210ns, {{481.31, 598.98}} },
589 { 235671188173000ns, {{481.00, 604.00}} },
590 { 235671196371000ns, {{480.00, 624.00}} },
591 { 235671202084196ns, {{479.27, 639.98}} },
592 { 235671204235000ns, {{479.00, 646.00}} },
593 { 235671212554000ns, {{478.00, 673.00}} },
594 { 235671219471011ns, {{476.39, 697.12}} },
595 { 235671221159000ns, {{476.00, 703.00}} },
596 { 235671229592000ns, {{474.00, 734.00}} },
597 { 235671236281462ns, {{472.43, 758.38}} },
598 { 235671238098000ns, {{472.00, 765.00}} },
599 { 235671246532000ns, {{470.00, 799.00}} },
600 { 235671246532000ns, {{470.00, 799.00}} }, // ACTION_UP
601 };
602 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, -262.80426);
603 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, -243.665344);
604 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 4215.682129);
605 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 4587.986816);
606 }
607
608
TEST_F(VelocityTrackerTest,SailfishFlingDownSlow3)609 TEST_F(VelocityTrackerTest, SailfishFlingDownSlow3) {
610 // Sailfish - fling down - slow - 3
611 std::vector<MotionEventEntry> motions = {
612 { 170983201000ns, {{557.00, 533.00}} },
613 { 171000668000ns, {{556.00, 534.00}} },
614 { 171007359750ns, {{554.73, 535.27}} },
615 { 171011197000ns, {{554.00, 536.00}} },
616 { 171017660000ns, {{552.00, 540.00}} },
617 { 171024201831ns, {{549.97, 544.73}} },
618 { 171027333000ns, {{549.00, 547.00}} },
619 { 171034603000ns, {{545.00, 557.00}} },
620 { 171041043371ns, {{541.98, 567.55}} },
621 { 171043147000ns, {{541.00, 571.00}} },
622 { 171051052000ns, {{536.00, 586.00}} },
623 { 171051052000ns, {{536.00, 586.00}} }, // ACTION_UP
624 };
625 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, -723.413513);
626 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, -651.038452);
627 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 2091.502441);
628 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 1934.517456);
629 }
630
631
TEST_F(VelocityTrackerTest,SailfishFlingDownFaster1)632 TEST_F(VelocityTrackerTest, SailfishFlingDownFaster1) {
633 // Sailfish - fling down - faster - 1
634 std::vector<MotionEventEntry> motions = {
635 { 235695280333000ns, {{558.00, 451.00}} },
636 { 235695283971237ns, {{558.43, 454.45}} },
637 { 235695289038000ns, {{559.00, 462.00}} },
638 { 235695297388000ns, {{561.00, 478.00}} },
639 { 235695300638465ns, {{561.83, 486.25}} },
640 { 235695305265000ns, {{563.00, 498.00}} },
641 { 235695313591000ns, {{564.00, 521.00}} },
642 { 235695317305492ns, {{564.43, 532.68}} },
643 { 235695322181000ns, {{565.00, 548.00}} },
644 { 235695330709000ns, {{565.00, 577.00}} },
645 { 235695333972227ns, {{565.00, 588.10}} },
646 { 235695339250000ns, {{565.00, 609.00}} },
647 { 235695347839000ns, {{565.00, 642.00}} },
648 { 235695351313257ns, {{565.00, 656.18}} },
649 { 235695356412000ns, {{565.00, 677.00}} },
650 { 235695364899000ns, {{563.00, 710.00}} },
651 { 235695368118682ns, {{562.24, 722.52}} },
652 { 235695373403000ns, {{564.00, 744.00}} },
653 { 235695373403000ns, {{564.00, 744.00}} }, // ACTION_UP
654 };
655 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 4254.639648);
656 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 4698.415039);
657 }
658
659
TEST_F(VelocityTrackerTest,SailfishFlingDownFaster2)660 TEST_F(VelocityTrackerTest, SailfishFlingDownFaster2) {
661 // Sailfish - fling down - faster - 2
662 std::vector<MotionEventEntry> motions = {
663 { 235709624766000ns, {{535.00, 579.00}} },
664 { 235709642256000ns, {{534.00, 580.00}} },
665 { 235709643350278ns, {{533.94, 580.06}} },
666 { 235709650760000ns, {{532.00, 584.00}} },
667 { 235709658615000ns, {{530.00, 593.00}} },
668 { 235709660170495ns, {{529.60, 594.78}} },
669 { 235709667095000ns, {{527.00, 606.00}} },
670 { 235709675616000ns, {{524.00, 628.00}} },
671 { 235709676983261ns, {{523.52, 631.53}} },
672 { 235709684289000ns, {{521.00, 652.00}} },
673 { 235709692763000ns, {{518.00, 682.00}} },
674 { 235709693804993ns, {{517.63, 685.69}} },
675 { 235709701438000ns, {{515.00, 709.00}} },
676 { 235709709830000ns, {{512.00, 739.00}} },
677 { 235709710626776ns, {{511.72, 741.85}} },
678 { 235709710626776ns, {{511.72, 741.85}} }, // ACTION_UP
679 };
680 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, -430.440247);
681 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, -447.600311);
682 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 3953.859375);
683 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 4316.155273);
684 }
685
686
TEST_F(VelocityTrackerTest,SailfishFlingDownFaster3)687 TEST_F(VelocityTrackerTest, SailfishFlingDownFaster3) {
688 // Sailfish - fling down - faster - 3
689 std::vector<MotionEventEntry> motions = {
690 { 235727628927000ns, {{540.00, 440.00}} },
691 { 235727636810000ns, {{537.00, 454.00}} },
692 { 235727646176000ns, {{536.00, 454.00}} },
693 { 235727653586628ns, {{535.12, 456.65}} },
694 { 235727654557000ns, {{535.00, 457.00}} },
695 { 235727663024000ns, {{534.00, 465.00}} },
696 { 235727670410103ns, {{533.04, 479.45}} },
697 { 235727670691000ns, {{533.00, 480.00}} },
698 { 235727679255000ns, {{531.00, 501.00}} },
699 { 235727687233704ns, {{529.09, 526.73}} },
700 { 235727687628000ns, {{529.00, 528.00}} },
701 { 235727696113000ns, {{526.00, 558.00}} },
702 { 235727704057546ns, {{523.18, 588.98}} },
703 { 235727704576000ns, {{523.00, 591.00}} },
704 { 235727713099000ns, {{520.00, 626.00}} },
705 { 235727720880776ns, {{516.33, 655.36}} },
706 { 235727721580000ns, {{516.00, 658.00}} },
707 { 235727721580000ns, {{516.00, 658.00}} }, // ACTION_UP
708 };
709 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 4484.617676);
710 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 4927.92627);
711 }
712
713
TEST_F(VelocityTrackerTest,SailfishFlingDownFast1)714 TEST_F(VelocityTrackerTest, SailfishFlingDownFast1) {
715 // Sailfish - fling down - fast - 1
716 std::vector<MotionEventEntry> motions = {
717 { 235762352849000ns, {{467.00, 286.00}} },
718 { 235762360250000ns, {{443.00, 344.00}} },
719 { 235762362787412ns, {{434.77, 363.89}} },
720 { 235762368807000ns, {{438.00, 359.00}} },
721 { 235762377220000ns, {{425.00, 423.00}} },
722 { 235762379608561ns, {{421.31, 441.17}} },
723 { 235762385698000ns, {{412.00, 528.00}} },
724 { 235762394133000ns, {{406.00, 648.00}} },
725 { 235762396429369ns, {{404.37, 680.67}} },
726 { 235762396429369ns, {{404.37, 680.67}} }, //ACTION_UP
727 };
728 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 14227.0224);
729 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 16064.685547);
730 }
731
732
TEST_F(VelocityTrackerTest,SailfishFlingDownFast2)733 TEST_F(VelocityTrackerTest, SailfishFlingDownFast2) {
734 // Sailfish - fling down - fast - 2
735 std::vector<MotionEventEntry> motions = {
736 { 235772487188000ns, {{576.00, 204.00}} },
737 { 235772495159000ns, {{553.00, 236.00}} },
738 { 235772503568000ns, {{551.00, 240.00}} },
739 { 235772508192247ns, {{545.55, 254.17}} },
740 { 235772512051000ns, {{541.00, 266.00}} },
741 { 235772520794000ns, {{520.00, 337.00}} },
742 { 235772525015263ns, {{508.92, 394.43}} },
743 { 235772529174000ns, {{498.00, 451.00}} },
744 { 235772537635000ns, {{484.00, 589.00}} },
745 { 235772537635000ns, {{484.00, 589.00}} }, // ACTION_UP
746 };
747 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 18660.048828);
748 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 16918.439453);
749 }
750
751
TEST_F(VelocityTrackerTest,SailfishFlingDownFast3)752 TEST_F(VelocityTrackerTest, SailfishFlingDownFast3) {
753 // Sailfish - fling down - fast - 3
754 std::vector<MotionEventEntry> motions = {
755 { 507650295000ns, {{628.00, 233.00}} },
756 { 507658234000ns, {{605.00, 269.00}} },
757 { 507666784000ns, {{601.00, 274.00}} },
758 { 507669660483ns, {{599.65, 275.68}} },
759 { 507675427000ns, {{582.00, 308.00}} },
760 { 507683740000ns, {{541.00, 404.00}} },
761 { 507686506238ns, {{527.36, 435.95}} },
762 { 507692220000ns, {{487.00, 581.00}} },
763 { 507700707000ns, {{454.00, 792.00}} },
764 { 507703352649ns, {{443.71, 857.77}} },
765 { 507703352649ns, {{443.71, 857.77}} }, // ACTION_UP
766 };
767 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, -4111.8173);
768 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, -6388.48877);
769 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 29765.908203);
770 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 28354.796875);
771 }
772
773 /**
774 * ================== Multiple pointers ============================================================
775 *
776 * Three fingers quickly tap the screen. Since this is a tap, the velocities should be zero.
777 * If the events with POINTER_UP or POINTER_DOWN are not handled correctly (these should not be
778 * part of the fitted data), this can cause large velocity values to be reported instead.
779 */
TEST_F(VelocityTrackerTest,LeastSquaresVelocityTrackerStrategyEstimator_ThreeFingerTap)780 TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_ThreeFingerTap) {
781 std::vector<MotionEventEntry> motions = {
782 { 0us, {{1063, 1128}, {NAN, NAN}, {NAN, NAN}} },
783 { 10800us, {{1063, 1128}, {682, 1318}, {NAN, NAN}} }, // POINTER_DOWN
784 { 10800us, {{1063, 1128}, {682, 1318}, {397, 1747}} }, // POINTER_DOWN
785 { 267300us, {{1063, 1128}, {682, 1318}, {397, 1747}} }, // POINTER_UP
786 { 267300us, {{1063, 1128}, {NAN, NAN}, {397, 1747}} }, // POINTER_UP
787 { 272700us, {{1063, 1128}, {NAN, NAN}, {NAN, NAN}} },
788 };
789
790 // Velocity should actually be zero, but we expect 0.016 here instead.
791 // This is close enough to zero, and is likely caused by division by a very small number.
792 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, -0.016);
793 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -0.016);
794 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 0);
795 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 0);
796 }
797
798 /**
799 * ================== Tests for least squares fitting ==============================================
800 *
801 * Special care must be taken when constructing tests for LeastSquaresVelocityTrackerStrategy
802 * getEstimator function. In particular:
803 * - inside the function, time gets converted from nanoseconds to seconds
804 * before being used in the fit.
805 * - any values that are older than 100 ms are being discarded.
806 * - the newest time gets subtracted from all of the other times before being used in the fit.
807 * So these tests have to be designed with those limitations in mind.
808 *
809 * General approach for the tests below:
810 * We only used timestamps in milliseconds, 0 ms, 1 ms, and 2 ms, to be sure that
811 * we are well within the HORIZON range.
812 * When specifying the expected values of the coefficients, we treat the x values as if
813 * they were in ms. Then, to adjust for the time units, the coefficients get progressively
814 * multiplied by powers of 1E3.
815 * For example:
816 * data: t(ms), x
817 * 1 ms, 1
818 * 2 ms, 4
819 * 3 ms, 9
820 * The coefficients are (0, 0, 1).
821 * In the test, we would convert these coefficients to (0*(1E3)^0, 0*(1E3)^1, 1*(1E3)^2).
822 */
TEST_F(VelocityTrackerTest,LeastSquaresVelocityTrackerStrategyEstimator_Constant)823 TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Constant) {
824 std::vector<MotionEventEntry> motions = {
825 { 0ms, {{1, 1}} }, // 0 s
826 { 1ms, {{1, 1}} }, // 0.001 s
827 { 2ms, {{1, 1}} }, // 0.002 s
828 { 2ms, {{1, 1}} }, // ACTION_UP
829 };
830 // The data used for the fit will be as follows:
831 // time(s), position
832 // -0.002, 1
833 // -0.001, 1
834 // -0.ms, 1
835 computeAndCheckQuadraticEstimate(motions, std::array<float, 3>({1, 0, 0}));
836 }
837
838 /*
839 * Straight line y = x :: the constant and quadratic coefficients are zero.
840 */
TEST_F(VelocityTrackerTest,LeastSquaresVelocityTrackerStrategyEstimator_Linear)841 TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Linear) {
842 std::vector<MotionEventEntry> motions = {
843 { 0ms, {{-2, -2}} },
844 { 1ms, {{-1, -1}} },
845 { 2ms, {{-0, -0}} },
846 { 2ms, {{-0, -0}} }, // ACTION_UP
847 };
848 // The data used for the fit will be as follows:
849 // time(s), position
850 // -0.002, -2
851 // -0.001, -1
852 // -0.000, 0
853 computeAndCheckQuadraticEstimate(motions, std::array<float, 3>({0, 1E3, 0}));
854 }
855
856 /*
857 * Parabola
858 */
TEST_F(VelocityTrackerTest,LeastSquaresVelocityTrackerStrategyEstimator_Parabolic)859 TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Parabolic) {
860 std::vector<MotionEventEntry> motions = {
861 { 0ms, {{1, 1}} },
862 { 1ms, {{4, 4}} },
863 { 2ms, {{8, 8}} },
864 { 2ms, {{8, 8}} }, // ACTION_UP
865 };
866 // The data used for the fit will be as follows:
867 // time(s), position
868 // -0.002, 1
869 // -0.001, 4
870 // -0.000, 8
871 computeAndCheckQuadraticEstimate(motions, std::array<float, 3>({8, 4.5E3, 0.5E6}));
872 }
873
874 /*
875 * Parabola
876 */
TEST_F(VelocityTrackerTest,LeastSquaresVelocityTrackerStrategyEstimator_Parabolic2)877 TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Parabolic2) {
878 std::vector<MotionEventEntry> motions = {
879 { 0ms, {{1, 1}} },
880 { 1ms, {{4, 4}} },
881 { 2ms, {{9, 9}} },
882 { 2ms, {{9, 9}} }, // ACTION_UP
883 };
884 // The data used for the fit will be as follows:
885 // time(s), position
886 // -0.002, 1
887 // -0.001, 4
888 // -0.000, 9
889 computeAndCheckQuadraticEstimate(motions, std::array<float, 3>({9, 6E3, 1E6}));
890 }
891
892 /*
893 * Parabola :: y = x^2 :: the constant and linear coefficients are zero.
894 */
TEST_F(VelocityTrackerTest,LeastSquaresVelocityTrackerStrategyEstimator_Parabolic3)895 TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Parabolic3) {
896 std::vector<MotionEventEntry> motions = {
897 { 0ms, {{4, 4}} },
898 { 1ms, {{1, 1}} },
899 { 2ms, {{0, 0}} },
900 { 2ms, {{0, 0}} }, // ACTION_UP
901 };
902 // The data used for the fit will be as follows:
903 // time(s), position
904 // -0.002, 4
905 // -0.001, 1
906 // -0.000, 0
907 computeAndCheckQuadraticEstimate(motions, std::array<float, 3>({0, 0E3, 1E6}));
908 }
909
910 } // namespace android
911