src/third_party/WebKit/Source/core/animation/TimedItemCalculationsTest.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/TimedItemCalculations.h"
  33
  34 #include <gtest/gtest.h>
  35
  36 using namespace WebCore;
  37
  38 namespace {
  39
  40 TEST(AnimationTimedItemCalculationsTest, ActiveTime)
  41 {
  42     Timing timing;
  43
  44     // calculateActiveTime(activeDuration, localTime, parentPhase, phase, timing)
  45
  46     // Before Phase
  47     timing.startDelay = 10;
  48     timing.fillMode = Timing::FillModeForwards;
  49     EXPECT_TRUE(isNull(calculateActiveTime(20, 0, TimedItem::PhaseActive, TimedItem::PhaseBefore, timing)));
  50     timing.fillMode = Timing::FillModeNone;
  51     EXPECT_TRUE(isNull(calculateActiveTime(20, 0, TimedItem::PhaseActive, TimedItem::PhaseBefore, timing)));
  52     timing.fillMode = Timing::FillModeBackwards;
  53     EXPECT_EQ(0, calculateActiveTime(20, 0, TimedItem::PhaseActive, TimedItem::PhaseBefore, timing));
  54     timing.fillMode = Timing::FillModeBoth;
  55     EXPECT_EQ(0, calculateActiveTime(20, 0, TimedItem::PhaseActive, TimedItem::PhaseBefore, timing));
  56
  57     // Active Phase
  58     timing.startDelay = 10;
  59     // Active, and parent Before
  60     timing.fillMode = Timing::FillModeNone;
  61     EXPECT_TRUE(isNull(calculateActiveTime(20, 15, TimedItem::PhaseBefore, TimedItem::PhaseActive, timing)));
  62     timing.fillMode = Timing::FillModeForwards;
  63     EXPECT_TRUE(isNull(calculateActiveTime(20, 15, TimedItem::PhaseBefore, TimedItem::PhaseActive, timing)));
  64     // Active, and parent After
  65     timing.fillMode = Timing::FillModeNone;
  66     EXPECT_TRUE(isNull(calculateActiveTime(20, 15, TimedItem::PhaseAfter, TimedItem::PhaseActive, timing)));
  67     timing.fillMode = Timing::FillModeBackwards;
  68     EXPECT_TRUE(isNull(calculateActiveTime(20, 15, TimedItem::PhaseAfter, TimedItem::PhaseActive, timing)));
  69     // Active, and parent Active
  70     timing.fillMode = Timing::FillModeForwards;
  71     EXPECT_EQ(5, calculateActiveTime(20, 15, TimedItem::PhaseActive, TimedItem::PhaseActive, timing));
  72
  73     // After Phase
  74     timing.startDelay = 10;
  75     timing.fillMode = Timing::FillModeForwards;
  76     EXPECT_EQ(21, calculateActiveTime(21, 45, TimedItem::PhaseActive, TimedItem::PhaseAfter, timing));
  77     timing.fillMode = Timing::FillModeBoth;
  78     EXPECT_EQ(21, calculateActiveTime(21, 45, TimedItem::PhaseActive, TimedItem::PhaseAfter, timing));
  79     timing.fillMode = Timing::FillModeBackwards;
  80     EXPECT_TRUE(isNull(calculateActiveTime(21, 45, TimedItem::PhaseActive, TimedItem::PhaseAfter, timing)));
  81     timing.fillMode = Timing::FillModeNone;
  82     EXPECT_TRUE(isNull(calculateActiveTime(21, 45, TimedItem::PhaseActive, TimedItem::PhaseAfter, timing)));
  83
  84     // None
  85     EXPECT_TRUE(isNull(calculateActiveTime(32, nullValue(), TimedItem::PhaseNone, TimedItem::PhaseNone, timing)));
  86 }
  87
  88 TEST(AnimationTimedItemCalculationsTest, ScaledActiveTime)
  89 {
  90     Timing timing;
  91
  92     // calculateScaledActiveTime(activeDuration, activeTime, startOffset, timing)
  93
  94     // if the active time is null
  95     EXPECT_TRUE(isNull(calculateScaledActiveTime(4, nullValue(), 5, timing)));
  96
  97     // if the playback rate is negative
  98     timing.playbackRate = -1;
  99     EXPECT_EQ(35, calculateScaledActiveTime(40, 10, 5, timing));
 100
 101     // otherwise
 102     timing.playbackRate = 0;
 103     EXPECT_EQ(5, calculateScaledActiveTime(40, 10, 5, timing));
 104     timing.playbackRate = 1;
 105     EXPECT_EQ(15, calculateScaledActiveTime(40, 10, 5, timing));
 106
 107     // infinte activeTime
 108     timing.playbackRate = 0;
 109     EXPECT_EQ(0, calculateScaledActiveTime(std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), 0, timing));
 110     timing.playbackRate = 1;
 111     EXPECT_EQ(std::numeric_limits<double>::infinity(), calculateScaledActiveTime(std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), 0, timing));
 112 }
 113
 114 TEST(AnimationTimedItemCalculationsTest, IterationTime)
 115 {
 116     Timing timing;
 117
 118     // calculateIterationTime(iterationDuration, repeatedDuration, scaledActiveTime, startOffset, timing)
 119
 120     // if the scaled active time is null
 121     EXPECT_TRUE(isNull(calculateIterationTime(1, 1, nullValue(), 1, timing)));
 122
 123     // if (complex-conditions)...
 124     EXPECT_EQ(12, calculateIterationTime(12, 12, 12, 0, timing));
 125
 126     // otherwise
 127     timing.iterationCount = 10;
 128     EXPECT_EQ(5, calculateIterationTime(10, 100, 25, 4, timing));
 129     EXPECT_EQ(7, calculateIterationTime(11, 110, 29, 1, timing));
 130     timing.iterationStart = 1.1;
 131     EXPECT_EQ(8, calculateIterationTime(12, 120, 20, 7, timing));
 132 }
 133
 134 TEST(AnimationTimedItemCalculationsTest, CurrentIteration)
 135 {
 136     Timing timing;
 137
 138     // calculateCurrentIteration(iterationDuration, iterationTime, scaledActiveTime, timing)
 139
 140     // if the scaled active time is null
 141     EXPECT_TRUE(isNull(calculateCurrentIteration(1, 1, nullValue(), timing)));
 142
 143     // if the scaled active time is zero
 144     EXPECT_EQ(0, calculateCurrentIteration(1, 1, 0, timing));
 145
 146     // if the iteration time equals the iteration duration
 147     timing.iterationStart = 4;
 148     timing.iterationCount = 7;
 149     EXPECT_EQ(10, calculateCurrentIteration(5, 5, 9, timing));
 150
 151     // otherwise
 152     EXPECT_EQ(3, calculateCurrentIteration(3.2, 3.1, 10, timing));
 153 }
 154
 155 TEST(AnimationTimedItemCalculationsTest, DirectedTime)
 156 {
 157     Timing timing;
 158
 159     // calculateDirectedTime(currentIteration, iterationDuration, iterationTime, timing)
 160
 161     // if the iteration time is null
 162     EXPECT_TRUE(isNull(calculateDirectedTime(1, 2, nullValue(), timing)));
 163
 164     // forwards
 165     EXPECT_EQ(17, calculateDirectedTime(0, 20, 17, timing));
 166     EXPECT_EQ(17, calculateDirectedTime(1, 20, 17, timing));
 167     timing.direction = Timing::PlaybackDirectionAlternate;
 168     EXPECT_EQ(17, calculateDirectedTime(0, 20, 17, timing));
 169     EXPECT_EQ(17, calculateDirectedTime(2, 20, 17, timing));
 170     timing.direction = Timing::PlaybackDirectionAlternateReverse;
 171     EXPECT_EQ(17, calculateDirectedTime(1, 20, 17, timing));
 172     EXPECT_EQ(17, calculateDirectedTime(3, 20, 17, timing));
 173
 174     // reverse
 175     timing.direction = Timing::PlaybackDirectionReverse;
 176     EXPECT_EQ(3, calculateDirectedTime(0, 20, 17, timing));
 177     EXPECT_EQ(3, calculateDirectedTime(1, 20, 17, timing));
 178     timing.direction = Timing::PlaybackDirectionAlternate;
 179     EXPECT_EQ(3, calculateDirectedTime(1, 20, 17, timing));
 180     EXPECT_EQ(3, calculateDirectedTime(3, 20, 17, timing));
 181     timing.direction = Timing::PlaybackDirectionAlternateReverse;
 182     EXPECT_EQ(3, calculateDirectedTime(0, 20, 17, timing));
 183     EXPECT_EQ(3, calculateDirectedTime(2, 20, 17, timing));
 184 }
 185
 186 TEST(AnimationTimedItemCalculationsTest, TransformedTime)
 187 {
 188     Timing timing;
 189
 190     // calculateTransformedTime(currentIteration, iterationDuration, iterationTime, timing)
 191
 192     // Iteration time is null
 193     EXPECT_TRUE(isNull(calculateTransformedTime(1, 2, nullValue(), timing)));
 194
 195     // PlaybackDirectionForwards
 196     EXPECT_EQ(12, calculateTransformedTime(0, 20, 12, timing));
 197     EXPECT_EQ(12, calculateTransformedTime(1, 20, 12, timing));
 198
 199     // PlaybackDirectionForwards with timing function
 200     timing.timingFunction = StepsTimingFunction::create(4, false /* stepAtStart */);
 201     EXPECT_EQ(10, calculateTransformedTime(0, 20, 12, timing));
 202     EXPECT_EQ(10, calculateTransformedTime(1, 20, 12, timing));
 203
 204     // PlaybackDirectionReverse
 205     timing.timingFunction = 0;
 206     timing.direction = Timing::PlaybackDirectionReverse;
 207     EXPECT_EQ(8, calculateTransformedTime(0, 20, 12, timing));
 208     EXPECT_EQ(8, calculateTransformedTime(1, 20, 12, timing));
 209
 210     // PlaybackDirectionReverse with timing function
 211     timing.timingFunction = StepsTimingFunction::create(4, false /* stepAtStart */);
 212     EXPECT_EQ(5, calculateTransformedTime(0, 20, 12, timing));
 213     EXPECT_EQ(5, calculateTransformedTime(1, 20, 12, timing));
 214
 215     // Timing function when directed time is null.
 216     EXPECT_TRUE(isNull(calculateTransformedTime(1, 2, nullValue(), timing)));
 217
 218     // Timing function when iterationDuration is infinity
 219     timing.direction = Timing::PlaybackDirectionNormal;
 220     EXPECT_EQ(0, calculateTransformedTime(0, std::numeric_limits<double>::infinity(), 0, timing));
 221     EXPECT_EQ(1, calculateTransformedTime(0, std::numeric_limits<double>::infinity(), 1, timing));
 222     timing.direction = Timing::PlaybackDirectionReverse;
 223     EXPECT_EQ(std::numeric_limits<double>::infinity(), calculateTransformedTime(0, std::numeric_limits<double>::infinity(), 0, timing));
 224     EXPECT_EQ(std::numeric_limits<double>::infinity(), calculateTransformedTime(0, std::numeric_limits<double>::infinity(), 1, timing));
 225 }
 226
 227 }