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