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