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