| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2013, 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 are | |
| 6 * met: | |
| 7 * | |
| 8 * * Redistributions of source code must retain the above copyright | |
| 9 * notice, this list of conditions and the following disclaimer. | |
| 10 * * Redistributions in binary form must reproduce the above | |
| 11 * copyright notice, this list of conditions and the following disclaimer | |
| 12 * in the documentation and/or other materials provided with the | |
| 13 * distribution. | |
| 14 * * Neither the name of Google Inc. nor the names of its | |
| 15 * contributors may be used to endorse or promote products derived from | |
| 16 * this software without specific prior written permission. | |
| 17 * | |
| 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 29 */ | |
| 30 | |
| 31 #include "config.h" | |
| 32 #include "core/animation/TimedItem.h" | |
| 33 | |
| 34 #include <gtest/gtest.h> | |
| 35 | |
| 36 using namespace WebCore; | |
| 37 | |
| 38 namespace { | |
| 39 | |
| 40 class TestTimedItemEventDelegate : public TimedItem::EventDelegate { | |
| 41 public: | |
| 42 virtual void onEventCondition(const TimedItem* timedItem) OVERRIDE | |
| 43 { | |
| 44 m_eventTriggered = true; | |
| 45 | |
| 46 } | |
| 47 void reset() | |
| 48 { | |
| 49 m_eventTriggered = false; | |
| 50 } | |
| 51 bool eventTriggered() { return m_eventTriggered; } | |
| 52 | |
| 53 private: | |
| 54 bool m_eventTriggered; | |
| 55 }; | |
| 56 | |
| 57 class TestTimedItem : public TimedItem { | |
| 58 public: | |
| 59 static PassRefPtrWillBeRawPtr<TestTimedItem> create(const Timing& specified) | |
| 60 { | |
| 61 return adoptRefWillBeNoop(new TestTimedItem(specified, new TestTimedItem
EventDelegate())); | |
| 62 } | |
| 63 | |
| 64 void updateInheritedTime(double time) | |
| 65 { | |
| 66 updateInheritedTime(time, TimingUpdateForAnimationFrame); | |
| 67 } | |
| 68 | |
| 69 void updateInheritedTime(double time, TimingUpdateReason reason) | |
| 70 { | |
| 71 m_eventDelegate->reset(); | |
| 72 TimedItem::updateInheritedTime(time, reason); | |
| 73 } | |
| 74 | |
| 75 virtual void updateChildrenAndEffects() const OVERRIDE { } | |
| 76 void willDetach() { } | |
| 77 TestTimedItemEventDelegate* eventDelegate() { return m_eventDelegate; } | |
| 78 virtual double calculateTimeToEffectChange(bool forwards, double localTime,
double timeToNextIteration) const OVERRIDE | |
| 79 { | |
| 80 m_localTime = localTime; | |
| 81 m_timeToNextIteration = timeToNextIteration; | |
| 82 return -1; | |
| 83 } | |
| 84 double takeLocalTime() | |
| 85 { | |
| 86 const double result = m_localTime; | |
| 87 m_localTime = nullValue(); | |
| 88 return result; | |
| 89 } | |
| 90 | |
| 91 double takeTimeToNextIteration() | |
| 92 { | |
| 93 const double result = m_timeToNextIteration; | |
| 94 m_timeToNextIteration = nullValue(); | |
| 95 return result; | |
| 96 } | |
| 97 | |
| 98 private: | |
| 99 TestTimedItem(const Timing& specified, TestTimedItemEventDelegate* eventDele
gate) | |
| 100 : TimedItem(specified, adoptPtr(eventDelegate)) | |
| 101 , m_eventDelegate(eventDelegate) | |
| 102 { | |
| 103 } | |
| 104 | |
| 105 TestTimedItemEventDelegate* m_eventDelegate; | |
| 106 mutable double m_localTime; | |
| 107 mutable double m_timeToNextIteration; | |
| 108 }; | |
| 109 | |
| 110 TEST(AnimationTimedItemTest, Sanity) | |
| 111 { | |
| 112 Timing timing; | |
| 113 timing.iterationDuration = 2; | |
| 114 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 115 | |
| 116 EXPECT_EQ(0, timedItem->startTime()); | |
| 117 | |
| 118 timedItem->updateInheritedTime(0); | |
| 119 | |
| 120 EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase()); | |
| 121 EXPECT_TRUE(timedItem->isInPlay()); | |
| 122 EXPECT_TRUE(timedItem->isCurrent()); | |
| 123 EXPECT_TRUE(timedItem->isInEffect()); | |
| 124 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 125 EXPECT_EQ(0, timedItem->startTime()); | |
| 126 EXPECT_EQ(2, timedItem->activeDurationInternal()); | |
| 127 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 128 | |
| 129 timedItem->updateInheritedTime(1); | |
| 130 | |
| 131 EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase()); | |
| 132 EXPECT_TRUE(timedItem->isInPlay()); | |
| 133 EXPECT_TRUE(timedItem->isCurrent()); | |
| 134 EXPECT_TRUE(timedItem->isInEffect()); | |
| 135 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 136 EXPECT_EQ(0, timedItem->startTime()); | |
| 137 EXPECT_EQ(2, timedItem->activeDurationInternal()); | |
| 138 EXPECT_EQ(0.5, timedItem->timeFraction()); | |
| 139 | |
| 140 timedItem->updateInheritedTime(2); | |
| 141 | |
| 142 EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase()); | |
| 143 EXPECT_FALSE(timedItem->isInPlay()); | |
| 144 EXPECT_FALSE(timedItem->isCurrent()); | |
| 145 EXPECT_TRUE(timedItem->isInEffect()); | |
| 146 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 147 EXPECT_EQ(0, timedItem->startTime()); | |
| 148 EXPECT_EQ(2, timedItem->activeDurationInternal()); | |
| 149 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 150 | |
| 151 timedItem->updateInheritedTime(3); | |
| 152 | |
| 153 EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase()); | |
| 154 EXPECT_FALSE(timedItem->isInPlay()); | |
| 155 EXPECT_FALSE(timedItem->isCurrent()); | |
| 156 EXPECT_TRUE(timedItem->isInEffect()); | |
| 157 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 158 EXPECT_EQ(0, timedItem->startTime()); | |
| 159 EXPECT_EQ(2, timedItem->activeDurationInternal()); | |
| 160 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 161 } | |
| 162 | |
| 163 TEST(AnimationTimedItemTest, FillAuto) | |
| 164 { | |
| 165 Timing timing; | |
| 166 timing.iterationDuration = 1; | |
| 167 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 168 | |
| 169 timedItem->updateInheritedTime(-1); | |
| 170 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 171 | |
| 172 timedItem->updateInheritedTime(2); | |
| 173 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 174 } | |
| 175 | |
| 176 TEST(AnimationTimedItemTest, FillForwards) | |
| 177 { | |
| 178 Timing timing; | |
| 179 timing.iterationDuration = 1; | |
| 180 timing.fillMode = Timing::FillModeForwards; | |
| 181 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 182 | |
| 183 timedItem->updateInheritedTime(-1); | |
| 184 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 185 | |
| 186 timedItem->updateInheritedTime(2); | |
| 187 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 188 } | |
| 189 | |
| 190 TEST(AnimationTimedItemTest, FillBackwards) | |
| 191 { | |
| 192 Timing timing; | |
| 193 timing.iterationDuration = 1; | |
| 194 timing.fillMode = Timing::FillModeBackwards; | |
| 195 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 196 | |
| 197 timedItem->updateInheritedTime(-1); | |
| 198 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 199 | |
| 200 timedItem->updateInheritedTime(2); | |
| 201 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 202 } | |
| 203 | |
| 204 TEST(AnimationTimedItemTest, FillBoth) | |
| 205 { | |
| 206 Timing timing; | |
| 207 timing.iterationDuration = 1; | |
| 208 timing.fillMode = Timing::FillModeBoth; | |
| 209 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 210 | |
| 211 timedItem->updateInheritedTime(-1); | |
| 212 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 213 | |
| 214 timedItem->updateInheritedTime(2); | |
| 215 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 216 } | |
| 217 | |
| 218 TEST(AnimationTimedItemTest, StartDelay) | |
| 219 { | |
| 220 Timing timing; | |
| 221 timing.iterationDuration = 1; | |
| 222 timing.fillMode = Timing::FillModeForwards; | |
| 223 timing.startDelay = 0.5; | |
| 224 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 225 | |
| 226 timedItem->updateInheritedTime(0); | |
| 227 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 228 | |
| 229 timedItem->updateInheritedTime(0.5); | |
| 230 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 231 | |
| 232 timedItem->updateInheritedTime(1.5); | |
| 233 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 234 } | |
| 235 | |
| 236 TEST(AnimationTimedItemTest, ZeroIteration) | |
| 237 { | |
| 238 Timing timing; | |
| 239 timing.iterationDuration = 1; | |
| 240 timing.fillMode = Timing::FillModeForwards; | |
| 241 timing.iterationCount = 0; | |
| 242 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 243 | |
| 244 timedItem->updateInheritedTime(-1); | |
| 245 EXPECT_EQ(0, timedItem->activeDurationInternal()); | |
| 246 EXPECT_TRUE(isNull(timedItem->currentIteration())); | |
| 247 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 248 | |
| 249 timedItem->updateInheritedTime(0); | |
| 250 EXPECT_EQ(0, timedItem->activeDurationInternal()); | |
| 251 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 252 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 253 } | |
| 254 | |
| 255 TEST(AnimationTimedItemTest, InfiniteIteration) | |
| 256 { | |
| 257 Timing timing; | |
| 258 timing.iterationDuration = 1; | |
| 259 timing.fillMode = Timing::FillModeForwards; | |
| 260 timing.iterationCount = std::numeric_limits<double>::infinity(); | |
| 261 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 262 | |
| 263 timedItem->updateInheritedTime(-1); | |
| 264 EXPECT_TRUE(isNull(timedItem->currentIteration())); | |
| 265 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 266 | |
| 267 EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration
Internal()); | |
| 268 | |
| 269 timedItem->updateInheritedTime(0); | |
| 270 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 271 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 272 } | |
| 273 | |
| 274 TEST(AnimationTimedItemTest, Iteration) | |
| 275 { | |
| 276 Timing timing; | |
| 277 timing.iterationCount = 2; | |
| 278 timing.iterationDuration = 2; | |
| 279 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 280 | |
| 281 timedItem->updateInheritedTime(0); | |
| 282 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 283 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 284 | |
| 285 timedItem->updateInheritedTime(1); | |
| 286 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 287 EXPECT_EQ(0.5, timedItem->timeFraction()); | |
| 288 | |
| 289 timedItem->updateInheritedTime(2); | |
| 290 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 291 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 292 | |
| 293 timedItem->updateInheritedTime(2); | |
| 294 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 295 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 296 | |
| 297 timedItem->updateInheritedTime(5); | |
| 298 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 299 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 300 } | |
| 301 | |
| 302 TEST(AnimationTimedItemTest, IterationStart) | |
| 303 { | |
| 304 Timing timing; | |
| 305 timing.iterationStart = 1.2; | |
| 306 timing.iterationCount = 2.2; | |
| 307 timing.iterationDuration = 1; | |
| 308 timing.fillMode = Timing::FillModeBoth; | |
| 309 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 310 | |
| 311 timedItem->updateInheritedTime(-1); | |
| 312 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 313 EXPECT_NEAR(0.2, timedItem->timeFraction(), 0.000000000000001); | |
| 314 | |
| 315 timedItem->updateInheritedTime(0); | |
| 316 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 317 EXPECT_NEAR(0.2, timedItem->timeFraction(), 0.000000000000001); | |
| 318 | |
| 319 timedItem->updateInheritedTime(10); | |
| 320 EXPECT_EQ(3, timedItem->currentIteration()); | |
| 321 EXPECT_NEAR(0.4, timedItem->timeFraction(), 0.000000000000001); | |
| 322 } | |
| 323 | |
| 324 TEST(AnimationTimedItemTest, IterationAlternate) | |
| 325 { | |
| 326 Timing timing; | |
| 327 timing.iterationCount = 10; | |
| 328 timing.iterationDuration = 1; | |
| 329 timing.direction = Timing::PlaybackDirectionAlternate; | |
| 330 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 331 | |
| 332 timedItem->updateInheritedTime(0.75); | |
| 333 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 334 EXPECT_EQ(0.75, timedItem->timeFraction()); | |
| 335 | |
| 336 timedItem->updateInheritedTime(1.75); | |
| 337 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 338 EXPECT_EQ(0.25, timedItem->timeFraction()); | |
| 339 | |
| 340 timedItem->updateInheritedTime(2.75); | |
| 341 EXPECT_EQ(2, timedItem->currentIteration()); | |
| 342 EXPECT_EQ(0.75, timedItem->timeFraction()); | |
| 343 } | |
| 344 | |
| 345 TEST(AnimationTimedItemTest, IterationAlternateReverse) | |
| 346 { | |
| 347 Timing timing; | |
| 348 timing.iterationCount = 10; | |
| 349 timing.iterationDuration = 1; | |
| 350 timing.direction = Timing::PlaybackDirectionAlternateReverse; | |
| 351 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 352 | |
| 353 timedItem->updateInheritedTime(0.75); | |
| 354 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 355 EXPECT_EQ(0.25, timedItem->timeFraction()); | |
| 356 | |
| 357 timedItem->updateInheritedTime(1.75); | |
| 358 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 359 EXPECT_EQ(0.75, timedItem->timeFraction()); | |
| 360 | |
| 361 timedItem->updateInheritedTime(2.75); | |
| 362 EXPECT_EQ(2, timedItem->currentIteration()); | |
| 363 EXPECT_EQ(0.25, timedItem->timeFraction()); | |
| 364 } | |
| 365 | |
| 366 TEST(AnimationTimedItemTest, ZeroDurationSanity) | |
| 367 { | |
| 368 Timing timing; | |
| 369 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 370 | |
| 371 EXPECT_EQ(0, timedItem->startTime()); | |
| 372 | |
| 373 timedItem->updateInheritedTime(0); | |
| 374 | |
| 375 EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase()); | |
| 376 EXPECT_FALSE(timedItem->isInPlay()); | |
| 377 EXPECT_FALSE(timedItem->isCurrent()); | |
| 378 EXPECT_TRUE(timedItem->isInEffect()); | |
| 379 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 380 EXPECT_EQ(0, timedItem->startTime()); | |
| 381 EXPECT_EQ(0, timedItem->activeDurationInternal()); | |
| 382 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 383 | |
| 384 timedItem->updateInheritedTime(1); | |
| 385 | |
| 386 EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase()); | |
| 387 EXPECT_FALSE(timedItem->isInPlay()); | |
| 388 EXPECT_FALSE(timedItem->isCurrent()); | |
| 389 EXPECT_TRUE(timedItem->isInEffect()); | |
| 390 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 391 EXPECT_EQ(0, timedItem->startTime()); | |
| 392 EXPECT_EQ(0, timedItem->activeDurationInternal()); | |
| 393 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 394 } | |
| 395 | |
| 396 TEST(AnimationTimedItemTest, ZeroDurationFillForwards) | |
| 397 { | |
| 398 Timing timing; | |
| 399 timing.fillMode = Timing::FillModeForwards; | |
| 400 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 401 | |
| 402 timedItem->updateInheritedTime(-1); | |
| 403 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 404 | |
| 405 timedItem->updateInheritedTime(0); | |
| 406 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 407 | |
| 408 timedItem->updateInheritedTime(1); | |
| 409 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 410 } | |
| 411 | |
| 412 TEST(AnimationTimedItemTest, ZeroDurationFillBackwards) | |
| 413 { | |
| 414 Timing timing; | |
| 415 timing.fillMode = Timing::FillModeBackwards; | |
| 416 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 417 | |
| 418 timedItem->updateInheritedTime(-1); | |
| 419 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 420 | |
| 421 timedItem->updateInheritedTime(0); | |
| 422 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 423 | |
| 424 timedItem->updateInheritedTime(1); | |
| 425 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 426 } | |
| 427 | |
| 428 TEST(AnimationTimedItemTest, ZeroDurationFillBoth) | |
| 429 { | |
| 430 Timing timing; | |
| 431 timing.fillMode = Timing::FillModeBoth; | |
| 432 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 433 | |
| 434 timedItem->updateInheritedTime(-1); | |
| 435 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 436 | |
| 437 timedItem->updateInheritedTime(0); | |
| 438 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 439 | |
| 440 timedItem->updateInheritedTime(1); | |
| 441 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 442 } | |
| 443 | |
| 444 TEST(AnimationTimedItemTest, ZeroDurationStartDelay) | |
| 445 { | |
| 446 Timing timing; | |
| 447 timing.fillMode = Timing::FillModeForwards; | |
| 448 timing.startDelay = 0.5; | |
| 449 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 450 | |
| 451 timedItem->updateInheritedTime(0); | |
| 452 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 453 | |
| 454 timedItem->updateInheritedTime(0.5); | |
| 455 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 456 | |
| 457 timedItem->updateInheritedTime(1.5); | |
| 458 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 459 } | |
| 460 | |
| 461 TEST(AnimationTimedItemTest, ZeroDurationIterationStartAndCount) | |
| 462 { | |
| 463 Timing timing; | |
| 464 timing.iterationStart = 0.1; | |
| 465 timing.iterationCount = 0.2; | |
| 466 timing.fillMode = Timing::FillModeBoth; | |
| 467 timing.startDelay = 0.3; | |
| 468 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 469 | |
| 470 timedItem->updateInheritedTime(0); | |
| 471 EXPECT_EQ(0.1, timedItem->timeFraction()); | |
| 472 | |
| 473 timedItem->updateInheritedTime(0.3); | |
| 474 EXPECT_DOUBLE_EQ(0.3, timedItem->timeFraction()); | |
| 475 | |
| 476 timedItem->updateInheritedTime(1); | |
| 477 EXPECT_DOUBLE_EQ(0.3, timedItem->timeFraction()); | |
| 478 } | |
| 479 | |
| 480 // FIXME: Needs specification work. | |
| 481 TEST(AnimationTimedItemTest, ZeroDurationInfiniteIteration) | |
| 482 { | |
| 483 Timing timing; | |
| 484 timing.fillMode = Timing::FillModeForwards; | |
| 485 timing.iterationCount = std::numeric_limits<double>::infinity(); | |
| 486 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 487 | |
| 488 timedItem->updateInheritedTime(-1); | |
| 489 EXPECT_EQ(0, timedItem->activeDurationInternal()); | |
| 490 EXPECT_TRUE(isNull(timedItem->currentIteration())); | |
| 491 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 492 | |
| 493 timedItem->updateInheritedTime(0); | |
| 494 EXPECT_EQ(0, timedItem->activeDurationInternal()); | |
| 495 EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->currentIterati
on()); | |
| 496 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 497 } | |
| 498 | |
| 499 TEST(AnimationTimedItemTest, ZeroDurationIteration) | |
| 500 { | |
| 501 Timing timing; | |
| 502 timing.fillMode = Timing::FillModeForwards; | |
| 503 timing.iterationCount = 2; | |
| 504 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 505 | |
| 506 timedItem->updateInheritedTime(-1); | |
| 507 EXPECT_TRUE(isNull(timedItem->currentIteration())); | |
| 508 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 509 | |
| 510 timedItem->updateInheritedTime(0); | |
| 511 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 512 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 513 | |
| 514 timedItem->updateInheritedTime(1); | |
| 515 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 516 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 517 } | |
| 518 | |
| 519 TEST(AnimationTimedItemTest, ZeroDurationIterationStart) | |
| 520 { | |
| 521 Timing timing; | |
| 522 timing.iterationStart = 1.2; | |
| 523 timing.iterationCount = 2.2; | |
| 524 timing.fillMode = Timing::FillModeBoth; | |
| 525 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 526 | |
| 527 timedItem->updateInheritedTime(-1); | |
| 528 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 529 EXPECT_NEAR(0.2, timedItem->timeFraction(), 0.000000000000001); | |
| 530 | |
| 531 timedItem->updateInheritedTime(0); | |
| 532 EXPECT_EQ(3, timedItem->currentIteration()); | |
| 533 EXPECT_NEAR(0.4, timedItem->timeFraction(), 0.000000000000001); | |
| 534 | |
| 535 timedItem->updateInheritedTime(10); | |
| 536 EXPECT_EQ(3, timedItem->currentIteration()); | |
| 537 EXPECT_NEAR(0.4, timedItem->timeFraction(), 0.000000000000001); | |
| 538 } | |
| 539 | |
| 540 TEST(AnimationTimedItemTest, ZeroDurationIterationAlternate) | |
| 541 { | |
| 542 Timing timing; | |
| 543 timing.fillMode = Timing::FillModeForwards; | |
| 544 timing.iterationCount = 2; | |
| 545 timing.direction = Timing::PlaybackDirectionAlternate; | |
| 546 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 547 | |
| 548 timedItem->updateInheritedTime(-1); | |
| 549 EXPECT_TRUE(isNull(timedItem->currentIteration())); | |
| 550 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 551 | |
| 552 timedItem->updateInheritedTime(0); | |
| 553 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 554 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 555 | |
| 556 timedItem->updateInheritedTime(1); | |
| 557 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 558 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 559 } | |
| 560 | |
| 561 TEST(AnimationTimedItemTest, ZeroDurationIterationAlternateReverse) | |
| 562 { | |
| 563 Timing timing; | |
| 564 timing.fillMode = Timing::FillModeForwards; | |
| 565 timing.iterationCount = 2; | |
| 566 timing.direction = Timing::PlaybackDirectionAlternateReverse; | |
| 567 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 568 | |
| 569 timedItem->updateInheritedTime(-1); | |
| 570 EXPECT_TRUE(isNull(timedItem->currentIteration())); | |
| 571 EXPECT_TRUE(isNull(timedItem->timeFraction())); | |
| 572 | |
| 573 timedItem->updateInheritedTime(0); | |
| 574 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 575 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 576 | |
| 577 timedItem->updateInheritedTime(1); | |
| 578 EXPECT_EQ(1, timedItem->currentIteration()); | |
| 579 EXPECT_EQ(1, timedItem->timeFraction()); | |
| 580 } | |
| 581 | |
| 582 TEST(AnimationTimedItemTest, InfiniteDurationSanity) | |
| 583 { | |
| 584 Timing timing; | |
| 585 timing.iterationDuration = std::numeric_limits<double>::infinity(); | |
| 586 timing.iterationCount = 1; | |
| 587 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 588 | |
| 589 EXPECT_EQ(0, timedItem->startTime()); | |
| 590 | |
| 591 timedItem->updateInheritedTime(0); | |
| 592 | |
| 593 EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration
Internal()); | |
| 594 EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase()); | |
| 595 EXPECT_TRUE(timedItem->isInPlay()); | |
| 596 EXPECT_TRUE(timedItem->isCurrent()); | |
| 597 EXPECT_TRUE(timedItem->isInEffect()); | |
| 598 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 599 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 600 | |
| 601 timedItem->updateInheritedTime(1); | |
| 602 | |
| 603 EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration
Internal()); | |
| 604 EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase()); | |
| 605 EXPECT_TRUE(timedItem->isInPlay()); | |
| 606 EXPECT_TRUE(timedItem->isCurrent()); | |
| 607 EXPECT_TRUE(timedItem->isInEffect()); | |
| 608 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 609 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 610 } | |
| 611 | |
| 612 // FIXME: Needs specification work. | |
| 613 TEST(AnimationTimedItemTest, InfiniteDurationZeroIterations) | |
| 614 { | |
| 615 Timing timing; | |
| 616 timing.iterationDuration = std::numeric_limits<double>::infinity(); | |
| 617 timing.iterationCount = 0; | |
| 618 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 619 | |
| 620 EXPECT_EQ(0, timedItem->startTime()); | |
| 621 | |
| 622 timedItem->updateInheritedTime(0); | |
| 623 | |
| 624 EXPECT_EQ(0, timedItem->activeDurationInternal()); | |
| 625 EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase()); | |
| 626 EXPECT_FALSE(timedItem->isInPlay()); | |
| 627 EXPECT_FALSE(timedItem->isCurrent()); | |
| 628 EXPECT_TRUE(timedItem->isInEffect()); | |
| 629 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 630 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 631 | |
| 632 timedItem->updateInheritedTime(1); | |
| 633 | |
| 634 EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase()); | |
| 635 EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase()); | |
| 636 EXPECT_FALSE(timedItem->isInPlay()); | |
| 637 EXPECT_FALSE(timedItem->isCurrent()); | |
| 638 EXPECT_TRUE(timedItem->isInEffect()); | |
| 639 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 640 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 641 } | |
| 642 | |
| 643 TEST(AnimationTimedItemTest, InfiniteDurationInfiniteIterations) | |
| 644 { | |
| 645 Timing timing; | |
| 646 timing.iterationDuration = std::numeric_limits<double>::infinity(); | |
| 647 timing.iterationCount = std::numeric_limits<double>::infinity(); | |
| 648 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 649 | |
| 650 EXPECT_EQ(0, timedItem->startTime()); | |
| 651 | |
| 652 timedItem->updateInheritedTime(0); | |
| 653 | |
| 654 EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration
Internal()); | |
| 655 EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase()); | |
| 656 EXPECT_TRUE(timedItem->isInPlay()); | |
| 657 EXPECT_TRUE(timedItem->isCurrent()); | |
| 658 EXPECT_TRUE(timedItem->isInEffect()); | |
| 659 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 660 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 661 | |
| 662 timedItem->updateInheritedTime(1); | |
| 663 | |
| 664 EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration
Internal()); | |
| 665 EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase()); | |
| 666 EXPECT_TRUE(timedItem->isInPlay()); | |
| 667 EXPECT_TRUE(timedItem->isCurrent()); | |
| 668 EXPECT_TRUE(timedItem->isInEffect()); | |
| 669 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 670 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 671 } | |
| 672 | |
| 673 TEST(AnimationTimedItemTest, InfiniteDurationZeroPlaybackRate) | |
| 674 { | |
| 675 Timing timing; | |
| 676 timing.iterationDuration = std::numeric_limits<double>::infinity(); | |
| 677 timing.playbackRate = 0; | |
| 678 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 679 | |
| 680 EXPECT_EQ(0, timedItem->startTime()); | |
| 681 | |
| 682 timedItem->updateInheritedTime(0); | |
| 683 | |
| 684 EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration
Internal()); | |
| 685 EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase()); | |
| 686 EXPECT_TRUE(timedItem->isInPlay()); | |
| 687 EXPECT_TRUE(timedItem->isCurrent()); | |
| 688 EXPECT_TRUE(timedItem->isInEffect()); | |
| 689 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 690 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 691 | |
| 692 timedItem->updateInheritedTime(std::numeric_limits<double>::infinity()); | |
| 693 | |
| 694 EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration
Internal()); | |
| 695 EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase()); | |
| 696 EXPECT_FALSE(timedItem->isInPlay()); | |
| 697 EXPECT_FALSE(timedItem->isCurrent()); | |
| 698 EXPECT_TRUE(timedItem->isInEffect()); | |
| 699 EXPECT_EQ(0, timedItem->currentIteration()); | |
| 700 EXPECT_EQ(0, timedItem->timeFraction()); | |
| 701 } | |
| 702 | |
| 703 TEST(AnimationTimedItemTest, EndTime) | |
| 704 { | |
| 705 Timing timing; | |
| 706 timing.startDelay = 1; | |
| 707 timing.endDelay = 2; | |
| 708 timing.iterationDuration = 4; | |
| 709 timing.iterationCount = 2; | |
| 710 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 711 EXPECT_EQ(11, timedItem->endTimeInternal()); | |
| 712 } | |
| 713 | |
| 714 TEST(AnimationTimedItemTest, Events) | |
| 715 { | |
| 716 Timing timing; | |
| 717 timing.iterationDuration = 1; | |
| 718 timing.fillMode = Timing::FillModeForwards; | |
| 719 timing.iterationCount = 2; | |
| 720 timing.startDelay = 1; | |
| 721 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 722 | |
| 723 timedItem->updateInheritedTime(0.0, TimingUpdateOnDemand); | |
| 724 EXPECT_FALSE(timedItem->eventDelegate()->eventTriggered()); | |
| 725 | |
| 726 timedItem->updateInheritedTime(0.0, TimingUpdateForAnimationFrame); | |
| 727 EXPECT_TRUE(timedItem->eventDelegate()->eventTriggered()); | |
| 728 | |
| 729 timedItem->updateInheritedTime(1.5, TimingUpdateOnDemand); | |
| 730 EXPECT_FALSE(timedItem->eventDelegate()->eventTriggered()); | |
| 731 | |
| 732 timedItem->updateInheritedTime(1.5, TimingUpdateForAnimationFrame); | |
| 733 EXPECT_TRUE(timedItem->eventDelegate()->eventTriggered()); | |
| 734 | |
| 735 } | |
| 736 | |
| 737 TEST(AnimationTimedItemTest, TimeToEffectChange) | |
| 738 { | |
| 739 Timing timing; | |
| 740 timing.iterationDuration = 1; | |
| 741 timing.fillMode = Timing::FillModeForwards; | |
| 742 timing.iterationStart = 0.2; | |
| 743 timing.iterationCount = 2.5; | |
| 744 timing.startDelay = 1; | |
| 745 timing.direction = Timing::PlaybackDirectionAlternate; | |
| 746 RefPtrWillBeRawPtr<TestTimedItem> timedItem = TestTimedItem::create(timing); | |
| 747 | |
| 748 timedItem->updateInheritedTime(0); | |
| 749 EXPECT_EQ(0, timedItem->takeLocalTime()); | |
| 750 EXPECT_TRUE(std::isinf(timedItem->takeTimeToNextIteration())); | |
| 751 | |
| 752 // Normal iteration. | |
| 753 timedItem->updateInheritedTime(1.75); | |
| 754 EXPECT_EQ(1.75, timedItem->takeLocalTime()); | |
| 755 EXPECT_NEAR(0.05, timedItem->takeTimeToNextIteration(), 0.000000000000001); | |
| 756 | |
| 757 // Reverse iteration. | |
| 758 timedItem->updateInheritedTime(2.75); | |
| 759 EXPECT_EQ(2.75, timedItem->takeLocalTime()); | |
| 760 EXPECT_NEAR(0.05, timedItem->takeTimeToNextIteration(), 0.000000000000001); | |
| 761 | |
| 762 // Item ends before iteration finishes. | |
| 763 timedItem->updateInheritedTime(3.4); | |
| 764 EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase()); | |
| 765 EXPECT_EQ(3.4, timedItem->takeLocalTime()); | |
| 766 EXPECT_TRUE(std::isinf(timedItem->takeTimeToNextIteration())); | |
| 767 | |
| 768 // Item has finished. | |
| 769 timedItem->updateInheritedTime(3.5); | |
| 770 EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase()); | |
| 771 EXPECT_EQ(3.5, timedItem->takeLocalTime()); | |
| 772 EXPECT_TRUE(std::isinf(timedItem->takeTimeToNextIteration())); | |
| 773 } | |
| 774 | |
| 775 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 293893003:
Web Animations: Rename TimedItem to AnimationSource (Closed)
Base URL: svn://svn.chromium.org/blink/trunk