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