undefined reference to 'JSC::B3::BasicBlock::fallThrough() const
[WebKit-https.git] / LayoutTests / http / wpt / web-animations / timing-model / animations / set-the-animation-start-time.html
1 <!DOCTYPE html>
2 <meta charset=utf-8>
3 <title>Setting the start time tests</title>
4 <link rel="help" href="https://w3c.github.io/web-animations/#set-the-animation-start-time">
5 <script src="/resources/testharness.js"></script>
6 <script src="/resources/testharnessreport.js"></script>
7 <script src="../../testcommon.js"></script>
8 <body>
9 <div id="log"></div>
10 <script>
11 'use strict';
12
13 test(function(t)
14 {
15   // It should only be possible to set *either* the start time or the current
16   // time for an animation that does not have an active timeline.
17
18   var animation =
19     new Animation(new KeyframeEffect(createDiv(t), null, 100 * MS_PER_SEC),
20                   null);
21
22   assert_equals(animation.currentTime, null, 'Intial current time');
23   assert_equals(animation.startTime, null, 'Intial start time');
24
25   animation.currentTime = 1000;
26   assert_equals(animation.currentTime, 1000,
27                 'Setting the current time succeeds');
28   assert_equals(animation.startTime, null,
29                 'Start time remains null after setting current time');
30
31   animation.startTime = 1000;
32   assert_equals(animation.startTime, 1000,
33                 'Setting the start time succeeds');
34   assert_equals(animation.currentTime, null,
35                 'Setting the start time clears the current time');
36
37   animation.startTime = null;
38   assert_equals(animation.startTime, null,
39                 'Setting the start time to an unresolved time succeeds');
40   assert_equals(animation.currentTime, null, 'The current time is unaffected');
41
42 }, 'Setting the start time of an animation without an active timeline');
43
44 test(function(t)
45 {
46   // Setting an unresolved start time on an animation without an active
47   // timeline should not clear the current time.
48
49   var animation =
50     new Animation(new KeyframeEffect(createDiv(t), null, 100 * MS_PER_SEC),
51                   null);
52
53   assert_equals(animation.currentTime, null, 'Intial current time');
54   assert_equals(animation.startTime, null, 'Intial start time');
55
56   animation.currentTime = 1000;
57   assert_equals(animation.currentTime, 1000,
58                 'Setting the current time succeeds');
59   assert_equals(animation.startTime, null,
60                 'Start time remains null after setting current time');
61
62   animation.startTime = null;
63   assert_equals(animation.startTime, null, 'Start time remains unresolved');
64   assert_equals(animation.currentTime, 1000, 'Current time is unaffected');
65
66 }, 'Setting an unresolved start time an animation without an active timeline'
67    + ' does not clear the current time');
68
69 test(function(t)
70 {
71   var animation =
72     new Animation(new KeyframeEffect(createDiv(t), null, 100 * MS_PER_SEC),
73                   document.timeline);
74
75   // So long as a hold time is set, querying the current time will return
76   // the hold time.
77
78   // Since the start time is unresolved at this point, setting the current time
79   // will set the hold time
80   animation.currentTime = 1000;
81   assert_equals(animation.currentTime, 1000,
82                 'The current time is calculated from the hold time');
83
84   // If we set the start time, however, we should clear the hold time.
85   animation.startTime = document.timeline.currentTime - 2000;
86   assert_times_equal(animation.currentTime, 2000,
87                      'The current time is calculated from the start time,'
88                      + ' not the hold time');
89
90   // Sanity check
91   assert_equals(animation.playState, 'running',
92                 'Animation reports it is running after setting a resolved'
93                 + ' start time');
94 }, 'Setting the start time clears the hold time');
95
96 test(function(t)
97 {
98   var animation =
99     new Animation(new KeyframeEffect(createDiv(t), null, 100 * MS_PER_SEC),
100                   document.timeline);
101
102   // Set up a running animation (i.e. both start time and current time
103   // are resolved).
104   animation.startTime = document.timeline.currentTime - 1000;
105   assert_equals(animation.playState, 'running');
106   assert_times_equal(animation.currentTime, 1000,
107                      'Current time is resolved for a running animation')
108
109   // Clear start time
110   animation.startTime = null;
111   assert_times_equal(animation.currentTime, 1000,
112                      'Hold time is set after start time is made unresolved');
113   assert_equals(animation.playState, 'paused',
114                 'Animation reports it is paused after setting an unresolved'
115                 + ' start time');
116 }, 'Setting an unresolved start time sets the hold time');
117
118 promise_test(function(t)
119 {
120   var animation =
121     new Animation(new KeyframeEffect(createDiv(t), null, 100 * MS_PER_SEC),
122                   document.timeline);
123
124   var readyPromiseCallbackCalled = false;
125   animation.ready.then(function() { readyPromiseCallbackCalled = true; } );
126
127   // Put the animation in the play-pending state
128   animation.play();
129
130   // Sanity check
131   assert_equals(animation.playState, 'pending',
132                 'Animation is in play-pending state');
133
134   // Setting the start time should resolve the 'ready' promise, i.e.
135   // it should schedule a microtask to run the promise callbacks.
136   animation.startTime = document.timeline.currentTime;
137   assert_false(readyPromiseCallbackCalled,
138                'Ready promise callback is not called synchronously');
139
140   // If we schedule another microtask then it should run immediately after
141   // the ready promise resolution microtask.
142   return Promise.resolve().then(function() {
143     assert_true(readyPromiseCallbackCalled,
144                 'Ready promise callback called after setting startTime');
145   });
146 }, 'Setting the start time resolves a pending ready promise');
147
148 promise_test(function(t)
149 {
150   var animation =
151     new Animation(new KeyframeEffect(createDiv(t), null, 100 * MS_PER_SEC),
152                   document.timeline);
153
154   var readyPromiseCallbackCalled = false;
155   animation.ready.then(function() { readyPromiseCallbackCalled = true; } );
156
157   // Put the animation in the pause-pending state
158   animation.startTime = document.timeline.currentTime;
159   animation.pause();
160
161   // Sanity check
162   assert_equals(animation.playState, 'pending',
163                 'Animation is in pause-pending state');
164
165   // Setting the start time should resolve the 'ready' promise although
166   // the resolution callbacks when be run in a separate microtask.
167   animation.startTime = null;
168   assert_false(readyPromiseCallbackCalled,
169                'Ready promise callback is not called synchronously');
170
171   return Promise.resolve().then(function() {
172     assert_true(readyPromiseCallbackCalled,
173                 'Ready promise callback called after setting startTime');
174   });
175 }, 'Setting the start time resolves a pending pause task');
176
177 promise_test(function(t)
178 {
179   var animation =
180     new Animation(new KeyframeEffect(createDiv(t), null, 100 * MS_PER_SEC),
181                   document.timeline);
182
183   // Set start time such that the current time is past the end time
184   animation.startTime = document.timeline.currentTime
185                         - 110 * MS_PER_SEC;
186   assert_equals(animation.playState, 'finished',
187                 'Seeked to finished state using the startTime');
188
189   // If the 'did seek' flag is true, the current time should be greater than
190   // the effect end.
191   assert_greater_than(animation.currentTime,
192                       animation.effect.getComputedTiming().endTime,
193                       'Setting the start time updated the finished state with'
194                       + ' the \'did seek\' flag set to true');
195
196   // Furthermore, that time should persist if we have correctly updated
197   // the hold time
198   var finishedCurrentTime = animation.currentTime;
199   return waitForAnimationFrames(1).then(function() {
200     assert_equals(animation.currentTime, finishedCurrentTime,
201                   'Current time does not change after seeking past the effect'
202                   + ' end time by setting the current time');
203   });
204 }, 'Setting the start time updates the finished state');
205
206 </script>
207 </body>