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