summaryrefslogtreecommitdiffstats
path: root/testing/web-platform/tests/web-animations/timing-model/animation-effects/active-time.html
blob: bdaad08edd4419298edb0ac41e6cb5e334937bb5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
<!DOCTYPE html>
<meta charset=utf-8>
<title>Active time tests</title>
<link rel="help" href="https://w3c.github.io/web-animations/#calculating-the-active-time">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="../../testcommon.js"></script>
<body>
<div id="log"></div>
<script>
'use strict';

test(function(t) {
  var tests = [ { fill: 'none', progress: null },
                { fill: 'backwards', progress: 0 },
                { fill: 'forwards', progress: null },
                { fill: 'both', progress: 0 } ];
  tests.forEach(function(test) {
    var anim = createDiv(t).animate(null, { delay: 1, fill: test.fill });
    assert_equals(anim.effect.getComputedTiming().progress, test.progress,
                  'Progress in before phase when using \'' + test.fill
                  + '\' fill');
  });
}, 'Active time in before phase');

test(function(t) {
  var anim = createDiv(t).animate(null, 1000);
  anim.currentTime = 500;
  assert_times_equal(anim.effect.getComputedTiming().progress, 0.5);
}, 'Active time in active phase and no start delay is the local time');

test(function(t) {
  var anim = createDiv(t).animate(null, { duration: 1000, delay: 500 });
  anim.currentTime = 1000;
  assert_times_equal(anim.effect.getComputedTiming().progress, 0.5);
}, 'Active time in active phase and positive start delay is the local time'
   + ' minus the start delay');

test(function(t) {
  var anim = createDiv(t).animate(null, { duration: 1000, delay: -500 });
  assert_times_equal(anim.effect.getComputedTiming().progress, 0.5);
}, 'Active time in active phase and negative start delay is the local time'
   + ' minus the start delay');

test(function(t) {
  var anim = createDiv(t).animate(null);
  assert_equals(anim.effect.getComputedTiming().progress, null);
}, 'Active time in after phase with no fill is unresolved');

test(function(t) {
  var anim = createDiv(t).animate(null, { fill: 'backwards' });
  assert_equals(anim.effect.getComputedTiming().progress, null);
}, 'Active time in after phase with backwards-only fill is unresolved');

test(function(t) {
  var anim = createDiv(t).animate(null, { duration: 1000,
                                          iterations: 2.3,
                                          delay: 500, // Should have no effect
                                          fill: 'forwards' });
  anim.finish();
  assert_equals(anim.effect.getComputedTiming().currentIteration, 2);
  assert_times_equal(anim.effect.getComputedTiming().progress, 0.3);
}, 'Active time in after phase with forwards fill is the active duration');

test(function(t) {
  var anim = createDiv(t).animate(null, { duration: 0,
                                          iterations: Infinity,
                                          fill: 'forwards' });
  anim.finish();
  assert_equals(anim.effect.getComputedTiming().currentIteration, Infinity);
  assert_equals(anim.effect.getComputedTiming().progress, 1);
}, 'Active time in after phase with forwards fill, zero-duration, and '
   + ' infinite iteration count is the active duration');

test(function(t) {
  var anim = createDiv(t).animate(null, { duration: 1000,
                                          iterations: 2.3,
                                          delay: 500,
                                          endDelay: 4000,
                                          fill: 'forwards' });
  anim.finish();
  assert_equals(anim.effect.getComputedTiming().currentIteration, 2);
  assert_times_equal(anim.effect.getComputedTiming().progress, 0.3);
}, 'Active time in after phase with forwards fill and positive end delay'
   + ' is the active duration');

test(function(t) {
  var anim = createDiv(t).animate(null, { duration: 1000,
                                          iterations: 2.3,
                                          delay: 500,
                                          endDelay: -800,
                                          fill: 'forwards' });
  anim.finish();
  assert_equals(anim.effect.getComputedTiming().currentIteration, 1);
  assert_times_equal(anim.effect.getComputedTiming().progress, 0.5);
}, 'Active time in after phase with forwards fill and negative end delay'
   + ' is the active duration + end delay');

test(function(t) {
  var anim = createDiv(t).animate(null, { duration: 1000,
                                          iterations: 2.3,
                                          delay: 500,
                                          endDelay: -2500,
                                          fill: 'forwards' });
  anim.finish();
  assert_equals(anim.effect.getComputedTiming().currentIteration, 0);
  assert_equals(anim.effect.getComputedTiming().progress, 0);
}, 'Active time in after phase with forwards fill and negative end delay'
   + ' greater in magnitude than the active duration is zero');

test(function(t) {
  var anim = createDiv(t).animate(null, { duration: 1000,
                                          iterations: 2.3,
                                          delay: 500,
                                          endDelay: -4000,
                                          fill: 'forwards' });
  anim.finish();
  assert_equals(anim.effect.getComputedTiming().currentIteration, 0);
  assert_equals(anim.effect.getComputedTiming().progress, 0);
}, 'Active time in after phase with forwards fill and negative end delay'
   + ' greater in magnitude than the sum of the active duration and start delay'
   + ' is zero');

test(function(t) {
  var anim = createDiv(t).animate(null, { duration: 1000,
                                          iterations: 2.3,
                                          delay: 500,
                                          fill: 'both' });
  anim.finish();
  assert_equals(anim.effect.getComputedTiming().currentIteration, 2);
  assert_times_equal(anim.effect.getComputedTiming().progress, 0.3);
}, 'Active time in after phase with \'both\' fill is the active duration');

test(function(t) {
  // Create an effect with a non-zero duration so we ensure we're not just
  // testing the after-phase behavior.
  var effect = new KeyframeEffect(null, null, 1);
  assert_equals(effect.getComputedTiming().progress, null);
}, 'Active time when the local time is unresolved, is unresolved');

</script>
</body>