| <!doctype html> |
| <meta charset=utf-8> |
| <script src="../../../resources/testharness.js"></script> |
| <script src="../../../resources/testharnessreport.js"></script> |
| <script src="../resources/testcommon.js"></script> |
| <style> |
| @keyframes moveAnimation { |
| from { margin-left: 100px } |
| to { margin-left: 200px } |
| } |
| </style> |
| <body> |
| <div id="log"></div> |
| <script> |
| |
| 'use strict'; |
| |
| // -------------------- |
| // delay |
| // -------------------- |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().delay, 0, |
| 'Initial value of delay'); |
| }, 'delay of a new animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s -10s'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().delay, -10 * MS_PER_SEC, |
| 'Initial value of delay'); |
| }, 'Negative delay of a new animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s 10s'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().delay, 10 * MS_PER_SEC, |
| 'Initial value of delay'); |
| }, 'Positive delay of a new animation'); |
| |
| |
| // -------------------- |
| // endDelay |
| // -------------------- |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().endDelay, 0, |
| 'Initial value of endDelay'); |
| }, 'endDelay of a new animation'); |
| |
| |
| // -------------------- |
| // fill |
| // -------------------- |
| test(function(t) { |
| var getEffectWithFill = function(fill) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s ' + fill}); |
| return div.getAnimations()[0].effect; |
| }; |
| |
| var effect = getEffectWithFill(''); |
| assert_equals(effect.getComputedTiming().fill, 'none', |
| 'Initial value of fill'); |
| effect = getEffectWithFill('forwards'); |
| assert_equals(effect.getComputedTiming().fill, 'forwards', |
| 'Fill forwards'); |
| effect = getEffectWithFill('backwards'); |
| assert_equals(effect.getComputedTiming().fill, 'backwards', |
| 'Fill backwards'); |
| effect = getEffectWithFill('both'); |
| assert_equals(effect.getComputedTiming().fill, 'both', |
| 'Fill forwards and backwards'); |
| }, 'fill of a new animation'); |
| |
| |
| // -------------------- |
| // iterationStart |
| // -------------------- |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().iterationStart, 0, |
| 'Initial value of iterationStart'); |
| }, 'iterationStart of a new animation'); |
| |
| |
| // -------------------- |
| // iterations |
| // -------------------- |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().iterations, 1, |
| 'Initial value of iterations'); |
| }, 'iterations of a new animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s 2016.5'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().iterations, 2016.5, |
| 'Initial value of iterations'); |
| }, 'iterations of a finitely repeating animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s infinite'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().iterations, Infinity, |
| 'Initial value of iterations'); |
| }, 'iterations of an infinitely repeating animation'); |
| |
| |
| // -------------------- |
| // duration |
| // -------------------- |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s -10s infinite'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().duration, 100 * MS_PER_SEC, |
| 'Initial value of duration'); |
| }, 'duration of a new animation'); |
| |
| |
| // -------------------- |
| // direction |
| // -------------------- |
| test(function(t) { |
| var getEffectWithDir = function(dir) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s ' + dir}); |
| return div.getAnimations()[0].effect; |
| }; |
| |
| var effect = getEffectWithDir(''); |
| assert_equals(effect.getComputedTiming().direction, 'normal', |
| 'Initial value of normal direction'); |
| effect = getEffectWithDir('reverse'); |
| assert_equals(effect.getComputedTiming().direction, 'reverse', |
| 'Initial value of reverse direction'); |
| effect = getEffectWithDir('alternate'); |
| assert_equals(effect.getComputedTiming().direction, 'alternate', |
| 'Initial value of alternate direction'); |
| effect = getEffectWithDir('alternate-reverse'); |
| assert_equals(effect.getComputedTiming().direction, 'alternate-reverse', |
| 'Initial value of alternate-reverse direction'); |
| }, 'direction of a new animation'); |
| |
| |
| // -------------------- |
| // easing |
| // -------------------- |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().easing, 'linear', |
| 'Initial value of easing'); |
| }, 'easing of a new animation'); |
| |
| |
| // ------------------------------ |
| // endTime |
| // = max(start delay + active duration + end delay, 0) |
| // -------------------- |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().endTime, 100 * MS_PER_SEC, |
| 'Initial value of endTime'); |
| }, 'endTime of an new animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s -5s'}); |
| var effect = div.getAnimations()[0].effect; |
| var answer = (100 - 5) * MS_PER_SEC; |
| assert_equals(effect.getComputedTiming().endTime, answer, |
| 'Initial value of endTime'); |
| }, 'endTime of an animation with a negative delay'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 10s -100s infinite'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().endTime, Infinity, |
| 'Initial value of endTime'); |
| }, 'endTime of an infinitely repeating animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 0s 100s infinite'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().endTime, 100 * MS_PER_SEC, |
| 'Initial value of endTime'); |
| }, 'endTime of an infinitely repeating zero-duration animation'); |
| |
| test(function(t) { |
| // Fill forwards so div.getAnimations()[0] won't return an |
| // undefined value. |
| var div = addDiv(t, {style: 'animation: moveAnimation 10s -100s forwards'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().endTime, 0, |
| 'Initial value of endTime'); |
| }, 'endTime of an animation that finishes before its startTime'); |
| |
| |
| // -------------------- |
| // activeDuration |
| // = iteration duration * iteration count |
| // -------------------- |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s 5'}); |
| var effect = div.getAnimations()[0].effect; |
| var answer = 100 * MS_PER_SEC * 5; |
| assert_equals(effect.getComputedTiming().activeDuration, answer, |
| 'Initial value of activeDuration'); |
| }, 'activeDuration of a new animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s infinite'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().activeDuration, Infinity, |
| 'Initial value of activeDuration'); |
| }, 'activeDuration of an infinitely repeating animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 0s 1s infinite'}); |
| var effect = div.getAnimations()[0].effect; |
| // If either the iteration duration or iteration count are zero, |
| // the active duration is zero. |
| assert_equals(effect.getComputedTiming().activeDuration, 0, |
| 'Initial value of activeDuration'); |
| }, 'activeDuration of an infinitely repeating zero-duration animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s 1s 0'}); |
| var effect = div.getAnimations()[0].effect; |
| // If either the iteration duration or iteration count are zero, |
| // the active duration is zero. |
| assert_equals(effect.getComputedTiming().activeDuration, 0, |
| 'Initial value of activeDuration'); |
| }, 'activeDuration of an animation with zero iterations'); |
| |
| |
| // -------------------- |
| // localTime |
| // -------------------- |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().localTime, 0, |
| 'Initial value of localTime'); |
| }, 'localTime of a new animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s'}); |
| var anim = div.getAnimations()[0]; |
| anim.currentTime = 5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().localTime, anim.currentTime, |
| 'current localTime after setting currentTime'); |
| }, 'localTime of an animation is always equal to currentTime'); |
| |
| promise_test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s'}); |
| |
| var anim = div.getAnimations()[0]; |
| anim.playbackRate = 2; // 2 times faster |
| |
| return anim.ready.then(function() { |
| assert_equals(anim.effect.getComputedTiming().localTime, anim.currentTime, |
| 'localTime is equal to currentTime'); |
| return waitForFrame(); |
| }).then(function() { |
| assert_equals(anim.effect.getComputedTiming().localTime, anim.currentTime, |
| 'localTime is equal to currentTime'); |
| }); |
| }, 'localTime reflects playbackRate immediately'); |
| |
| test(function(t) { |
| var div = addDiv(t); |
| var effect = new KeyframeEffect(div, {left: ["0px", "100px"]}); |
| |
| assert_equals(effect.getComputedTiming().localTime, null, |
| 'localTime for orphaned effect'); |
| }, 'localTime of an AnimationEffect without an Animation'); |
| |
| |
| // -------------------- |
| // progress |
| // Note: Default timing function is linear. |
| // -------------------- |
| test(function(t) { |
| [{fill: '', progress: [ null, null ]}, |
| {fill: 'none', progress: [ null, null ]}, |
| {fill: 'forwards', progress: [ null, 1.0 ]}, |
| {fill: 'backwards', progress: [ 0.0, null ]}, |
| {fill: 'both', progress: [ 0.0, 1.0 ]}] |
| .forEach(function(test) { |
| var div = |
| addDiv(t, {style: 'animation: moveAnimation 100s 10s ' + test.fill}); |
| var anim = div.getAnimations()[0]; |
| assert_true(anim.effect.getComputedTiming().progress === test.progress[0], |
| 'initial progress with "' + test.fill + '" fill'); |
| anim.finish(); |
| assert_true(anim.effect.getComputedTiming().progress === test.progress[1], |
| 'finished progress with "' + test.fill + '" fill'); |
| }); |
| }, 'progress of an animation with different fill modes'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 10s 10 both'}); |
| var anim = div.getAnimations()[0]; |
| |
| assert_equals(anim.effect.getComputedTiming().progress, 0.0, |
| 'Initial value of progress'); |
| anim.currentTime += 2.5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.25, |
| 'Value of progress'); |
| anim.currentTime += 5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.75, |
| 'Value of progress'); |
| anim.currentTime += 5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.25, |
| 'Value of progress'); |
| anim.finish() |
| assert_equals(anim.effect.getComputedTiming().progress, 1.0, |
| 'Value of progress'); |
| }, 'progress of an integral repeating animation with normal direction'); |
| |
| test(function(t) { |
| var div = addDiv(t); |
| // Note: FillMode here is "both" because |
| // 1. Since this a zero-duration animation, it will already have finished |
| // so it won't be returned by getAnimations() unless it fills forwards. |
| // 2. Fill backwards, so the progress before phase wouldn't be |
| // unresolved (null value). |
| var div = addDiv(t, {style: 'animation: moveAnimation 0s infinite both'}); |
| var anim = div.getAnimations()[0]; |
| |
| assert_equals(anim.effect.getComputedTiming().progress, 1.0, |
| 'Initial value of progress in after phase'); |
| |
| // Seek backwards |
| anim.currentTime -= 1 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.0, |
| 'Value of progress before phase'); |
| }, 'progress of an infinitely repeating zero-duration animation'); |
| |
| test(function(t) { |
| // Default iterations = 1 |
| var div = addDiv(t, {style: 'animation: moveAnimation 0s both'}); |
| var anim = div.getAnimations()[0]; |
| |
| assert_equals(anim.effect.getComputedTiming().progress, 1.0, |
| 'Initial value of progress in after phase'); |
| |
| // Seek backwards |
| anim.currentTime -= 1 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.0, |
| 'Value of progress before phase'); |
| }, 'progress of a finitely repeating zero-duration animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 0s 5s 10.25 both'}); |
| var anim = div.getAnimations()[0]; |
| |
| assert_equals(anim.effect.getComputedTiming().progress, 0.0, |
| 'Initial value of progress (before phase)'); |
| |
| // Using iteration duration of 1 now. |
| // currentIteration now is floor(10.25) = 10, so progress should be 25%. |
| anim.finish(); |
| assert_equals(anim.effect.getComputedTiming().progress, 0.25, |
| 'Value of progress in after phase'); |
| }, 'progress of a non-integral repeating zero-duration animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 0s 5s 10.25 both reverse'}); |
| var anim = div.getAnimations()[0]; |
| |
| assert_equals(anim.effect.getComputedTiming().progress, 1.0, |
| 'Initial value of progress (before phase)'); |
| |
| // Seek forwards |
| anim.finish(); |
| assert_equals(anim.effect.getComputedTiming().progress, 0.75, |
| 'Value of progress in after phase'); |
| }, 'Progress of a non-integral repeating zero-duration animation ' + |
| 'with reversing direction'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 10s 10.25 both alternate'}); |
| var anim = div.getAnimations()[0]; |
| |
| assert_equals(anim.effect.getComputedTiming().progress, 0.0, |
| 'Initial value of progress'); |
| anim.currentTime += 2.5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.25, |
| 'Value of progress'); |
| anim.currentTime += 5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.75, |
| 'Value of progress'); |
| anim.currentTime += 5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.75, |
| 'Value of progress'); |
| anim.finish() |
| assert_equals(anim.effect.getComputedTiming().progress, 0.25, |
| 'Value of progress'); |
| }, 'progress of a non-integral repeating animation ' + |
| 'with alternate direction'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 10s 10.25 both alternate-reverse'}); |
| var anim = div.getAnimations()[0]; |
| |
| assert_equals(anim.effect.getComputedTiming().progress, 1.0, |
| 'Initial value of progress'); |
| anim.currentTime += 2.5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.75, |
| 'Value of progress'); |
| anim.currentTime += 5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.25, |
| 'Value of progress'); |
| anim.currentTime += 5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.25, |
| 'Value of progress'); |
| anim.finish() |
| assert_equals(anim.effect.getComputedTiming().progress, 0.75, |
| 'Value of progress'); |
| }, 'progress of a non-integral repeating animation ' + |
| 'with alternate-reversing direction'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 0s 10.25 both alternate'}); |
| var anim = div.getAnimations()[0]; |
| |
| assert_equals(anim.effect.getComputedTiming().progress, 0.25, |
| 'Initial value of progress'); |
| anim.currentTime += 2.5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.25, |
| 'Value of progress'); |
| anim.currentTime -= 5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.0, |
| 'Value of progress'); |
| anim.finish() |
| assert_equals(anim.effect.getComputedTiming().progress, 0.25, |
| 'Value of progress'); |
| }, 'progress of a non-integral repeating zero-duration animation ' + |
| 'with alternate direction'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 0s 10.25 both alternate-reverse'}); |
| var anim = div.getAnimations()[0]; |
| |
| assert_equals(anim.effect.getComputedTiming().progress, 0.75, |
| 'Initial value of progress'); |
| anim.currentTime += 2.5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 0.75, |
| 'Value of progress'); |
| anim.currentTime -= 5 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().progress, 1.0, |
| 'Value of progress'); |
| anim.finish() |
| assert_equals(anim.effect.getComputedTiming().progress, 0.75, |
| 'Value of progress'); |
| }, 'progress of a non-integral repeating zero-duration animation ' + |
| 'with alternate-reverse direction'); |
| |
| |
| // -------------------- |
| // currentIteration |
| // -------------------- |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s 2s'}); |
| var effect = div.getAnimations()[0].effect; |
| assert_equals(effect.getComputedTiming().currentIteration, null, |
| 'Initial value of currentIteration before phase'); |
| }, 'currentIteration of a new animation with no backwards fill is unresolved ' + |
| 'in before phase'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s'}); |
| var anim = div.getAnimations()[0]; |
| assert_equals(anim.effect.getComputedTiming().currentIteration, 0, |
| 'Initial value of currentIteration'); |
| }, 'currentIteration of a new animation is zero'); |
| |
| test(function(t) { |
| // Note: FillMode here is "both" because |
| // 1. Since this a zero-duration animation, it will already have finished |
| // so it won't be returned by getAnimations() unless it fills forwards. |
| // 2. Fill backwards, so the currentIteration (before phase) wouldn't be |
| // unresolved (null value). |
| var div = addDiv(t, {style: 'animation: moveAnimation 0s infinite both'}); |
| var anim = div.getAnimations()[0]; |
| |
| assert_equals(anim.effect.getComputedTiming().currentIteration, Infinity, |
| 'Initial value of currentIteration in after phase'); |
| |
| // Seek backwards |
| anim.currentTime -= 2 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().currentIteration, 0, |
| 'Value of currentIteration count during before phase'); |
| }, 'currentIteration of an infinitely repeating zero-duration animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 0s 10.5 both'}); |
| var anim = div.getAnimations()[0]; |
| |
| // Note: currentIteration = ceil(iteration start + iteration count) - 1 |
| assert_equals(anim.effect.getComputedTiming().currentIteration, 10, |
| 'Initial value of currentIteration'); |
| |
| // Seek backwards |
| anim.currentTime -= 2 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().currentIteration, 0, |
| 'Value of currentIteration count during before phase'); |
| }, 'currentIteration of a finitely repeating zero-duration animation'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s 5.5 forwards'}); |
| var anim = div.getAnimations()[0]; |
| |
| assert_equals(anim.effect.getComputedTiming().currentIteration, 0, |
| 'Initial value of currentIteration'); |
| // The 3rd iteration |
| // Note: currentIteration = floor(scaled active time / iteration duration) |
| anim.currentTime = 250 * MS_PER_SEC; |
| assert_equals(anim.effect.getComputedTiming().currentIteration, 2, |
| 'Value of currentIteration during the 3rd iteration'); |
| // Finish |
| anim.finish(); |
| assert_equals(anim.effect.getComputedTiming().currentIteration, 5, |
| 'Value of currentIteration in after phase'); |
| }, 'currentIteration of an animation with a non-integral iteration count'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s 2 forwards'}); |
| var anim = div.getAnimations()[0]; |
| |
| assert_equals(anim.effect.getComputedTiming().currentIteration, 0, |
| 'Initial value of currentIteration'); |
| // Finish |
| anim.finish(); |
| assert_equals(anim.effect.getComputedTiming().currentIteration, 1, |
| 'Value of currentIteration in after phase'); |
| }, 'currentIteration of an animation with an integral iteration count'); |
| |
| test(function(t) { |
| var div = addDiv(t, {style: 'animation: moveAnimation 100s forwards'}); |
| var anim = div.getAnimations()[0]; |
| assert_equals(anim.effect.getComputedTiming().currentIteration, 0, |
| 'Initial value of currentIteration'); |
| // Finish |
| anim.finish(); |
| assert_equals(anim.effect.getComputedTiming().currentIteration, 0, |
| 'Value of currentIteration in after phase'); |
| }, 'currentIteration of an animation with a default iteration count'); |
| |
| test(function(t) { |
| var div = addDiv(t); |
| var effect = new KeyframeEffect(div, {left: ["0px", "100px"]}); |
| |
| assert_equals(effect.getComputedTiming().currentIteration, null, |
| 'currentIteration for orphaned effect'); |
| }, 'currentIteration of an AnimationEffect without an Animation'); |
| |
| // TODO: If iteration duration is Infinity, currentIteration is 0. |
| // However, we cannot set iteration duration to Infinity in CSS Animation now. |
| |
| </script> |
| </body> |
