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