LayoutTests/web-animations-api/player-state-changes.html - Issue 555063002: Web Animations: Add tests for player state transitions and fix discovered issues

Side by Side Diff: LayoutTests/web-animations-api/player-state-changes.html

Issue 555063002: Web Animations: Add tests for player state transitions and fix discovered issues (Closed) Base URL: svn://svn.chromium.org/blink/trunk

Patch Set: Finish shouldn't exit idle. Created 6 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

OLD	NEW
(Empty)
	1 <!DOCTYPE html>

	2 <script src="../resources/testharness.js"></script>

	3 <script src="../resources/testharnessreport.js"></script>

	4

	5 <script>

	6 function assert_unresolved(value) {

	7 assert_true(isNaN(value));

	8 }

	9

	10 function idlePlayer() {

	11 var player = document.documentElement.animate([], 100000);

	12 player.cancel();

	13 assert_equals(player.playState, 'idle');

	14 return player;

	15 }

	16

	17 function runningPlayer() {

	18 var player = document.documentElement.animate([], 100000);

	19 player.startTime = document.timeline.currentTime;

	20 return player;

	21 }

	22

	23 function pendingStartTimePlayer() {

	24 var player = document.documentElement.animate([], 100000);

	25 return player;

	26 }

	27

	28 function pendingStartTimeAndCurrentTimePlayer() {

	29 var player = document.documentElement.animate([], 100000);

	30 player.pause();

	31 player.play();

	32 return player;

	33 }

	34

	35 function pausedPlayer() {

	36 var player = document.documentElement.animate([], 100000);

	37 player.pause();

	38 player.currentTime = 0;

	39 return player;

	40 }

	41

	42 function finishedPlayer() {

	43 var player = document.documentElement.animate([], 100000);

	44 player.finish();

	45 return player;

	46 }
	alancutter (OOO until 2018) 2014/09/10 03:59:42 We should add assertions to all these helper funct We should add assertions to all these helper functions to be sure they're returning players in the state we expect and to help me comprehend all these tests. :) e.g. assert_equals(player.playState, 'idle'); assert_equals(player.startTime, null); assert_equals(player.currentTime, 0); dstockwell 2014/09/10 04:01:10 That's what the tests immediately below are for. Show quoted text On 2014/09/10 03:59:42, alancutter wrote: > We should add assertions to all these helper functions to be sure they're > returning players in the state we expect and to help me comprehend all these > tests. :) > e.g. > assert_equals(player.playState, 'idle'); > assert_equals(player.startTime, null); > assert_equals(player.currentTime, 0); That's what the tests immediately below are for. alancutter (OOO until 2018) 2014/09/10 07:27:05 Acknowledged. In that case looks like idlePlayer() Show quoted text On 2014/09/10 04:01:10, dstockwell wrote: > On 2014/09/10 03:59:42, alancutter wrote: > > We should add assertions to all these helper functions to be sure they're > > returning players in the state we expect and to help me comprehend all these > > tests. :) > > e.g. > > assert_equals(player.playState, 'idle'); > > assert_equals(player.startTime, null); > > assert_equals(player.currentTime, 0); > > That's what the tests immediately below are for. Acknowledged. In that case looks like idlePlayer() has a redundant assert. dstockwell 2014/09/10 07:42:16 Removed. Show quoted text On 2014/09/10 at 07:27:05, alancutter wrote: > On 2014/09/10 04:01:10, dstockwell wrote: > > On 2014/09/10 03:59:42, alancutter wrote: > > > We should add assertions to all these helper functions to be sure they're > > > returning players in the state we expect and to help me comprehend all these > > > tests. :) > > > e.g. > > > assert_equals(player.playState, 'idle'); > > > assert_equals(player.startTime, null); > > > assert_equals(player.currentTime, 0); > > > > That's what the tests immediately below are for. > > Acknowledged. > In that case looks like idlePlayer() has a redundant assert. Removed.
	47

	48 test(function() {

	49 var player = idlePlayer();

	50 assert_unresolved(player.startTime);

	51 assert_unresolved(player.currentTime);

	52 assert_equals(player.playState, 'idle');

	53 }, "idle");

	54

	55 test(function() {

	56 var player = pendingStartTimePlayer();

	57 assert_unresolved(player.startTime);

	58 assert_equals(player.currentTime, 0);

	59 assert_equals(player.playState, 'pending');

	60 }, "pending startTime");

	61

	62 test(function() {

	63 var player = pendingStartTimeAndCurrentTimePlayer();

	64 assert_unresolved(player.startTime);

	65 assert_unresolved(player.currentTime);

	66 assert_equals(player.playState, 'pending');

	67 }, "pending startTime and currentTime");

	68

	69 test(function() {

	70 var player = runningPlayer();

	71 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	72 assert_equals(player.currentTime, 0);

	73 assert_equals(player.playState, 'running');

	74 }, "running");

	75

	76 test(function() {

	77 var player = pausedPlayer();

	78 assert_unresolved(player.startTime);

	79 assert_equals(player.currentTime, 0);

	80 assert_equals(player.playState, 'paused');

	81 }, "paused");

	82

	83 test(function() {

	84 var player = finishedPlayer();

	85 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	86 assert_equals(player.currentTime, 100000);

	87 assert_equals(player.playState, 'finished');

	88 }, "finished");

	89

	90 test(function() {

	91 var player = idlePlayer();

	92 player.play();

	93 assert_unresolved(player.startTime);

	94 assert_equals(player.currentTime, 0);

	95 assert_equals(player.playState, 'pending');

	96 }, "idle -> play()");

	97

	98 test(function() {

	99 var player = idlePlayer();

	100 player.pause();

	101 assert_unresolved(player.startTime);

	102 assert_unresolved(player.currentTime);

	103 assert_equals(player.playState, 'idle');

	104 }, "idle -> pause()");

	105

	106 test(function() {

	107 var player = idlePlayer();

	108 player.cancel();

	109 assert_unresolved(player.startTime);

	110 assert_unresolved(player.currentTime);

	111 assert_equals(player.playState, 'idle');

	112 }, "idle -> cancel()");

	113

	114 test(function() {

	115 var player = idlePlayer();

	116 player.finish();

	117 assert_unresolved(player.startTime);

	118 assert_unresolved(player.currentTime);

	119 assert_equals(player.playState, 'idle');

	120 }, "idle -> finish()");

	121

	122 test(function() {

	123 var player = idlePlayer();

	124 player.reverse();

	125 assert_unresolved(player.startTime);

	126 assert_equals(player.currentTime, 100000);

	127 assert_equals(player.playState, 'pending');

	128 }, "idle -> reverse()");

	129

	130 test(function() {

	131 var player = idlePlayer();

	132 player.currentTime = 1000;

	133 assert_unresolved(player.startTime);

	134 assert_unresolved(player.currentTime);

	135 assert_equals(player.playState, 'idle');

	136 }, "idle -> set currentTime");

	137

	138 test(function() {

	139 var player = idlePlayer();

	140 player.startTime = 1000;
	alancutter (OOO until 2018) 2014/09/10 07:27:05 It looks like pause(), finish(), cancel() and seek It looks like pause(), finish(), cancel() and seeking have no effect on idle players. I wonder if these actions should throw exceptions instead.
	141 assert_unresolved(player.startTime);

	142 assert_unresolved(player.currentTime);

	143 assert_equals(player.playState, 'idle');

	144 }, "idle -> set startTime");

	145

	146 test(function() {

	147 var player = pendingStartTimePlayer();

	148 player.play();

	149 assert_unresolved(player.startTime);

	150 assert_equals(player.currentTime, 0);

	151 assert_equals(player.playState, 'pending');

	152 }, "pending startTime -> play()");

	153

	154 test(function() {

	155 var player = pendingStartTimePlayer();

	156 player.pause();

	157 assert_unresolved(player.startTime);

	158 assert_unresolved(player.currentTime);

	159 assert_equals(player.playState, 'pending');

	160 }, "pending startTime -> pause()");

	161

	162 test(function() {

	163 var player = pendingStartTimePlayer();

	164 player.cancel();

	165 assert_unresolved(player.startTime);

	166 assert_unresolved(player.currentTime);

	167 assert_equals(player.playState, 'idle');

	168 }, "pending startTime -> cancel()");

	169

	170 test(function() {

	171 var player = pendingStartTimePlayer();

	172 player.finish();

	173 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	174 assert_equals(player.currentTime, 100000);

	175 assert_equals(player.playState, 'finished');

	176 }, "pending startTime -> finish()");

	177

	178 test(function() {

	179 var player = pendingStartTimePlayer();

	180 player.reverse();

	181 assert_unresolved(player.startTime);

	182 assert_equals(player.currentTime, 100000);

	183 assert_equals(player.playState, 'pending');

	184 }, "pending startTime -> reverse()");

	185

	186 test(function() {

	187 var player = pendingStartTimePlayer();

	188 player.currentTime = 1000;

	189 assert_unresolved(player.startTime);

	190 assert_equals(player.currentTime, 1000);

	191 assert_equals(player.playState, 'pending');

	192 }, "pending startTime -> set currentTime");

	193

	194 test(function() {

	195 var player = pendingStartTimePlayer();

	196 player.startTime = document.timeline.currentTime;
	alancutter (OOO until 2018) 2014/09/10 07:27:05 Wouldn't hurt to use "document.timeline.currentTim Wouldn't hurt to use "document.timeline.currentTime - 1000" to test that currentTime updates correctly here similar to "running -> set startTime". dstockwell 2014/09/10 07:42:16 Done. Show quoted text On 2014/09/10 at 07:27:05, alancutter wrote: > Wouldn't hurt to use "document.timeline.currentTime - 1000" to test that currentTime updates correctly here similar to "running -> set startTime". Done.
	197 assert_equals(player.startTime, document.timeline.currentTime);

	198 assert_equals(player.currentTime, 0);

	199 assert_equals(player.playState, 'running');

	200 }, "pending startTime -> set startTime");

	201

	202 test(function() {

	203 var player = pendingStartTimeAndCurrentTimePlayer();

	204 player.play();

	205 assert_unresolved(player.startTime);

	206 assert_unresolved(player.currentTime);

	207 assert_equals(player.playState, 'pending');

	208 }, "pending startTime & currentTime -> play()");

	209

	210 test(function() {

	211 var player = pendingStartTimeAndCurrentTimePlayer();

	212 player.pause();

	213 assert_unresolved(player.startTime);

	214 assert_unresolved(player.currentTime);

	215 assert_equals(player.playState, 'pending');

	216 }, "pending startTime & currentTime -> pause()");

	217

	218 test(function() {

	219 var player = pendingStartTimeAndCurrentTimePlayer();

	220 player.cancel();

	221 assert_unresolved(player.startTime);

	222 assert_unresolved(player.currentTime);

	223 assert_equals(player.playState, 'idle');

	224 }, "pending startTime & currentTime -> cancel()");

	225

	226 test(function() {

	227 var player = pendingStartTimeAndCurrentTimePlayer();

	228 player.finish();

	229 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	230 assert_equals(player.currentTime, 100000);

	231 assert_equals(player.playState, 'finished');

	232 }, "pending startTime & currentTime -> finish()");

	233

	234 test(function() {

	235 var player = pendingStartTimeAndCurrentTimePlayer();

	236 player.reverse();

	237 assert_unresolved(player.startTime);

	238 assert_unresolved(player.currentTime);

	239 assert_equals(player.playState, 'pending');

	240 }, "pending startTime & currentTime -> reverse()");

	241

	242 test(function() {

	243 var player = pendingStartTimeAndCurrentTimePlayer();

	244 player.currentTime = 1000;

	245 assert_unresolved(player.startTime);

	246 assert_equals(player.currentTime, 1000);

	247 assert_equals(player.playState, 'pending');

	248 }, "pending startTime & currentTime -> set currentTime");

	249

	250 test(function() {

	251 var player = pendingStartTimeAndCurrentTimePlayer();

	252 player.startTime = document.timeline.currentTime;

	253 assert_equals(player.startTime, document.timeline.currentTime);

	254 assert_equals(player.currentTime, 0);

	255 assert_equals(player.playState, 'running');

	256 }, "pending startTime & currentTime -> set startTime");

	257

	258 test(function() {

	259 var player = runningPlayer();

	260 var startTime = player.startTime;

	261 var currentTime = player.currentTime;

	262 player.play();

	263 assert_equals(player.startTime, startTime);

	264 assert_equals(player.currentTime, currentTime);

	265 assert_equals(player.playState, 'running');

	266 }, "running -> play()");

	267

	268 test(function() {

	269 var player = runningPlayer();

	270 player.pause();

	271 assert_unresolved(player.startTime);

	272 assert_unresolved(player.currentTime);

	273 assert_equals(player.playState, 'pending');

	274 }, "running -> pause()");

	275

	276 test(function() {

	277 var player = runningPlayer();

	278 player.cancel();

	279 assert_unresolved(player.startTime);

	280 assert_unresolved(player.currentTime);

	281 assert_equals(player.playState, 'idle');

	282 }, "running -> cancel()");

	283

	284 test(function() {

	285 var player = runningPlayer();

	286 player.finish();

	287 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	288 assert_equals(player.currentTime, 100000);

	289 assert_equals(player.playState, 'finished');

	290 }, "running -> finish()");

	291

	292 test(function() {

	293 var player = runningPlayer();

	294 player.reverse();

	295 assert_unresolved(player.startTime);

	296 assert_unresolved(player.currentTime);

	297 assert_equals(player.playState, 'pending');

	298 }, "running -> reverse()");

	299

	300 test(function() {

	301 var player = runningPlayer();

	302 player.currentTime = 1000;

	303 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	304 assert_equals(player.currentTime, 1000);

	305 assert_equals(player.playState, 'running');

	306 }, "running -> set currentTime");

	307

	308 test(function() {

	309 var player = runningPlayer();

	310 player.startTime = document.timeline.currentTime - 1000;

	311 assert_equals(player.startTime, document.timeline.currentTime - 1000);

	312 assert_equals(player.currentTime, 1000);

	313 assert_equals(player.playState, 'running');

	314 }, "running -> set startTime");

	315

	316 test(function() {

	317 var player = pausedPlayer();

	318 player.play();

	319 assert_unresolved(player.startTime);

	320 assert_equals(player.currentTime, 0);

	321 assert_equals(player.playState, 'pending');

	322 }, "paused -> play()");

	323

	324 test(function() {

	325 var player = pausedPlayer();

	326 player.pause();

	327 assert_unresolved(player.startTime);

	328 assert_equals(player.currentTime, 0);

	329 assert_equals(player.playState, 'paused');

	330 }, "paused -> pause()");

	331

	332 test(function() {

	333 var player = pausedPlayer();

	334 player.cancel();

	335 assert_unresolved(player.startTime);

	336 assert_unresolved(player.currentTime);

	337 assert_equals(player.playState, 'idle');

	338 }, "paused -> cancel()");

	339

	340 test(function() {

	341 var player = pausedPlayer();

	342 player.finish();

	343 assert_unresolved(player.startTime);

	344 assert_equals(player.currentTime, 100000);

	345 assert_equals(player.playState, 'paused');

	346 }, "paused -> finish()");

	347

	348 test(function() {

	349 var player = pausedPlayer();

	350 player.reverse();

	351 assert_unresolved(player.startTime);

	352 assert_equals(player.currentTime, 100000);

	353 assert_equals(player.playState, 'pending');

	354 }, "paused -> reverse()");

	355

	356 test(function() {

	357 var player = pausedPlayer();

	358 player.currentTime = 1000;

	359 assert_unresolved(player.startTime);

	360 assert_equals(player.currentTime, 1000);

	361 assert_equals(player.playState, 'paused');

	362 }, "paused -> set currentTime");

	363

	364 test(function() {

	365 var player = pausedPlayer();

	366 player.startTime = 1000;

	367 assert_unresolved(player.startTime);

	368 assert_equals(player.currentTime, 0);

	369 assert_equals(player.playState, 'paused');

	370 }, "paused -> set startTime");

	371

	372 test(function() {

	373 var player = finishedPlayer();

	374 player.play();

	375 assert_unresolved(player.startTime);

	376 assert_equals(player.currentTime, 0);

	377 assert_equals(player.playState, 'pending');

	378 }, "finished -> play()");

	379

	380 test(function() {

	381 var player = finishedPlayer();

	382 player.pause();

	383 assert_unresolved(player.startTime);

	384 assert_equals(player.currentTime, 100000);

	385 assert_equals(player.playState, 'paused');

	386 }, "finished -> pause()");

	387

	388 test(function() {

	389 var player = finishedPlayer();

	390 player.cancel();

	391 assert_unresolved(player.startTime);

	392 assert_unresolved(player.currentTime);

	393 assert_equals(player.playState, 'idle');

	394 }, "finished -> cancel()");

	395

	396 test(function() {

	397 var player = finishedPlayer();

	398 player.finish();

	399 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	400 assert_equals(player.currentTime, 100000);

	401 assert_equals(player.playState, 'finished');

	402 }, "finished -> finish()");

	403

	404 test(function() {

	405 var player = finishedPlayer();

	406 player.reverse();

	407 assert_unresolved(player.startTime);

	408 assert_equals(player.currentTime, 100000);

	409 assert_equals(player.playState, 'pending');

	410 }, "finished -> reverse()");

	411

	412 test(function() {

	413 var player = finishedPlayer();

	414 player.currentTime = 1000;

	415 assert_equals(player.startTime, document.timeline.currentTime - player.current Time);

	416 assert_equals(player.currentTime, 1000);

	417 assert_equals(player.playState, 'running');

	418 }, "finished -> set currentTime");

	419 </script>

OLD	NEW

« no previous file with comments | « no previous file | Source/core/animation/AnimationPlayer.cpp » ('j') | no next file with comments »