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