WinCairo build fails to link.
[WebKit-https.git] / Source / WebKit / chromium / tests / ScrollAnimatorNoneTest.cpp
1 /*
2  * Copyright (C) 2010 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 // Tests for the ScrollAnimatorNone class.
27
28 #include "config.h"
29
30 #if ENABLE(SMOOTH_SCROLLING)
31
32 #include "ScrollAnimatorNone.h"
33
34 #include "FloatPoint.h"
35 #include "IntRect.h"
36 #include "Logging.h"
37 #include "ScrollAnimator.h"
38 #include "ScrollableArea.h"
39 #include "TreeTestHelpers.h"
40 #include <gmock/gmock.h>
41 #include <gtest/gtest.h>
42
43 using namespace std;
44 using namespace WebCore;
45
46 using testing::AtLeast;
47 using testing::Return;
48 using testing::_;
49
50 class MockScrollableArea : public ScrollableArea {
51 public:
52     MockScrollableArea(bool scrollAnimatorEnabled)
53         : m_scrollAnimatorEnabled(scrollAnimatorEnabled) { }
54
55     MOCK_CONST_METHOD0(isActive, bool());
56     MOCK_CONST_METHOD1(scrollSize, int(ScrollbarOrientation));
57     MOCK_CONST_METHOD1(scrollPosition, int(Scrollbar*));
58     MOCK_METHOD2(invalidateScrollbar, void(Scrollbar*, const IntRect&));
59     MOCK_CONST_METHOD0(isScrollCornerVisible, bool());
60     MOCK_CONST_METHOD0(scrollCornerRect, IntRect());
61     MOCK_METHOD1(setScrollOffset, void(const IntPoint&));
62     MOCK_METHOD2(invalidateScrollbarRect, void(Scrollbar*, const IntRect&));
63     MOCK_METHOD1(invalidateScrollCornerRect, void(const IntRect&));
64     MOCK_METHOD1(setScrollOffsetFromAnimation, void(const IntPoint&));
65     MOCK_CONST_METHOD0(enclosingScrollableArea, ScrollableArea*());
66     MOCK_CONST_METHOD0(minimumScrollPosition, IntPoint());
67     MOCK_CONST_METHOD0(maximumScrollPosition, IntPoint());
68     MOCK_CONST_METHOD1(visibleContentRect, IntRect(VisibleContentRectIncludesScrollbars));
69     MOCK_CONST_METHOD0(contentsSize, IntSize());
70     MOCK_CONST_METHOD0(overhangAmount, IntSize());
71     MOCK_CONST_METHOD0(scrollbarsCanBeActive, bool());
72     MOCK_CONST_METHOD0(scrollableAreaBoundingBox, IntRect());
73
74     virtual IntPoint scrollPosition() const OVERRIDE { return IntPoint(); }
75     virtual int visibleHeight() const OVERRIDE { return 768; }
76     virtual int visibleWidth() const OVERRIDE { return 1024; }
77     virtual bool scrollAnimatorEnabled() const OVERRIDE { return m_scrollAnimatorEnabled; }
78
79 private:
80     bool m_scrollAnimatorEnabled;
81 };
82
83 class MockScrollAnimatorNone : public ScrollAnimatorNone {
84 public:
85     MockScrollAnimatorNone()
86         : ScrollAnimatorNone(new MockScrollableArea(true)) { }
87     MockScrollAnimatorNone(ScrollableArea* scrollableArea)
88         : ScrollAnimatorNone(scrollableArea) { }
89
90     float currentX() { return m_currentPosX; }
91     float currentY() { return m_currentPosY; }
92
93     FloatPoint m_fp;
94     int m_count;
95
96     void reset()
97     {
98         stopAnimationTimerIfNeeded();
99         m_currentPosX = 0;
100         m_currentPosY = 0;
101         m_horizontalData.reset();
102         m_verticalData.reset();
103         m_fp = FloatPoint::zero();
104         m_count = 0;
105     }
106
107     virtual void fireUpAnAnimation(FloatPoint fp)
108     {
109         m_fp = fp;
110         m_count++;
111     }
112
113     MOCK_METHOD1(scrollToOffsetWithoutAnimation, void(const FloatPoint&));
114 };
115
116 TEST(ScrollAnimatorEnabled, Enabled)
117 {
118     MockScrollableArea scrollableArea(true);
119     MockScrollAnimatorNone scrollAnimatorNone(&scrollableArea);
120
121     EXPECT_CALL(scrollableArea, scrollSize(_)).Times(AtLeast(1)).WillRepeatedly(Return(1000));
122     EXPECT_CALL(scrollableArea, setScrollOffset(_)).Times(4);
123
124     scrollAnimatorNone.scroll(HorizontalScrollbar, ScrollByLine, 100, 1);
125     EXPECT_NE(100, scrollAnimatorNone.currentX());
126     EXPECT_NE(0, scrollAnimatorNone.currentX());
127     EXPECT_EQ(0, scrollAnimatorNone.currentY());
128     scrollAnimatorNone.reset();
129
130     scrollAnimatorNone.scroll(HorizontalScrollbar, ScrollByPage, 100, 1);
131     EXPECT_NE(100, scrollAnimatorNone.currentX());
132     EXPECT_NE(0, scrollAnimatorNone.currentX());
133     EXPECT_EQ(0, scrollAnimatorNone.currentY());
134     scrollAnimatorNone.reset();
135
136     scrollAnimatorNone.scroll(HorizontalScrollbar, ScrollByPixel, 4, 25);
137     EXPECT_NE(100, scrollAnimatorNone.currentX());
138     EXPECT_NE(0, scrollAnimatorNone.currentX());
139     EXPECT_EQ(0, scrollAnimatorNone.currentY());
140     scrollAnimatorNone.reset();
141
142     scrollAnimatorNone.scroll(HorizontalScrollbar, ScrollByPrecisePixel, 4, 25);
143     EXPECT_EQ(100, scrollAnimatorNone.currentX());
144     EXPECT_NE(0, scrollAnimatorNone.currentX());
145     EXPECT_EQ(0, scrollAnimatorNone.currentY());
146     scrollAnimatorNone.reset();
147 }
148
149 TEST(ScrollAnimatorEnabled, Disabled)
150 {
151     MockScrollableArea scrollableArea(false);
152     MockScrollAnimatorNone scrollAnimatorNone(&scrollableArea);
153
154     EXPECT_CALL(scrollableArea, scrollSize(_)).Times(AtLeast(1)).WillRepeatedly(Return(1000));
155     EXPECT_CALL(scrollableArea, setScrollOffset(_)).Times(4);
156
157     scrollAnimatorNone.scroll(HorizontalScrollbar, ScrollByLine, 100, 1);
158     EXPECT_EQ(100, scrollAnimatorNone.currentX());
159     EXPECT_EQ(0, scrollAnimatorNone.currentY());
160     scrollAnimatorNone.reset();
161
162     scrollAnimatorNone.scroll(HorizontalScrollbar, ScrollByPage, 100, 1);
163     EXPECT_EQ(100, scrollAnimatorNone.currentX());
164     EXPECT_EQ(0, scrollAnimatorNone.currentY());
165     scrollAnimatorNone.reset();
166
167     scrollAnimatorNone.scroll(HorizontalScrollbar, ScrollByDocument, 100, 1);
168     EXPECT_EQ(100, scrollAnimatorNone.currentX());
169     EXPECT_EQ(0, scrollAnimatorNone.currentY());
170     scrollAnimatorNone.reset();
171
172     scrollAnimatorNone.scroll(HorizontalScrollbar, ScrollByPixel, 100, 1);
173     EXPECT_EQ(100, scrollAnimatorNone.currentX());
174     EXPECT_EQ(0, scrollAnimatorNone.currentY());
175     scrollAnimatorNone.reset();
176 }
177
178 class ScrollAnimatorNoneTest : public testing::Test {
179 public:
180     struct SavePerAxisData : public ScrollAnimatorNone::PerAxisData {
181         SavePerAxisData(const ScrollAnimatorNone::PerAxisData& data)
182             : ScrollAnimatorNone::PerAxisData(&m_mockScrollAnimatorNone, 0, 768)
183         {
184             this->m_currentVelocity = data.m_currentVelocity;
185             this->m_desiredPosition = data.m_desiredPosition;
186             this->m_desiredVelocity = data.m_desiredVelocity;
187             this->m_startPosition = data.m_startPosition;
188             this->m_startTime = data.m_startTime;
189             this->m_startVelocity = data.m_startVelocity;
190             this->m_animationTime = data.m_animationTime;
191             this->m_lastAnimationTime = data.m_lastAnimationTime;
192             this->m_attackPosition = data.m_attackPosition;
193             this->m_attackTime = data.m_attackTime;
194             this->m_attackCurve = data.m_attackCurve;
195             this->m_releasePosition = data.m_releasePosition;
196             this->m_releaseTime = data.m_releaseTime;
197             this->m_releaseCurve = data.m_releaseCurve;
198         }
199
200         bool operator==(const SavePerAxisData& other) const
201         {
202             return m_currentVelocity == other.m_currentVelocity && m_desiredPosition == other.m_desiredPosition && m_desiredVelocity == other.m_desiredVelocity && m_startPosition == other.m_startPosition && m_startTime == other.m_startTime && m_startVelocity == other.m_startVelocity && m_animationTime == other.m_animationTime && m_lastAnimationTime == other.m_lastAnimationTime && m_attackPosition == other.m_attackPosition && m_attackTime == other.m_attackTime && m_attackCurve == other.m_attackCurve && m_releasePosition == other.m_releasePosition && m_releaseTime == other.m_releaseTime && m_releaseCurve == other.m_releaseCurve;
203         }
204         MockScrollAnimatorNone m_mockScrollAnimatorNone;
205     };
206
207     ScrollAnimatorNoneTest()
208     {
209     }
210
211     virtual void SetUp()
212     {
213         m_currentPosition = 100;
214         m_data = new ScrollAnimatorNone::PerAxisData(&m_mockScrollAnimatorNone, &m_currentPosition, 768);
215     }
216     virtual void TearDown()
217     {
218         delete m_data;
219     }
220
221     void reset();
222     bool updateDataFromParameters(float step, float multiplier, float scrollableSize, double currentTime, ScrollAnimatorNone::Parameters*);
223     bool animateScroll(double currentTime);
224
225     double attackArea(ScrollAnimatorNone::Curve, double startT, double endT);
226     double releaseArea(ScrollAnimatorNone::Curve, double startT, double endT);
227     double attackCurve(ScrollAnimatorNone::Curve, double deltaT, double curveT, double startPosition, double attackPosition);
228     double releaseCurve(ScrollAnimatorNone::Curve, double deltaT, double curveT, double releasePosition, double desiredPosition);
229     double coastCurve(ScrollAnimatorNone::Curve, double factor);
230
231     void curveTestInner(ScrollAnimatorNone::Curve, double step, double time);
232     void curveTest(ScrollAnimatorNone::Curve);
233
234     void checkDesiredPosition(float expectedPosition);
235     void checkSoftLanding(float expectedPosition);
236
237     static double kTickTime;
238     static double kAnimationTime;
239     static double kStartTime;
240     static double kEndTime;
241     float m_currentPosition;
242     MockScrollAnimatorNone m_mockScrollAnimatorNone;
243     bool m_scrollingDown;
244     ScrollAnimatorNone::PerAxisData* m_data;
245 };
246
247 double ScrollAnimatorNoneTest::kTickTime = 1 / 60.0;
248 double ScrollAnimatorNoneTest::kAnimationTime = 0.01;
249 double ScrollAnimatorNoneTest::kStartTime = 10.0;
250 double ScrollAnimatorNoneTest::kEndTime = 20.0;
251
252 void ScrollAnimatorNoneTest::reset()
253 {
254     m_data->reset();
255     m_scrollingDown = true;
256 }
257
258 bool ScrollAnimatorNoneTest::updateDataFromParameters(float step, float multiplier, float scrollableSize, double currentTime, ScrollAnimatorNone::Parameters* parameters)
259 {
260     if (step * multiplier)
261         m_scrollingDown = (step * multiplier > 0);
262
263     double oldVelocity = m_data->m_currentVelocity;
264     double oldDesiredVelocity = m_data->m_desiredVelocity;
265     double oldTimeLeft = m_data->m_animationTime - (m_data->m_lastAnimationTime - m_data->m_startTime);
266     bool result = m_data->updateDataFromParameters(step, multiplier, scrollableSize, currentTime, parameters);
267     if (m_scrollingDown)
268         EXPECT_LE(oldVelocity, m_data->m_currentVelocity);
269     else
270         EXPECT_GE(oldVelocity, m_data->m_currentVelocity);
271
272     double deltaTime = m_data->m_lastAnimationTime - m_data->m_startTime;
273     double timeLeft = m_data->m_animationTime - deltaTime;
274     double releaseTimeLeft = min(timeLeft, m_data->m_releaseTime);
275     double attackTimeLeft = max(0., m_data->m_attackTime - deltaTime);
276     double sustainTimeLeft = max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
277
278     // If we're getting near the finish, the desired velocity can decrease since the time left gets increased.
279     if (step * multiplier) {
280         double allowedVelocityDecreaseFactor = 0.99 * oldTimeLeft / timeLeft;
281         allowedVelocityDecreaseFactor *= allowedVelocityDecreaseFactor;
282         if (m_scrollingDown)
283             EXPECT_LE(oldDesiredVelocity * allowedVelocityDecreaseFactor, m_data->m_desiredVelocity);
284         else
285             EXPECT_GE(oldDesiredVelocity * allowedVelocityDecreaseFactor, m_data->m_desiredVelocity);
286
287         double startPosition = attackTimeLeft ? m_data->m_attackPosition : m_currentPosition;
288         double expectedReleasePosition = startPosition + sustainTimeLeft * m_data->m_desiredVelocity;
289         EXPECT_NEAR(expectedReleasePosition, m_data->m_releasePosition, result ? .0001 : 1);
290     }
291
292     return result;
293 }
294
295 bool ScrollAnimatorNoneTest::animateScroll(double currentTime)
296 {
297     double oldPosition = *m_data->m_currentPosition;
298     bool testEstimatedMaxVelocity = m_data->m_startTime + m_data->m_animationTime - m_data->m_lastAnimationTime > m_data->m_releaseTime;
299
300     bool result = m_data->animateScroll(currentTime);
301
302     double deltaTime = m_data->m_lastAnimationTime - m_data->m_startTime;
303     double timeLeft = m_data->m_animationTime - deltaTime;
304     double releaseTimeLeft = min(timeLeft, m_data->m_releaseTime);
305     double attackTimeLeft = max(0., m_data->m_attackTime - deltaTime);
306     double sustainTimeLeft = max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
307     double distanceLeft = m_data->m_desiredPosition - *m_data->m_currentPosition;
308
309     if (m_scrollingDown) {
310         EXPECT_LE(0, m_data->m_currentVelocity);
311         EXPECT_LE(oldPosition, *m_data->m_currentPosition);
312     } else {
313         EXPECT_GE(0, m_data->m_currentVelocity);
314         EXPECT_GE(oldPosition, *m_data->m_currentPosition);
315     }
316     EXPECT_GE(fabs(m_data->m_desiredVelocity) * 2, fabs(m_data->m_currentVelocity));
317     if (testEstimatedMaxVelocity)
318         EXPECT_GE(fabs(distanceLeft / sustainTimeLeft) * 1.2, fabs(m_data->m_currentVelocity));
319
320     return result;
321 }
322
323 double ScrollAnimatorNoneTest::attackArea(ScrollAnimatorNone::Curve curve, double startT, double endT)
324 {
325     return ScrollAnimatorNone::PerAxisData::attackArea(curve, startT, endT);
326 }
327
328 double ScrollAnimatorNoneTest::releaseArea(ScrollAnimatorNone::Curve curve, double startT, double endT)
329 {
330     return ScrollAnimatorNone::PerAxisData::releaseArea(curve, startT, endT);
331 }
332
333 double ScrollAnimatorNoneTest::attackCurve(ScrollAnimatorNone::Curve curve, double deltaT, double curveT, double startPosition, double attackPosition)
334 {
335     return ScrollAnimatorNone::PerAxisData::attackCurve(curve, deltaT, curveT, startPosition, attackPosition);
336 }
337
338 double ScrollAnimatorNoneTest::releaseCurve(ScrollAnimatorNone::Curve curve, double deltaT, double curveT, double releasePosition, double desiredPosition)
339 {
340     return ScrollAnimatorNone::PerAxisData::releaseCurve(curve, deltaT, curveT, releasePosition, desiredPosition);
341 }
342
343 double ScrollAnimatorNoneTest::coastCurve(ScrollAnimatorNone::Curve curve, double factor)
344 {
345     return ScrollAnimatorNone::PerAxisData::coastCurve(curve, factor);
346 }
347
348 void ScrollAnimatorNoneTest::curveTestInner(ScrollAnimatorNone::Curve curve, double step, double time)
349 {
350     const double kPosition = 1000;
351
352     double oldPos = 0;
353     double oldVelocity = 0;
354     double accumulate = 0;
355
356     for (double t = step ; t <= time ; t += step) {
357         double newPos = attackCurve(curve, t, time, 0, kPosition);
358         double delta = newPos - oldPos;
359         double velocity = delta / step;
360         double velocityDelta = velocity - oldVelocity;
361
362         accumulate += (oldPos + newPos) / 2 * (step / time);
363         oldPos = newPos;
364         oldVelocity = velocity;
365         if (curve != ScrollAnimatorNone::Bounce) {
366             EXPECT_LE(-.0001, velocityDelta);
367             EXPECT_LT(0, delta);
368         }
369
370         double area = attackArea(curve, 0, t / time) * kPosition;
371         EXPECT_LE(0, area);
372         EXPECT_NEAR(accumulate, area, 1.0);
373     }
374
375     oldPos = 0;
376     oldVelocity *= 2;
377     accumulate = releaseArea(curve, 0, 1) * kPosition;
378     for (double t = step ; t <= time ; t += step) {
379         double newPos = releaseCurve(curve, t, time, 0, kPosition);
380         double delta = newPos - oldPos;
381         double velocity = delta / step;
382         double velocityDelta = velocity - oldVelocity;
383
384         accumulate -= (kPosition - (oldPos + newPos) / 2) * (step / time);
385         oldPos = newPos;
386         oldVelocity = velocity;
387         if (curve != ScrollAnimatorNone::Bounce) {
388             EXPECT_GE(0.01, velocityDelta);
389             EXPECT_LT(0, delta);
390         }
391
392         double area = releaseArea(curve, t / time, 1) * kPosition;
393         EXPECT_LE(0, area);
394         EXPECT_NEAR(accumulate, area, 1.0);
395     }
396 }
397
398 void ScrollAnimatorNoneTest::curveTest(ScrollAnimatorNone::Curve curve)
399 {
400     curveTestInner(curve, 0.01, 0.25);
401     curveTestInner(curve, 0.2, 10);
402     curveTestInner(curve, 0.025, 10);
403     curveTestInner(curve, 0.01, 1);
404     curveTestInner(curve, 0.25, 40);
405 }
406
407 void ScrollAnimatorNoneTest::checkDesiredPosition(float expectedPosition)
408 {
409     EXPECT_EQ(expectedPosition, m_data->m_desiredPosition);
410 }
411
412 void ScrollAnimatorNoneTest::checkSoftLanding(float expectedPosition)
413 {
414     EXPECT_EQ(expectedPosition, m_currentPosition);
415     EXPECT_LE(m_data->m_desiredVelocity / 2, m_data->m_currentVelocity);
416 }
417
418 TEST_F(ScrollAnimatorNoneTest, CurveMathLinear)
419 {
420     curveTest(ScrollAnimatorNone::Linear);
421 }
422
423 TEST_F(ScrollAnimatorNoneTest, CurveMathQuadratic)
424 {
425     curveTest(ScrollAnimatorNone::Quadratic);
426 }
427
428 TEST_F(ScrollAnimatorNoneTest, CurveMathCubic)
429 {
430     curveTest(ScrollAnimatorNone::Cubic);
431 }
432
433 TEST_F(ScrollAnimatorNoneTest, CurveMathQuartic)
434 {
435     curveTest(ScrollAnimatorNone::Quartic);
436 }
437
438 TEST_F(ScrollAnimatorNoneTest, CurveMathBounce)
439 {
440     curveTest(ScrollAnimatorNone::Bounce);
441 }
442
443 TEST_F(ScrollAnimatorNoneTest, CurveMathCoast)
444 {
445     for (double t = .25; t < 1; t += .25) {
446         EXPECT_EQ(t, coastCurve(ScrollAnimatorNone::Linear, t));
447         EXPECT_LT(t, coastCurve(ScrollAnimatorNone::Quadratic, t));
448         EXPECT_LT(t, coastCurve(ScrollAnimatorNone::Cubic, t));
449         EXPECT_LT(coastCurve(ScrollAnimatorNone::Quadratic, t), coastCurve(ScrollAnimatorNone::Cubic, t));
450         EXPECT_LT(t, coastCurve(ScrollAnimatorNone::Quartic, t));
451         EXPECT_LT(coastCurve(ScrollAnimatorNone::Cubic, t), coastCurve(ScrollAnimatorNone::Quartic, t));
452     }
453 }
454
455 TEST_F(ScrollAnimatorNoneTest, ScrollOnceLinear)
456 {
457     ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Linear, 3 * kTickTime, ScrollAnimatorNone::Linear, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
458
459     EXPECT_TRUE(updateDataFromParameters(1, 40, 1000, kStartTime, &parameters));
460     bool result = true;
461     for (double t = kStartTime; result && t < kEndTime; t += kAnimationTime)
462         result = animateScroll(t);
463 }
464
465 TEST_F(ScrollAnimatorNoneTest, ScrollOnceQuadratic)
466 {
467     ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
468
469     EXPECT_TRUE(updateDataFromParameters(1, 40, 1000, kStartTime, &parameters));
470     bool result = true;
471     for (double t = kStartTime; result && t < kEndTime; t += kAnimationTime)
472         result = animateScroll(t);
473 }
474
475 TEST_F(ScrollAnimatorNoneTest, ScrollLongQuadratic)
476 {
477     ScrollAnimatorNone::Parameters parameters(true, 20 * kTickTime, 0, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
478
479     EXPECT_TRUE(updateDataFromParameters(1, 40, 1000, kStartTime, &parameters));
480     bool result = true;
481     for (double t = kStartTime; result && t < kEndTime; t += kAnimationTime)
482         result = animateScroll(t);
483 }
484
485 TEST_F(ScrollAnimatorNoneTest, ScrollQuadraticNoSustain)
486 {
487     ScrollAnimatorNone::Parameters parameters(true, 8 * kTickTime, 0, ScrollAnimatorNone::Quadratic, 4 * kTickTime, ScrollAnimatorNone::Quadratic, 4 * kTickTime, ScrollAnimatorNone::Linear, 0);
488
489     EXPECT_TRUE(updateDataFromParameters(1, 40, 1000, kStartTime, &parameters));
490     bool result = true;
491     for (double t = kStartTime; result && t < kEndTime; t += kAnimationTime)
492         result = animateScroll(t);
493 }
494
495 TEST_F(ScrollAnimatorNoneTest, ScrollQuadraticSmoothed)
496 {
497     ScrollAnimatorNone::Parameters parameters(true, 8 * kTickTime, 8 * kTickTime, ScrollAnimatorNone::Quadratic, 4 * kTickTime, ScrollAnimatorNone::Quadratic, 4 * kTickTime, ScrollAnimatorNone::Linear, 0);
498
499     EXPECT_TRUE(updateDataFromParameters(1, 40, 1000, kStartTime, &parameters));
500     bool result = true;
501     for (double t = kStartTime; result && t < kEndTime; t += kAnimationTime)
502         result = animateScroll(t);
503 }
504
505 TEST_F(ScrollAnimatorNoneTest, ScrollOnceCubic)
506 {
507     ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
508
509     EXPECT_TRUE(updateDataFromParameters(1, 40, 1000, kStartTime, &parameters));
510     bool result = true;
511     for (double t = kStartTime; result && t < kEndTime; t += kAnimationTime)
512         result = animateScroll(t);
513 }
514
515 TEST_F(ScrollAnimatorNoneTest, ScrollOnceQuartic)
516 {
517     ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Quartic, 3 * kTickTime, ScrollAnimatorNone::Quartic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
518
519     EXPECT_TRUE(updateDataFromParameters(1, 40, 1000, kStartTime, &parameters));
520     bool result = true;
521     for (double t = kStartTime; result && t < kEndTime; t += kAnimationTime)
522         result = animateScroll(t);
523 }
524
525 TEST_F(ScrollAnimatorNoneTest, ScrollOnceShort)
526 {
527     ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
528
529     EXPECT_TRUE(updateDataFromParameters(1, 40, 1000, kStartTime, &parameters));
530     bool result = true;
531     for (double t = kStartTime; result && t < kEndTime; t += kTickTime)
532         result = animateScroll(t);
533 }
534
535 TEST_F(ScrollAnimatorNoneTest, ScrollTwiceQuadratic)
536 {
537     ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
538
539     EXPECT_TRUE(updateDataFromParameters(1, 40, 1000, kStartTime, &parameters));
540     bool result = true;
541     double t;
542     for (t = kStartTime; result && t < kStartTime + 1.5 * kTickTime; t += kAnimationTime)
543         result = animateScroll(t);
544
545     result = result && animateScroll(t);
546     double before = m_currentPosition;
547     result = result && updateDataFromParameters(1, 40, 1000, t, &parameters);
548     result = result && animateScroll(t);
549     double after = m_currentPosition;
550     EXPECT_NEAR(before, after, 10);
551
552     t += kAnimationTime;
553
554     result = result && animateScroll(t);
555     before = m_currentPosition;
556     result = result && updateDataFromParameters(1, 40, 1000, t, &parameters);
557     result = result && animateScroll(t);
558     after = m_currentPosition;
559     EXPECT_NEAR(before, after, 10);
560
561     t += kAnimationTime;
562     for (; result && t < kEndTime; t += kAnimationTime)
563         result = animateScroll(t);
564 }
565
566 TEST_F(ScrollAnimatorNoneTest, ScrollLotsQuadratic)
567 {
568     ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
569
570     EXPECT_TRUE(updateDataFromParameters(1, 40, 10000, kStartTime, &parameters));
571     bool result = true;
572     double t;
573     for (t = kStartTime; result && t < kStartTime + 1.5 * kTickTime; t += kAnimationTime)
574         result = animateScroll(t);
575
576     for (int i = 0; i < 20; ++i) {
577         t += kAnimationTime;
578         result = result && animateScroll(t);
579         result = result && updateDataFromParameters(3, 40, 10000, t, &parameters);
580     }
581
582     t += kAnimationTime;
583     for (; result && t < kEndTime; t += kAnimationTime)
584         result = result && animateScroll(t);
585 }
586
587 TEST_F(ScrollAnimatorNoneTest, ScrollLotsQuadraticSmoothed)
588 {
589     ScrollAnimatorNone::Parameters parameters(true, 10 * kTickTime, 6 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Quadratic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
590
591     EXPECT_TRUE(updateDataFromParameters(1, 40, 10000, kStartTime, &parameters));
592     bool result = true;
593     double t;
594     for (t = kStartTime; result && t < kStartTime + 1.5 * kTickTime; t += kAnimationTime)
595         result = animateScroll(t);
596
597     for (int i = 0; i < 20; ++i) {
598         t += kAnimationTime;
599         result = result && animateScroll(t);
600         result = result && updateDataFromParameters(3, 40, 10000, t, &parameters);
601     }
602
603     t += kAnimationTime;
604     for (; result && t < kEndTime; t += kAnimationTime)
605         result = result && animateScroll(t);
606 }
607
608 TEST_F(ScrollAnimatorNoneTest, ScrollTwiceCubic)
609 {
610     ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
611
612     EXPECT_TRUE(updateDataFromParameters(1, 40, 1000, kStartTime, &parameters));
613     bool result = true;
614     double t;
615     for (t = kStartTime; result && t < kStartTime + 1.5 * kTickTime; t += kAnimationTime)
616         result = animateScroll(t);
617
618     result = result && animateScroll(t);
619     double before = m_currentPosition;
620     result = result && updateDataFromParameters(1, 40, 1000, t, &parameters);
621     result = result && animateScroll(t);
622     double after = m_currentPosition;
623     EXPECT_NEAR(before, after, 10);
624
625     t += kAnimationTime;
626
627     result = result && animateScroll(t);
628     before = m_currentPosition;
629     result = result && updateDataFromParameters(1, 40, 1000, t, &parameters);
630     result = result && animateScroll(t);
631     after = m_currentPosition;
632     EXPECT_NEAR(before, after, 10);
633
634     t += kAnimationTime;
635     for (; result && t < kEndTime; t += kAnimationTime)
636         result = animateScroll(t);
637 }
638
639 TEST_F(ScrollAnimatorNoneTest, ScrollLotsCubic)
640 {
641     ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
642
643     EXPECT_TRUE(updateDataFromParameters(1, 40, 10000, kStartTime, &parameters));
644     bool result = true;
645     double t;
646     for (t = kStartTime; result && t < kStartTime + 1.5 * kTickTime; t += kAnimationTime)
647         result = animateScroll(t);
648
649     for (int i = 0; i < 20; ++i) {
650         t += kAnimationTime;
651         result = result && animateScroll(t);
652         result = result && updateDataFromParameters(3, 40, 10000, t, &parameters);
653     }
654
655     t += kAnimationTime;
656     for (; result && t < kEndTime; t += kAnimationTime)
657         result = result && animateScroll(t);
658 }
659
660 TEST_F(ScrollAnimatorNoneTest, ScrollLotsCubicSmoothed)
661 {
662     ScrollAnimatorNone::Parameters parameters(true, 10 * kTickTime, 6 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
663
664     EXPECT_TRUE(updateDataFromParameters(1, 40, 10000, kStartTime, &parameters));
665     bool result = true;
666     double t;
667     for (t = kStartTime; result && t < kStartTime + 1.5 * kTickTime; t += kAnimationTime)
668         result = animateScroll(t);
669
670     for (int i = 0; i < 20; ++i) {
671         t += kAnimationTime;
672         result = result && animateScroll(t);
673         result = result && updateDataFromParameters(3, 40, 10000, t, &parameters);
674     }
675
676     t += kAnimationTime;
677     for (; result && t < kEndTime; t += kAnimationTime)
678         result = result && animateScroll(t);
679 }
680
681 TEST_F(ScrollAnimatorNoneTest, ScrollWheelTrace)
682 {
683     ScrollAnimatorNone::Parameters parameters(true, 11 * kTickTime, 0, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
684
685     // Constructed from an actual scroll wheel trace that exhibited a glitch.
686     bool result = updateDataFromParameters(1, 53.33f, 1000, 100.5781f, &parameters);
687     result = animateScroll(100.5933);
688     result = result && animateScroll(100.6085);
689     result = result && updateDataFromParameters(1, 53.33f, 1000, 100.6485f, &parameters);
690     result = result && animateScroll(100.6515);
691     result = result && animateScroll(100.6853);
692     result = result && updateDataFromParameters(1, 53.33f, 1000, 100.6863f, &parameters);
693     result = result && animateScroll(100.7005);
694     result = result && animateScroll(100.7157);
695     result = result && animateScroll(100.7312);
696     result = result && updateDataFromParameters(1, 53.33f, 1000, 100.7379f, &parameters);
697     result = result && animateScroll(100.7464);
698     result = result && animateScroll(100.7617);
699     result = result && animateScroll(100.7775);
700     result = result && updateDataFromParameters(1, 53.33f, 1000, 100.7779f, &parameters);
701     for (double t = 100.7928; result && t < 200; t += 0.015)
702         result = result && animateScroll(t);
703 }
704
705 TEST_F(ScrollAnimatorNoneTest, ScrollWheelTraceSmoothed)
706 {
707     ScrollAnimatorNone::Parameters parameters(true, 11 * kTickTime, 7 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
708
709     // Constructed from an actual scroll wheel trace that exhibited a glitch.
710     bool result = updateDataFromParameters(1, 53.33f, 1000, 100.5781f, &parameters);
711     result = animateScroll(100.5933);
712     result = result && animateScroll(100.6085);
713     result = result && updateDataFromParameters(1, 53.33f, 1000, 100.6485f, &parameters);
714     result = result && animateScroll(100.6515);
715     result = result && animateScroll(100.6853);
716     result = result && updateDataFromParameters(1, 53.33f, 1000, 100.6863f, &parameters);
717     result = result && animateScroll(100.7005);
718     result = result && animateScroll(100.7157);
719     result = result && animateScroll(100.7312);
720     result = result && updateDataFromParameters(1, 53.33f, 1000, 100.7379f, &parameters);
721     result = result && animateScroll(100.7464);
722     result = result && animateScroll(100.7617);
723     result = result && animateScroll(100.7775);
724     result = result && updateDataFromParameters(1, 53.33f, 1000, 100.7779f, &parameters);
725     for (double t = 100.7928; result && t < 200; t += 0.015)
726         result = result && animateScroll(t);
727 }
728
729 TEST_F(ScrollAnimatorNoneTest, LinuxTrackPadTrace)
730 {
731     ScrollAnimatorNone::Parameters parameters(true, 11 * kTickTime, 0, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
732
733     bool result = updateDataFromParameters(1.00, 60.00, 1000, 100.6863, &parameters);
734     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.6897, &parameters);
735     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.7001, &parameters);
736     result = result && animateScroll(100.7015);
737     result = result && animateScroll(100.7169);
738     result = result && updateDataFromParameters(1.00, 40.00, 1000, 100.7179, &parameters);
739     result = result && animateScroll(100.7322);
740     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.7332, &parameters);
741     result = result && animateScroll(100.7491);
742     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.7519, &parameters);
743     result = result && animateScroll(100.7676);
744     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.7698, &parameters);
745     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.7830, &parameters);
746     result = result && animateScroll(100.7834);
747     result = result && animateScroll(100.7997);
748     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.8019, &parameters);
749     result = result && animateScroll(100.8154);
750     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.8241, &parameters);
751     result = result && animateScroll(100.8335);
752     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.8465, &parameters);
753     result = result && animateScroll(100.8513);
754     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.8623, &parameters);
755     for (double t = 100.8674; result && t < 200; t += 0.015)
756         result = result && animateScroll(t);
757 }
758
759 TEST_F(ScrollAnimatorNoneTest, LinuxTrackPadTraceSmoothed)
760 {
761     ScrollAnimatorNone::Parameters parameters(true, 11 * kTickTime, 7 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
762
763     bool result = updateDataFromParameters(1.00, 60.00, 1000, 100.6863, &parameters);
764     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.6897, &parameters);
765     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.7001, &parameters);
766     result = result && animateScroll(100.7015);
767     result = result && animateScroll(100.7169);
768     result = result && updateDataFromParameters(1.00, 40.00, 1000, 100.7179, &parameters);
769     result = result && animateScroll(100.7322);
770     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.7332, &parameters);
771     result = result && animateScroll(100.7491);
772     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.7519, &parameters);
773     result = result && animateScroll(100.7676);
774     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.7698, &parameters);
775     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.7830, &parameters);
776     result = result && animateScroll(100.7834);
777     result = result && animateScroll(100.7997);
778     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.8019, &parameters);
779     result = result && animateScroll(100.8154);
780     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.8241, &parameters);
781     result = result && animateScroll(100.8335);
782     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.8465, &parameters);
783     result = result && animateScroll(100.8513);
784     result = result && updateDataFromParameters(1.00, 20.00, 1000, 100.8623, &parameters);
785     for (double t = 100.8674; result && t < 200; t += 0.015)
786         result = result && animateScroll(t);
787 }
788
789 TEST_F(ScrollAnimatorNoneTest, ScrollDownToBumper)
790 {
791     ScrollAnimatorNone::Parameters parameters(true, 10 * kTickTime, 7 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
792
793     EXPECT_TRUE(updateDataFromParameters(1, 20, 200, kStartTime, &parameters));
794     bool result = true;
795     double t = kStartTime;
796     for (int i = 0; i < 10; ++i) {
797         t += kAnimationTime;
798         result = result && animateScroll(t);
799         updateDataFromParameters(1, 20, 200, t, &parameters);
800     }
801     checkDesiredPosition(200);
802
803     t += kAnimationTime;
804     for (; result && t < kEndTime; t += kAnimationTime)
805         result = result && animateScroll(t);
806     checkSoftLanding(200);
807 }
808
809 TEST_F(ScrollAnimatorNoneTest, ScrollUpToBumper)
810 {
811     ScrollAnimatorNone::Parameters parameters(true, 10 * kTickTime, 7 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
812
813     EXPECT_TRUE(updateDataFromParameters(1, -20, 200, kStartTime, &parameters));
814     bool result = true;
815     double t = kStartTime;
816     for (int i = 0; i < 10; ++i) {
817         t += kAnimationTime;
818         result = result && animateScroll(t);
819         updateDataFromParameters(1, -20, 200, t, &parameters);
820     }
821     checkDesiredPosition(0);
822
823     t += kAnimationTime;
824     for (; result && t < kEndTime; t += kAnimationTime)
825         result = result && animateScroll(t);
826     checkSoftLanding(0);
827 }
828
829 TEST_F(ScrollAnimatorNoneTest, ScrollUpToBumperCoast)
830 {
831     ScrollAnimatorNone::Parameters parameters(true, 11 * kTickTime, 2 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 1);
832
833     m_currentPosition = 40000;
834     EXPECT_TRUE(updateDataFromParameters(1, -10000, 50000, kStartTime, &parameters));
835     bool result = true;
836     double t = kStartTime;
837     for (int i = 0; i < 10; ++i) {
838         t += kAnimationTime;
839         result = result && animateScroll(t);
840         updateDataFromParameters(1, -10000, 50000, t, &parameters);
841     }
842     checkDesiredPosition(0);
843
844     t += kAnimationTime;
845     for (; result && t < kEndTime; t += kAnimationTime)
846         result = result && animateScroll(t);
847     checkSoftLanding(0);
848 }
849
850 TEST_F(ScrollAnimatorNoneTest, ScrollDownToBumperCoast)
851 {
852     ScrollAnimatorNone::Parameters parameters(true, 11 * kTickTime, 2 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 1);
853
854     m_currentPosition = 10000;
855     EXPECT_TRUE(updateDataFromParameters(1, 10000, 50000, kStartTime, &parameters));
856     bool result = true;
857     double t = kStartTime;
858     for (int i = 0; i < 10; ++i) {
859         t += kAnimationTime;
860         result = result && animateScroll(t);
861         updateDataFromParameters(1, 10000, 50000, t, &parameters);
862     }
863     checkDesiredPosition(50000);
864
865     t += kAnimationTime;
866     for (; result && t < kEndTime; t += kAnimationTime)
867         result = result && animateScroll(t);
868     checkSoftLanding(50000);
869 }
870
871 TEST_F(ScrollAnimatorNoneTest, VaryingInputsEquivalency)
872 {
873     ScrollAnimatorNone::Parameters parameters(true, 15 * kTickTime, 10 * kTickTime, ScrollAnimatorNone::Cubic, 5 * kTickTime, ScrollAnimatorNone::Cubic, 5 * kTickTime, ScrollAnimatorNone::Linear, 0);
874
875     reset();
876     EXPECT_TRUE(updateDataFromParameters(1, 300, 50000, kStartTime, &parameters));
877     SavePerAxisData dataSingle(*m_data);
878
879     reset();
880     EXPECT_TRUE(updateDataFromParameters(1, 150, 50000, kStartTime, &parameters));
881     EXPECT_TRUE(updateDataFromParameters(1, 150, 50000, kStartTime, &parameters));
882     SavePerAxisData dataDouble(*m_data);
883
884     reset();
885     EXPECT_TRUE(updateDataFromParameters(1, 100, 50000, kStartTime, &parameters));
886     EXPECT_TRUE(updateDataFromParameters(1, 100, 50000, kStartTime, &parameters));
887     EXPECT_TRUE(updateDataFromParameters(1, 100, 50000, kStartTime, &parameters));
888     SavePerAxisData dataTriple(*m_data);
889
890     reset();
891     EXPECT_TRUE(updateDataFromParameters(1, 50, 50000, kStartTime, &parameters));
892     EXPECT_TRUE(updateDataFromParameters(1, 50, 50000, kStartTime, &parameters));
893     EXPECT_TRUE(updateDataFromParameters(1, 50, 50000, kStartTime, &parameters));
894     EXPECT_TRUE(updateDataFromParameters(1, 50, 50000, kStartTime, &parameters));
895     EXPECT_TRUE(updateDataFromParameters(1, 50, 50000, kStartTime, &parameters));
896     EXPECT_TRUE(updateDataFromParameters(1, 50, 50000, kStartTime, &parameters));
897     SavePerAxisData dataMany(*m_data);
898
899     EXPECT_EQ(dataSingle, dataDouble);
900     EXPECT_EQ(dataSingle, dataTriple);
901     EXPECT_EQ(dataSingle, dataMany);
902 }
903
904 TEST_F(ScrollAnimatorNoneTest, VaryingInputsEquivalencyCoast)
905 {
906     ScrollAnimatorNone::Parameters parameters(true, 15 * kTickTime, 10 * kTickTime, ScrollAnimatorNone::Cubic, 5 * kTickTime, ScrollAnimatorNone::Cubic, 5 * kTickTime, ScrollAnimatorNone::Linear, 1);
907
908     reset();
909     updateDataFromParameters(1, 300, 50000, kStartTime, &parameters);
910     SavePerAxisData dataSingle(*m_data);
911
912     reset();
913     updateDataFromParameters(1, 150, 50000, kStartTime, &parameters);
914     updateDataFromParameters(1, 150, 50000, kStartTime, &parameters);
915     SavePerAxisData dataDouble(*m_data);
916
917     reset();
918     updateDataFromParameters(1, 100, 50000, kStartTime, &parameters);
919     updateDataFromParameters(1, 100, 50000, kStartTime, &parameters);
920     updateDataFromParameters(1, 100, 50000, kStartTime, &parameters);
921     SavePerAxisData dataTriple(*m_data);
922
923     reset();
924     updateDataFromParameters(1, 50, 50000, kStartTime, &parameters);
925     updateDataFromParameters(1, 50, 50000, kStartTime, &parameters);
926     updateDataFromParameters(1, 50, 50000, kStartTime, &parameters);
927     updateDataFromParameters(1, 50, 50000, kStartTime, &parameters);
928     updateDataFromParameters(1, 50, 50000, kStartTime, &parameters);
929     updateDataFromParameters(1, 50, 50000, kStartTime, &parameters);
930     SavePerAxisData dataMany(*m_data);
931
932     EXPECT_EQ(dataSingle, dataDouble);
933     EXPECT_EQ(dataSingle, dataTriple);
934     EXPECT_EQ(dataSingle, dataMany);
935 }
936
937 TEST_F(ScrollAnimatorNoneTest, VaryingInputsEquivalencyCoastLarge)
938 {
939     ScrollAnimatorNone::Parameters parameters(true, 15 * kTickTime, 10 * kTickTime, ScrollAnimatorNone::Cubic, 5 * kTickTime, ScrollAnimatorNone::Cubic, 5 * kTickTime, ScrollAnimatorNone::Linear, 1);
940
941     reset();
942     EXPECT_TRUE(updateDataFromParameters(1, 30000, 50000, kStartTime, &parameters));
943     SavePerAxisData dataSingle(*m_data);
944
945     reset();
946     EXPECT_TRUE(updateDataFromParameters(1, 15000, 50000, kStartTime, &parameters));
947     EXPECT_TRUE(updateDataFromParameters(1, 15000, 50000, kStartTime, &parameters));
948     SavePerAxisData dataDouble(*m_data);
949
950     reset();
951     EXPECT_TRUE(updateDataFromParameters(1, 10000, 50000, kStartTime, &parameters));
952     EXPECT_TRUE(updateDataFromParameters(1, 10000, 50000, kStartTime, &parameters));
953     EXPECT_TRUE(updateDataFromParameters(1, 10000, 50000, kStartTime, &parameters));
954     SavePerAxisData dataTriple(*m_data);
955
956     reset();
957     EXPECT_TRUE(updateDataFromParameters(1, 5000, 50000, kStartTime, &parameters));
958     EXPECT_TRUE(updateDataFromParameters(1, 5000, 50000, kStartTime, &parameters));
959     EXPECT_TRUE(updateDataFromParameters(1, 5000, 50000, kStartTime, &parameters));
960     EXPECT_TRUE(updateDataFromParameters(1, 5000, 50000, kStartTime, &parameters));
961     EXPECT_TRUE(updateDataFromParameters(1, 5000, 50000, kStartTime, &parameters));
962     EXPECT_TRUE(updateDataFromParameters(1, 5000, 50000, kStartTime, &parameters));
963     SavePerAxisData dataMany(*m_data);
964
965     EXPECT_EQ(dataSingle, dataDouble);
966     EXPECT_EQ(dataSingle, dataTriple);
967     EXPECT_EQ(dataSingle, dataMany);
968 }
969
970 TEST_F(ScrollAnimatorNoneTest, VaryingInputsEquivalencyCoastSteep)
971 {
972     ScrollAnimatorNone::Parameters parameters(true, 15 * kTickTime, 10 * kTickTime, ScrollAnimatorNone::Cubic, 5 * kTickTime, ScrollAnimatorNone::Cubic, 5 * kTickTime, ScrollAnimatorNone::Quadratic, 1);
973
974     reset();
975     EXPECT_TRUE(updateDataFromParameters(1, 30000, 50000, kStartTime, &parameters));
976     SavePerAxisData dataSingle(*m_data);
977
978     reset();
979     EXPECT_TRUE(updateDataFromParameters(1, 15000, 50000, kStartTime, &parameters));
980     EXPECT_TRUE(updateDataFromParameters(1, 15000, 50000, kStartTime, &parameters));
981     SavePerAxisData dataDouble(*m_data);
982
983     reset();
984     EXPECT_TRUE(updateDataFromParameters(1, 10000, 50000, kStartTime, &parameters));
985     EXPECT_TRUE(updateDataFromParameters(1, 10000, 50000, kStartTime, &parameters));
986     EXPECT_TRUE(updateDataFromParameters(1, 10000, 50000, kStartTime, &parameters));
987     SavePerAxisData dataTriple(*m_data);
988
989     reset();
990     EXPECT_TRUE(updateDataFromParameters(1, 5000, 50000, kStartTime, &parameters));
991     EXPECT_TRUE(updateDataFromParameters(1, 5000, 50000, kStartTime, &parameters));
992     EXPECT_TRUE(updateDataFromParameters(1, 5000, 50000, kStartTime, &parameters));
993     EXPECT_TRUE(updateDataFromParameters(1, 5000, 50000, kStartTime, &parameters));
994     EXPECT_TRUE(updateDataFromParameters(1, 5000, 50000, kStartTime, &parameters));
995     EXPECT_TRUE(updateDataFromParameters(1, 5000, 50000, kStartTime, &parameters));
996     SavePerAxisData dataMany(*m_data);
997
998     EXPECT_EQ(dataSingle, dataDouble);
999     EXPECT_EQ(dataSingle, dataTriple);
1000     EXPECT_EQ(dataSingle, dataMany);
1001 }
1002
1003 TEST_F(ScrollAnimatorNoneTest, ScrollStopInMiddle)
1004 {
1005     ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
1006
1007     EXPECT_TRUE(updateDataFromParameters(1, 40, 1000, kStartTime, &parameters));
1008     bool result = true;
1009     double t;
1010     for (t = kStartTime; result && t < kStartTime + 1.5 * kTickTime; t += kAnimationTime)
1011         result = animateScroll(t);
1012
1013     result = result && animateScroll(t);
1014     EXPECT_TRUE(result);
1015     double before = m_currentPosition;
1016     result = result && updateDataFromParameters(0, 0, 1000, t, &parameters);
1017     EXPECT_FALSE(result);
1018     result = result && animateScroll(t);
1019     double after = m_currentPosition;
1020     EXPECT_EQ(before, after);
1021     checkDesiredPosition(after);
1022 }
1023
1024 TEST_F(ScrollAnimatorNoneTest, ReverseInMiddle)
1025 {
1026     ScrollAnimatorNone::Parameters parameters(true, 7 * kTickTime, 0, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Cubic, 3 * kTickTime, ScrollAnimatorNone::Linear, 0);
1027
1028     EXPECT_TRUE(updateDataFromParameters(1, 40, 1000, kStartTime, &parameters));
1029     bool result = true;
1030     double t;
1031     for (t = kStartTime; result && t < kStartTime + 1.5 * kTickTime; t += kAnimationTime)
1032         result = animateScroll(t);
1033
1034     result = result && animateScroll(t);
1035     EXPECT_TRUE(result);
1036     double before = m_currentPosition;
1037     result = result && updateDataFromParameters(1, -10, 1000, t, &parameters);
1038     EXPECT_TRUE(result);
1039     result = result && animateScroll(t);
1040     double after = m_currentPosition;
1041     EXPECT_GE(before, after);
1042
1043     t += kAnimationTime;
1044     for (; result && t < kEndTime; t += kAnimationTime)
1045         result = result && animateScroll(t);
1046     EXPECT_GE(before, m_currentPosition);
1047 }
1048
1049 #endif // ENABLE(SMOOTH_SCROLLING)