src/third_party/WebKit/Source/core/animation/TimedItemTest.cpp

   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, bool isFirstSample, TimedItem::Phase previousPhase, double previousIteration) OVERRIDE
  43     {
  44         m_eventTriggered = true;
  45         m_phaseChanged = previousPhase != timedItem->phase();
  46         m_iterationChanged = previousIteration != timedItem->currentIteration();
  47
  48     }
  49     void reset()
  50     {
  51         m_eventTriggered = false;
  52         m_phaseChanged = false;
  53         m_iterationChanged = false;
  54     }
  55     bool eventTriggered() { return m_eventTriggered; }
  56     bool phaseChanged() { return m_phaseChanged; }
  57     bool iterationChanged() { return m_iterationChanged; }
  58
  59 private:
  60     bool m_eventTriggered;
  61     bool m_phaseChanged;
  62     bool m_iterationChanged;
  63 };
  64
  65 class TestTimedItem : public TimedItem {
  66 public:
  67     static PassRefPtr<TestTimedItem> create(const Timing& specified)
  68     {
  69         return adoptRef(new TestTimedItem(specified, new TestTimedItemEventDelegate()));
  70     }
  71
  72     void updateInheritedTime(double time)
  73     {
  74         m_eventDelegate->reset();
  75         TimedItem::updateInheritedTime(time);
  76     }
  77
  78     virtual bool updateChildrenAndEffects() const OVERRIDE { return false; }
  79     void willDetach() { }
  80     TestTimedItemEventDelegate* eventDelegate() { return m_eventDelegate; }
  81     virtual double calculateTimeToEffectChange(bool forwards, double localTime, double timeToNextIteration) const OVERRIDE
  82     {
  83         m_localTime = localTime;
  84         m_timeToNextIteration = timeToNextIteration;
  85         return -1;
  86     }
  87     double takeLocalTime()
  88     {
  89         const double result = m_localTime;
  90         m_localTime = nullValue();
  91         return result;
  92     }
  93
  94     double takeTimeToNextIteration()
  95     {
  96         const double result = m_timeToNextIteration;
  97         m_timeToNextIteration = nullValue();
  98         return result;
  99     }
 100
 101 private:
 102     TestTimedItem(const Timing& specified, TestTimedItemEventDelegate* eventDelegate)
 103         : TimedItem(specified, adoptPtr(eventDelegate))
 104         , m_eventDelegate(eventDelegate)
 105     {
 106     }
 107
 108     TestTimedItemEventDelegate* m_eventDelegate;
 109     mutable double m_localTime;
 110     mutable double m_timeToNextIteration;
 111 };
 112
 113 TEST(AnimationTimedItemTest, Sanity)
 114 {
 115     Timing timing;
 116     timing.iterationDuration = 2;
 117     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 118
 119     EXPECT_EQ(0, timedItem->startTime());
 120
 121     timedItem->updateInheritedTime(0);
 122
 123     EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase());
 124     EXPECT_TRUE(timedItem->isInPlay());
 125     EXPECT_TRUE(timedItem->isCurrent());
 126     EXPECT_TRUE(timedItem->isInEffect());
 127     EXPECT_EQ(0, timedItem->currentIteration());
 128     EXPECT_EQ(0, timedItem->startTime());
 129     EXPECT_EQ(2, timedItem->activeDuration());
 130     EXPECT_EQ(0, timedItem->timeFraction());
 131
 132     timedItem->updateInheritedTime(1);
 133
 134     EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase());
 135     EXPECT_TRUE(timedItem->isInPlay());
 136     EXPECT_TRUE(timedItem->isCurrent());
 137     EXPECT_TRUE(timedItem->isInEffect());
 138     EXPECT_EQ(0, timedItem->currentIteration());
 139     EXPECT_EQ(0, timedItem->startTime());
 140     EXPECT_EQ(2, timedItem->activeDuration());
 141     EXPECT_EQ(0.5, timedItem->timeFraction());
 142
 143     timedItem->updateInheritedTime(2);
 144
 145     EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase());
 146     EXPECT_FALSE(timedItem->isInPlay());
 147     EXPECT_FALSE(timedItem->isCurrent());
 148     EXPECT_TRUE(timedItem->isInEffect());
 149     EXPECT_EQ(0, timedItem->currentIteration());
 150     EXPECT_EQ(0, timedItem->startTime());
 151     EXPECT_EQ(2, timedItem->activeDuration());
 152     EXPECT_EQ(1, timedItem->timeFraction());
 153
 154     timedItem->updateInheritedTime(3);
 155
 156     EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase());
 157     EXPECT_FALSE(timedItem->isInPlay());
 158     EXPECT_FALSE(timedItem->isCurrent());
 159     EXPECT_TRUE(timedItem->isInEffect());
 160     EXPECT_EQ(0, timedItem->currentIteration());
 161     EXPECT_EQ(0, timedItem->startTime());
 162     EXPECT_EQ(2, timedItem->activeDuration());
 163     EXPECT_EQ(1, timedItem->timeFraction());
 164 }
 165
 166 TEST(AnimationTimedItemTest, FillAuto)
 167 {
 168     Timing timing;
 169     timing.iterationDuration = 1;
 170     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 171
 172     timedItem->updateInheritedTime(-1);
 173     EXPECT_EQ(0, timedItem->timeFraction());
 174
 175     timedItem->updateInheritedTime(2);
 176     EXPECT_EQ(1, timedItem->timeFraction());
 177 }
 178
 179 TEST(AnimationTimedItemTest, FillForwards)
 180 {
 181     Timing timing;
 182     timing.iterationDuration = 1;
 183     timing.fillMode = Timing::FillModeForwards;
 184     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 185
 186     timedItem->updateInheritedTime(-1);
 187     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 188
 189     timedItem->updateInheritedTime(2);
 190     EXPECT_EQ(1, timedItem->timeFraction());
 191 }
 192
 193 TEST(AnimationTimedItemTest, FillBackwards)
 194 {
 195     Timing timing;
 196     timing.iterationDuration = 1;
 197     timing.fillMode = Timing::FillModeBackwards;
 198     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 199
 200     timedItem->updateInheritedTime(-1);
 201     EXPECT_EQ(0, timedItem->timeFraction());
 202
 203     timedItem->updateInheritedTime(2);
 204     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 205 }
 206
 207 TEST(AnimationTimedItemTest, FillBoth)
 208 {
 209     Timing timing;
 210     timing.iterationDuration = 1;
 211     timing.fillMode = Timing::FillModeBoth;
 212     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 213
 214     timedItem->updateInheritedTime(-1);
 215     EXPECT_EQ(0, timedItem->timeFraction());
 216
 217     timedItem->updateInheritedTime(2);
 218     EXPECT_EQ(1, timedItem->timeFraction());
 219 }
 220
 221 TEST(AnimationTimedItemTest, StartDelay)
 222 {
 223     Timing timing;
 224     timing.iterationDuration = 1;
 225     timing.fillMode = Timing::FillModeForwards;
 226     timing.startDelay = 0.5;
 227     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 228
 229     timedItem->updateInheritedTime(0);
 230     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 231
 232     timedItem->updateInheritedTime(0.5);
 233     EXPECT_EQ(0, timedItem->timeFraction());
 234
 235     timedItem->updateInheritedTime(1.5);
 236     EXPECT_EQ(1, timedItem->timeFraction());
 237 }
 238
 239 TEST(AnimationTimedItemTest, ZeroIteration)
 240 {
 241     Timing timing;
 242     timing.iterationDuration = 1;
 243     timing.fillMode = Timing::FillModeForwards;
 244     timing.iterationCount = 0;
 245     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 246
 247     timedItem->updateInheritedTime(-1);
 248     EXPECT_EQ(0, timedItem->activeDuration());
 249     EXPECT_TRUE(isNull(timedItem->currentIteration()));
 250     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 251
 252     timedItem->updateInheritedTime(0);
 253     EXPECT_EQ(0, timedItem->activeDuration());
 254     EXPECT_EQ(0, timedItem->currentIteration());
 255     EXPECT_EQ(0, timedItem->timeFraction());
 256 }
 257
 258 TEST(AnimationTimedItemTest, InfiniteIteration)
 259 {
 260     Timing timing;
 261     timing.iterationDuration = 1;
 262     timing.fillMode = Timing::FillModeForwards;
 263     timing.iterationCount = std::numeric_limits<double>::infinity();
 264     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 265
 266     timedItem->updateInheritedTime(-1);
 267     EXPECT_TRUE(isNull(timedItem->currentIteration()));
 268     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 269
 270     EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration());
 271
 272     timedItem->updateInheritedTime(0);
 273     EXPECT_EQ(0, timedItem->currentIteration());
 274     EXPECT_EQ(0, timedItem->timeFraction());
 275 }
 276
 277 TEST(AnimationTimedItemTest, Iteration)
 278 {
 279     Timing timing;
 280     timing.iterationCount = 2;
 281     timing.iterationDuration = 2;
 282     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 283
 284     timedItem->updateInheritedTime(0);
 285     EXPECT_EQ(0, timedItem->currentIteration());
 286     EXPECT_EQ(0, timedItem->timeFraction());
 287
 288     timedItem->updateInheritedTime(1);
 289     EXPECT_EQ(0, timedItem->currentIteration());
 290     EXPECT_EQ(0.5, timedItem->timeFraction());
 291
 292     timedItem->updateInheritedTime(2);
 293     EXPECT_EQ(1, timedItem->currentIteration());
 294     EXPECT_EQ(0, timedItem->timeFraction());
 295
 296     timedItem->updateInheritedTime(2);
 297     EXPECT_EQ(1, timedItem->currentIteration());
 298     EXPECT_EQ(0, timedItem->timeFraction());
 299
 300     timedItem->updateInheritedTime(5);
 301     EXPECT_EQ(1, timedItem->currentIteration());
 302     EXPECT_EQ(1, timedItem->timeFraction());
 303 }
 304
 305 TEST(AnimationTimedItemTest, IterationStart)
 306 {
 307     Timing timing;
 308     timing.iterationStart = 1.2;
 309     timing.iterationCount = 2.2;
 310     timing.iterationDuration = 1;
 311     timing.fillMode = Timing::FillModeBoth;
 312     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 313
 314     timedItem->updateInheritedTime(-1);
 315     EXPECT_EQ(1, timedItem->currentIteration());
 316     EXPECT_NEAR(0.2, timedItem->timeFraction(), 0.000000000000001);
 317
 318     timedItem->updateInheritedTime(0);
 319     EXPECT_EQ(1, timedItem->currentIteration());
 320     EXPECT_NEAR(0.2, timedItem->timeFraction(), 0.000000000000001);
 321
 322     timedItem->updateInheritedTime(10);
 323     EXPECT_EQ(3, timedItem->currentIteration());
 324     EXPECT_NEAR(0.4, timedItem->timeFraction(), 0.000000000000001);
 325 }
 326
 327 TEST(AnimationTimedItemTest, IterationAlternate)
 328 {
 329     Timing timing;
 330     timing.iterationCount = 10;
 331     timing.iterationDuration = 1;
 332     timing.direction = Timing::PlaybackDirectionAlternate;
 333     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 334
 335     timedItem->updateInheritedTime(0.75);
 336     EXPECT_EQ(0, timedItem->currentIteration());
 337     EXPECT_EQ(0.75, timedItem->timeFraction());
 338
 339     timedItem->updateInheritedTime(1.75);
 340     EXPECT_EQ(1, timedItem->currentIteration());
 341     EXPECT_EQ(0.25, timedItem->timeFraction());
 342
 343     timedItem->updateInheritedTime(2.75);
 344     EXPECT_EQ(2, timedItem->currentIteration());
 345     EXPECT_EQ(0.75, timedItem->timeFraction());
 346 }
 347
 348 TEST(AnimationTimedItemTest, IterationAlternateReverse)
 349 {
 350     Timing timing;
 351     timing.iterationCount = 10;
 352     timing.iterationDuration = 1;
 353     timing.direction = Timing::PlaybackDirectionAlternateReverse;
 354     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 355
 356     timedItem->updateInheritedTime(0.75);
 357     EXPECT_EQ(0, timedItem->currentIteration());
 358     EXPECT_EQ(0.25, timedItem->timeFraction());
 359
 360     timedItem->updateInheritedTime(1.75);
 361     EXPECT_EQ(1, timedItem->currentIteration());
 362     EXPECT_EQ(0.75, timedItem->timeFraction());
 363
 364     timedItem->updateInheritedTime(2.75);
 365     EXPECT_EQ(2, timedItem->currentIteration());
 366     EXPECT_EQ(0.25, timedItem->timeFraction());
 367 }
 368
 369 TEST(AnimationTimedItemTest, ZeroDurationSanity)
 370 {
 371     Timing timing;
 372     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 373
 374     EXPECT_EQ(0, timedItem->startTime());
 375
 376     timedItem->updateInheritedTime(0);
 377
 378     EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase());
 379     EXPECT_FALSE(timedItem->isInPlay());
 380     EXPECT_FALSE(timedItem->isCurrent());
 381     EXPECT_TRUE(timedItem->isInEffect());
 382     EXPECT_EQ(0, timedItem->currentIteration());
 383     EXPECT_EQ(0, timedItem->startTime());
 384     EXPECT_EQ(0, timedItem->activeDuration());
 385     EXPECT_EQ(1, timedItem->timeFraction());
 386
 387     timedItem->updateInheritedTime(1);
 388
 389     EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase());
 390     EXPECT_FALSE(timedItem->isInPlay());
 391     EXPECT_FALSE(timedItem->isCurrent());
 392     EXPECT_TRUE(timedItem->isInEffect());
 393     EXPECT_EQ(0, timedItem->currentIteration());
 394     EXPECT_EQ(0, timedItem->startTime());
 395     EXPECT_EQ(0, timedItem->activeDuration());
 396     EXPECT_EQ(1, timedItem->timeFraction());
 397 }
 398
 399 TEST(AnimationTimedItemTest, ZeroDurationFillForwards)
 400 {
 401     Timing timing;
 402     timing.fillMode = Timing::FillModeForwards;
 403     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 404
 405     timedItem->updateInheritedTime(-1);
 406     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 407
 408     timedItem->updateInheritedTime(0);
 409     EXPECT_EQ(1, timedItem->timeFraction());
 410
 411     timedItem->updateInheritedTime(1);
 412     EXPECT_EQ(1, timedItem->timeFraction());
 413 }
 414
 415 TEST(AnimationTimedItemTest, ZeroDurationFillBackwards)
 416 {
 417     Timing timing;
 418     timing.fillMode = Timing::FillModeBackwards;
 419     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 420
 421     timedItem->updateInheritedTime(-1);
 422     EXPECT_EQ(0, timedItem->timeFraction());
 423
 424     timedItem->updateInheritedTime(0);
 425     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 426
 427     timedItem->updateInheritedTime(1);
 428     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 429 }
 430
 431 TEST(AnimationTimedItemTest, ZeroDurationFillBoth)
 432 {
 433     Timing timing;
 434     timing.fillMode = Timing::FillModeBoth;
 435     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 436
 437     timedItem->updateInheritedTime(-1);
 438     EXPECT_EQ(0, timedItem->timeFraction());
 439
 440     timedItem->updateInheritedTime(0);
 441     EXPECT_EQ(1, timedItem->timeFraction());
 442
 443     timedItem->updateInheritedTime(1);
 444     EXPECT_EQ(1, timedItem->timeFraction());
 445 }
 446
 447 TEST(AnimationTimedItemTest, ZeroDurationStartDelay)
 448 {
 449     Timing timing;
 450     timing.fillMode = Timing::FillModeForwards;
 451     timing.startDelay = 0.5;
 452     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 453
 454     timedItem->updateInheritedTime(0);
 455     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 456
 457     timedItem->updateInheritedTime(0.5);
 458     EXPECT_EQ(1, timedItem->timeFraction());
 459
 460     timedItem->updateInheritedTime(1.5);
 461     EXPECT_EQ(1, timedItem->timeFraction());
 462 }
 463
 464 TEST(AnimationTimedItemTest, ZeroDurationIterationStartAndCount)
 465 {
 466     Timing timing;
 467     timing.iterationStart = 0.1;
 468     timing.iterationCount = 0.2;
 469     timing.fillMode = Timing::FillModeBoth;
 470     timing.startDelay = 0.3;
 471     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 472
 473     timedItem->updateInheritedTime(0);
 474     EXPECT_EQ(0.1, timedItem->timeFraction());
 475
 476     timedItem->updateInheritedTime(0.3);
 477     EXPECT_DOUBLE_EQ(0.3, timedItem->timeFraction());
 478
 479     timedItem->updateInheritedTime(1);
 480     EXPECT_DOUBLE_EQ(0.3, timedItem->timeFraction());
 481 }
 482
 483 // FIXME: Needs specification work.
 484 TEST(AnimationTimedItemTest, ZeroDurationInfiniteIteration)
 485 {
 486     Timing timing;
 487     timing.fillMode = Timing::FillModeForwards;
 488     timing.iterationCount = std::numeric_limits<double>::infinity();
 489     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 490
 491     timedItem->updateInheritedTime(-1);
 492     EXPECT_EQ(0, timedItem->activeDuration());
 493     EXPECT_TRUE(isNull(timedItem->currentIteration()));
 494     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 495
 496     timedItem->updateInheritedTime(0);
 497     EXPECT_EQ(0, timedItem->activeDuration());
 498     EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->currentIteration());
 499     EXPECT_EQ(1, timedItem->timeFraction());
 500 }
 501
 502 TEST(AnimationTimedItemTest, ZeroDurationIteration)
 503 {
 504     Timing timing;
 505     timing.fillMode = Timing::FillModeForwards;
 506     timing.iterationCount = 2;
 507     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 508
 509     timedItem->updateInheritedTime(-1);
 510     EXPECT_TRUE(isNull(timedItem->currentIteration()));
 511     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 512
 513     timedItem->updateInheritedTime(0);
 514     EXPECT_EQ(1, timedItem->currentIteration());
 515     EXPECT_EQ(1, timedItem->timeFraction());
 516
 517     timedItem->updateInheritedTime(1);
 518     EXPECT_EQ(1, timedItem->currentIteration());
 519     EXPECT_EQ(1, timedItem->timeFraction());
 520 }
 521
 522 TEST(AnimationTimedItemTest, ZeroDurationIterationStart)
 523 {
 524     Timing timing;
 525     timing.iterationStart = 1.2;
 526     timing.iterationCount = 2.2;
 527     timing.fillMode = Timing::FillModeBoth;
 528     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 529
 530     timedItem->updateInheritedTime(-1);
 531     EXPECT_EQ(1, timedItem->currentIteration());
 532     EXPECT_NEAR(0.2, timedItem->timeFraction(), 0.000000000000001);
 533
 534     timedItem->updateInheritedTime(0);
 535     EXPECT_EQ(3, timedItem->currentIteration());
 536     EXPECT_NEAR(0.4, timedItem->timeFraction(), 0.000000000000001);
 537
 538     timedItem->updateInheritedTime(10);
 539     EXPECT_EQ(3, timedItem->currentIteration());
 540     EXPECT_NEAR(0.4, timedItem->timeFraction(), 0.000000000000001);
 541 }
 542
 543 TEST(AnimationTimedItemTest, ZeroDurationIterationAlternate)
 544 {
 545     Timing timing;
 546     timing.fillMode = Timing::FillModeForwards;
 547     timing.iterationCount = 2;
 548     timing.direction = Timing::PlaybackDirectionAlternate;
 549     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 550
 551     timedItem->updateInheritedTime(-1);
 552     EXPECT_TRUE(isNull(timedItem->currentIteration()));
 553     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 554
 555     timedItem->updateInheritedTime(0);
 556     EXPECT_EQ(1, timedItem->currentIteration());
 557     EXPECT_EQ(0, timedItem->timeFraction());
 558
 559     timedItem->updateInheritedTime(1);
 560     EXPECT_EQ(1, timedItem->currentIteration());
 561     EXPECT_EQ(0, timedItem->timeFraction());
 562 }
 563
 564 TEST(AnimationTimedItemTest, ZeroDurationIterationAlternateReverse)
 565 {
 566     Timing timing;
 567     timing.fillMode = Timing::FillModeForwards;
 568     timing.iterationCount = 2;
 569     timing.direction = Timing::PlaybackDirectionAlternateReverse;
 570     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 571
 572     timedItem->updateInheritedTime(-1);
 573     EXPECT_TRUE(isNull(timedItem->currentIteration()));
 574     EXPECT_TRUE(isNull(timedItem->timeFraction()));
 575
 576     timedItem->updateInheritedTime(0);
 577     EXPECT_EQ(1, timedItem->currentIteration());
 578     EXPECT_EQ(1, timedItem->timeFraction());
 579
 580     timedItem->updateInheritedTime(1);
 581     EXPECT_EQ(1, timedItem->currentIteration());
 582     EXPECT_EQ(1, timedItem->timeFraction());
 583 }
 584
 585 TEST(AnimationTimedItemTest, InfiniteDurationSanity)
 586 {
 587     Timing timing;
 588     timing.iterationDuration = std::numeric_limits<double>::infinity();
 589     timing.iterationCount = 1;
 590     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 591
 592     EXPECT_EQ(0, timedItem->startTime());
 593
 594     timedItem->updateInheritedTime(0);
 595
 596     EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration());
 597     EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase());
 598     EXPECT_TRUE(timedItem->isInPlay());
 599     EXPECT_TRUE(timedItem->isCurrent());
 600     EXPECT_TRUE(timedItem->isInEffect());
 601     EXPECT_EQ(0, timedItem->currentIteration());
 602     EXPECT_EQ(0, timedItem->timeFraction());
 603
 604     timedItem->updateInheritedTime(1);
 605
 606     EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration());
 607     EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase());
 608     EXPECT_TRUE(timedItem->isInPlay());
 609     EXPECT_TRUE(timedItem->isCurrent());
 610     EXPECT_TRUE(timedItem->isInEffect());
 611     EXPECT_EQ(0, timedItem->currentIteration());
 612     EXPECT_EQ(0, timedItem->timeFraction());
 613 }
 614
 615 // FIXME: Needs specification work.
 616 TEST(AnimationTimedItemTest, InfiniteDurationZeroIterations)
 617 {
 618     Timing timing;
 619     timing.iterationDuration = std::numeric_limits<double>::infinity();
 620     timing.iterationCount = 0;
 621     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 622
 623     EXPECT_EQ(0, timedItem->startTime());
 624
 625     timedItem->updateInheritedTime(0);
 626
 627     EXPECT_EQ(0, timedItem->activeDuration());
 628     EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase());
 629     EXPECT_FALSE(timedItem->isInPlay());
 630     EXPECT_FALSE(timedItem->isCurrent());
 631     EXPECT_TRUE(timedItem->isInEffect());
 632     EXPECT_EQ(0, timedItem->currentIteration());
 633     EXPECT_EQ(0, timedItem->timeFraction());
 634
 635     timedItem->updateInheritedTime(1);
 636
 637     EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase());
 638     EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase());
 639     EXPECT_FALSE(timedItem->isInPlay());
 640     EXPECT_FALSE(timedItem->isCurrent());
 641     EXPECT_TRUE(timedItem->isInEffect());
 642     EXPECT_EQ(0, timedItem->currentIteration());
 643     EXPECT_EQ(0, timedItem->timeFraction());
 644 }
 645
 646 TEST(AnimationTimedItemTest, InfiniteDurationInfiniteIterations)
 647 {
 648     Timing timing;
 649     timing.iterationDuration = std::numeric_limits<double>::infinity();
 650     timing.iterationCount = std::numeric_limits<double>::infinity();
 651     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 652
 653     EXPECT_EQ(0, timedItem->startTime());
 654
 655     timedItem->updateInheritedTime(0);
 656
 657     EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration());
 658     EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase());
 659     EXPECT_TRUE(timedItem->isInPlay());
 660     EXPECT_TRUE(timedItem->isCurrent());
 661     EXPECT_TRUE(timedItem->isInEffect());
 662     EXPECT_EQ(0, timedItem->currentIteration());
 663     EXPECT_EQ(0, timedItem->timeFraction());
 664
 665     timedItem->updateInheritedTime(1);
 666
 667     EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration());
 668     EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase());
 669     EXPECT_TRUE(timedItem->isInPlay());
 670     EXPECT_TRUE(timedItem->isCurrent());
 671     EXPECT_TRUE(timedItem->isInEffect());
 672     EXPECT_EQ(0, timedItem->currentIteration());
 673     EXPECT_EQ(0, timedItem->timeFraction());
 674 }
 675
 676 TEST(AnimationTimedItemTest, InfiniteDurationZeroPlaybackRate)
 677 {
 678     Timing timing;
 679     timing.iterationDuration = std::numeric_limits<double>::infinity();
 680     timing.playbackRate = 0;
 681     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 682
 683     EXPECT_EQ(0, timedItem->startTime());
 684
 685     timedItem->updateInheritedTime(0);
 686
 687     EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration());
 688     EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase());
 689     EXPECT_TRUE(timedItem->isInPlay());
 690     EXPECT_TRUE(timedItem->isCurrent());
 691     EXPECT_TRUE(timedItem->isInEffect());
 692     EXPECT_EQ(0, timedItem->currentIteration());
 693     EXPECT_EQ(0, timedItem->timeFraction());
 694
 695     timedItem->updateInheritedTime(std::numeric_limits<double>::infinity());
 696
 697     EXPECT_EQ(std::numeric_limits<double>::infinity(), timedItem->activeDuration());
 698     EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase());
 699     EXPECT_FALSE(timedItem->isInPlay());
 700     EXPECT_FALSE(timedItem->isCurrent());
 701     EXPECT_TRUE(timedItem->isInEffect());
 702     EXPECT_EQ(0, timedItem->currentIteration());
 703     EXPECT_EQ(0, timedItem->timeFraction());
 704 }
 705
 706 TEST(AnimationTimedItemTest, EndTime)
 707 {
 708     Timing timing;
 709     timing.startDelay = 1;
 710     timing.endDelay = 2;
 711     timing.iterationDuration = 4;
 712     timing.iterationCount = 2;
 713     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 714     EXPECT_EQ(11, timedItem->endTime());
 715 }
 716
 717 TEST(AnimationTimedItemTest, Events)
 718 {
 719     Timing timing;
 720     timing.iterationDuration = 1;
 721     timing.fillMode = Timing::FillModeForwards;
 722     timing.iterationCount = 2;
 723     timing.startDelay = 1;
 724     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 725
 726     // First sample
 727     timedItem->updateInheritedTime(0.0);
 728     EXPECT_TRUE(timedItem->eventDelegate()->eventTriggered());
 729
 730     // Before start
 731     timedItem->updateInheritedTime(0.5);
 732     EXPECT_FALSE(timedItem->eventDelegate()->eventTriggered());
 733
 734     // First iteration
 735     timedItem->updateInheritedTime(1.5);
 736     EXPECT_TRUE(timedItem->eventDelegate()->eventTriggered());
 737     EXPECT_TRUE(timedItem->eventDelegate()->phaseChanged());
 738     EXPECT_TRUE(timedItem->eventDelegate()->iterationChanged());
 739
 740     timedItem->updateInheritedTime(1.6);
 741     EXPECT_FALSE(timedItem->eventDelegate()->eventTriggered());
 742
 743     // Second iteration
 744     timedItem->updateInheritedTime(2.5);
 745     EXPECT_TRUE(timedItem->eventDelegate()->eventTriggered());
 746     EXPECT_FALSE(timedItem->eventDelegate()->phaseChanged());
 747     EXPECT_TRUE(timedItem->eventDelegate()->iterationChanged());
 748
 749     timedItem->updateInheritedTime(2.6);
 750     EXPECT_FALSE(timedItem->eventDelegate()->eventTriggered());
 751
 752     // After end
 753     timedItem->updateInheritedTime(3.5);
 754     EXPECT_TRUE(timedItem->eventDelegate()->eventTriggered());
 755     EXPECT_TRUE(timedItem->eventDelegate()->phaseChanged());
 756     EXPECT_FALSE(timedItem->eventDelegate()->iterationChanged());
 757
 758     timedItem->updateInheritedTime(3.6);
 759     EXPECT_FALSE(timedItem->eventDelegate()->eventTriggered());
 760 }
 761
 762 TEST(AnimationTimedItemTest, TimeToEffectChange)
 763 {
 764     Timing timing;
 765     timing.iterationDuration = 1;
 766     timing.fillMode = Timing::FillModeForwards;
 767     timing.iterationStart = 0.2;
 768     timing.iterationCount = 2.5;
 769     timing.startDelay = 1;
 770     timing.direction = Timing::PlaybackDirectionAlternate;
 771     RefPtr<TestTimedItem> timedItem = TestTimedItem::create(timing);
 772
 773     timedItem->updateInheritedTime(0);
 774     EXPECT_EQ(0, timedItem->takeLocalTime());
 775     EXPECT_TRUE(std::isinf(timedItem->takeTimeToNextIteration()));
 776
 777     // Normal iteration.
 778     timedItem->updateInheritedTime(1.75);
 779     EXPECT_EQ(1.75, timedItem->takeLocalTime());
 780     EXPECT_NEAR(0.05, timedItem->takeTimeToNextIteration(), 0.000000000000001);
 781
 782     // Reverse iteration.
 783     timedItem->updateInheritedTime(2.75);
 784     EXPECT_EQ(2.75, timedItem->takeLocalTime());
 785     EXPECT_NEAR(0.05, timedItem->takeTimeToNextIteration(), 0.000000000000001);
 786
 787     // Item ends before iteration finishes.
 788     timedItem->updateInheritedTime(3.4);
 789     EXPECT_EQ(TimedItem::PhaseActive, timedItem->phase());
 790     EXPECT_EQ(3.4, timedItem->takeLocalTime());
 791     EXPECT_TRUE(std::isinf(timedItem->takeTimeToNextIteration()));
 792
 793     // Item has finished.
 794     timedItem->updateInheritedTime(3.5);
 795     EXPECT_EQ(TimedItem::PhaseAfter, timedItem->phase());
 796     EXPECT_EQ(3.5, timedItem->takeLocalTime());
 797     EXPECT_TRUE(std::isinf(timedItem->takeTimeToNextIteration()));
 798 }
 799
 800 }