--- a/testing/web-platform/tests/web-animations/interfaces/Animation/constructor.html
+++ b/testing/web-platform/tests/web-animations/interfaces/Animation/constructor.html
@@ -4,111 +4,111 @@
<link rel="help" href="https://w3c.github.io/web-animations/#dom-animation-animation">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="../../testcommon.js"></script>
<body>
<div id="log"></div>
<div id="target"></div>
<script>
-"use strict";
+'use strict';
-const gTarget = document.getElementById("target");
+const gTarget = document.getElementById('target');
function createEffect() {
return new KeyframeEffectReadOnly(gTarget, { opacity: [0, 1] });
}
function createNull() {
return null;
}
const gTestArguments = [
{
createEffect: createNull,
timeline: null,
expectedTimeline: null,
- expectedTimelineDescription: "null",
- description: "with null effect and null timeline"
+ expectedTimelineDescription: 'null',
+ description: 'with null effect and null timeline'
},
{
createEffect: createNull,
timeline: document.timeline,
expectedTimeline: document.timeline,
- expectedTimelineDescription: "document.timeline",
- description: "with null effect and non-null timeline"
+ expectedTimelineDescription: 'document.timeline',
+ description: 'with null effect and non-null timeline'
},
{
createEffect: createNull,
expectedTimeline: document.timeline,
- expectedTimelineDescription: "document.timeline",
- description: "with null effect and no timeline parameter"
+ expectedTimelineDescription: 'document.timeline',
+ description: 'with null effect and no timeline parameter'
},
{
createEffect: createEffect,
timeline: null,
expectedTimeline: null,
- expectedTimelineDescription: "null",
- description: "with non-null effect and null timeline"
+ expectedTimelineDescription: 'null',
+ description: 'with non-null effect and null timeline'
},
{
createEffect: createEffect,
timeline: document.timeline,
expectedTimeline: document.timeline,
- expectedTimelineDescription: "document.timeline",
- description: "with non-null effect and non-null timeline"
+ expectedTimelineDescription: 'document.timeline',
+ description: 'with non-null effect and non-null timeline'
},
{
createEffect: createEffect,
expectedTimeline: document.timeline,
- expectedTimelineDescription: "document.timeline",
- description: "with non-null effect and no timeline parameter"
+ expectedTimelineDescription: 'document.timeline',
+ description: 'with non-null effect and no timeline parameter'
},
];
gTestArguments.forEach(args => {
test(t => {
const effect = args.createEffect();
const animation = new Animation(effect, args.timeline);
assert_not_equals(animation, null,
- "An animation sohuld be created");
+ 'An animation sohuld be created');
assert_equals(animation.effect, effect,
- "Animation returns the same effect passed to " +
- "the Constructor");
+ 'Animation returns the same effect passed to ' +
+ 'the Constructor');
assert_equals(animation.timeline, args.expectedTimeline,
- "Animation timeline should be " + args.expectedTimelineDescription);
- assert_equals(animation.playState, "idle",
- "Animation.playState should be initially 'idle'");
- }, "Animation can be constructed " + args.description);
+ 'Animation timeline should be ' + args.expectedTimelineDescription);
+ assert_equals(animation.playState, 'idle',
+ 'Animation.playState should be initially \'idle\'');
+ }, 'Animation can be constructed ' + args.description);
});
test(t => {
const effect = new KeyframeEffectReadOnly(null,
- { left: ["10px", "20px"] },
+ { left: ['10px', '20px'] },
{ duration: 10000,
- fill: "forwards" });
+ fill: 'forwards' });
const anim = new Animation(effect, document.timeline);
anim.pause();
assert_equals(effect.getComputedTiming().progress, 0.0);
anim.currentTime += 5000;
assert_equals(effect.getComputedTiming().progress, 0.5);
anim.finish();
assert_equals(effect.getComputedTiming().progress, 1.0);
-}, "Animation constructed by an effect with null target runs normally");
+}, 'Animation constructed by an effect with null target runs normally');
async_test(t => {
const iframe = document.createElement('iframe');
iframe.addEventListener('load', t.step_func(() => {
const div = createDiv(t, iframe.contentDocument);
const effect = new KeyframeEffectReadOnly(div, null, 10000);
const anim = new Animation(effect);
assert_equals(anim.timeline, document.timeline);
iframe.remove();
t.done();
}));
document.body.appendChild(iframe);
-}, "Animation constructed with a keyframe that target element is in iframe");
+}, 'Animation constructed with a keyframe that target element is in iframe');
</script>
</body>
--- a/testing/web-platform/tests/web-animations/interfaces/Animation/effect.html
+++ b/testing/web-platform/tests/web-animations/interfaces/Animation/effect.html
@@ -3,26 +3,26 @@
<title>Animation.effect</title>
<link rel="help" href="https://w3c.github.io/web-animations/#dom-animation-effect">
<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";
+'use strict';
test(t => {
const anim = new Animation();
- assert_equals(anim.effect, null, "initial effect is null");
+ assert_equals(anim.effect, null, 'initial effect is null');
const newEffect = new KeyframeEffectReadOnly(createDiv(t), null);
anim.effect = newEffect;
- assert_equals(anim.effect, newEffect, "new effect is set");
-}, "effect is set correctly.");
+ assert_equals(anim.effect, newEffect, 'new effect is set');
+}, 'effect is set correctly.');
test(t => {
const div = createDiv(t);
const animation = div.animate({ left: ['100px', '100px'] },
{ fill: 'forwards' });
const effect = animation.effect;
assert_equals(getComputedStyle(div).left, '100px',
--- a/testing/web-platform/tests/web-animations/interfaces/Animation/finished.html
+++ b/testing/web-platform/tests/web-animations/interfaces/Animation/finished.html
@@ -3,17 +3,17 @@
<title>Animation.finished</title>
<link rel="help" href="https://w3c.github.io/web-animations/#dom-animation-finished">
<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";
+'use strict';
promise_test(t => {
const div = createDiv(t);
const animation = div.animate({}, 100 * MS_PER_SEC);
const previousFinishedPromise = animation.finished;
return animation.ready.then(() => {
assert_equals(animation.finished, previousFinishedPromise,
'Finished promise is the same object when playing starts');
--- a/testing/web-platform/tests/web-animations/interfaces/Animation/id.html
+++ b/testing/web-platform/tests/web-animations/interfaces/Animation/id.html
@@ -3,17 +3,17 @@
<title>Animation.id</title>
<link rel="help" href="https://w3c.github.io/web-animations/#dom-animation-id">
<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";
+'use strict';
test(t => {
const div = createDiv(t);
const animation = div.animate({}, 100 * MS_PER_SEC);
assert_equals(animation.id, '', 'id for Animation is initially empty');
}, 'Animation.id initial value');
test(t => {
--- a/testing/web-platform/tests/web-animations/interfaces/Animation/oncancel.html
+++ b/testing/web-platform/tests/web-animations/interfaces/Animation/oncancel.html
@@ -3,17 +3,17 @@
<title>Animation.oncancel</title>
<link rel="help" href="https://w3c.github.io/web-animations/#dom-animation-oncancel">
<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";
+'use strict';
async_test(t => {
const div = createDiv(t);
const animation = div.animate({}, 100 * MS_PER_SEC);
let finishedTimelineTime;
animation.finished.then().catch(() => {
finishedTimelineTime = animation.timeline.currentTime;
});
--- a/testing/web-platform/tests/web-animations/interfaces/Animation/onfinish.html
+++ b/testing/web-platform/tests/web-animations/interfaces/Animation/onfinish.html
@@ -3,17 +3,17 @@
<title>Animation.onfinish</title>
<link rel="help" href="https://w3c.github.io/web-animations/#dom-animation-onfinish">
<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";
+'use strict';
async_test(t => {
const div = createDiv(t);
const animation = div.animate({}, 100 * MS_PER_SEC);
let finishedTimelineTime;
animation.finished.then(() => {
finishedTimelineTime = animation.timeline.currentTime;
});
--- a/testing/web-platform/tests/web-animations/interfaces/Animation/pause.html
+++ b/testing/web-platform/tests/web-animations/interfaces/Animation/pause.html
@@ -3,17 +3,17 @@
<title>Animation.pause</title>
<link rel="help" href="https://w3c.github.io/web-animations/#dom-animation-pause">
<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";
+'use strict';
promise_test(t => {
const div = createDiv(t);
const animation = div.animate({}, 1000 * MS_PER_SEC);
let previousCurrentTime = animation.currentTime;
return animation.ready.then(waitForAnimationFrames(1)).then(() => {
assert_true(animation.currentTime >= previousCurrentTime,
--- a/testing/web-platform/tests/web-animations/interfaces/Animation/playbackRate.html
+++ b/testing/web-platform/tests/web-animations/interfaces/Animation/playbackRate.html
@@ -3,17 +3,17 @@
<title>Animation.playbackRate</title>
<link rel="help" href="https://w3c.github.io/web-animations/#dom-animation-playbackrate">
<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";
+'use strict';
function assert_playbackrate(animation,
previousAnimationCurrentTime,
previousTimelineCurrentTime,
description) {
const accuracy = 0.001; /* accuracy of DOMHighResTimeStamp */
const animationCurrentTimeDifference =
animation.currentTime - previousAnimationCurrentTime;
--- a/testing/web-platform/tests/web-animations/interfaces/Animation/ready.html
+++ b/testing/web-platform/tests/web-animations/interfaces/Animation/ready.html
@@ -3,17 +3,17 @@
<title>Animation.ready</title>
<link rel="help" href="https://w3c.github.io/web-animations/#dom-animation-ready">
<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";
+'use strict';
promise_test(t => {
const div = createDiv(t);
const animation = div.animate(null, 100 * MS_PER_SEC);
const originalReadyPromise = animation.ready;
let pauseReadyPromise;
return animation.ready.then(() => {
--- a/testing/web-platform/tests/web-animations/interfaces/AnimationEffectTiming/endDelay.html
+++ b/testing/web-platform/tests/web-animations/interfaces/AnimationEffectTiming/endDelay.html
@@ -32,25 +32,25 @@ test(t => {
assert_equals(anim.effect.timing.endDelay, -1000, 'set endDelay -1000');
assert_equals(anim.effect.getComputedTiming().endDelay, -1000,
'getComputedTiming() after set endDelay -1000');
}, 'Can be set to a negative number');
test(t => {
const div = createDiv(t);
const anim = div.animate({ opacity: [ 0, 1 ] }, 2000);
- assert_throws({name: "TypeError"}, () => {
+ assert_throws({ name: 'TypeError' }, () => {
anim.effect.timing.endDelay = Infinity;
}, 'we can not assign Infinity to timing.endDelay');
}, 'Throws when setting infinity');
test(t => {
const div = createDiv(t);
const anim = div.animate({ opacity: [ 0, 1 ] }, 2000);
- assert_throws({name: "TypeError"}, () => {
+ assert_throws({ name: 'TypeError' }, () => {
anim.effect.timing.endDelay = -Infinity;
}, 'we can not assign negative Infinity to timing.endDelay');
}, 'Throws when setting negative infinity');
async_test(t => {
const div = createDiv(t);
const anim = div.animate({ opacity: [ 0, 1 ] },
{ duration: 100000, endDelay: 50000 });
--- a/testing/web-platform/tests/web-animations/interfaces/AnimationEffectTiming/fill.html
+++ b/testing/web-platform/tests/web-animations/interfaces/AnimationEffectTiming/fill.html
@@ -10,17 +10,17 @@
<script>
'use strict';
test(t => {
const anim = createDiv(t).animate(null);
assert_equals(anim.effect.timing.fill, 'auto');
}, 'Has the default value \'auto\'');
-["none", "forwards", "backwards", "both", ].forEach(fill => {
+['none', 'forwards', 'backwards', 'both', ].forEach(fill => {
test(t => {
const div = createDiv(t);
const anim = div.animate({ opacity: [ 0, 1 ] }, 100);
anim.effect.timing.fill = fill;
assert_equals(anim.effect.timing.fill, fill, 'set fill ' + fill);
assert_equals(anim.effect.getComputedTiming().fill, fill,
'getComputedTiming() after set fill ' + fill);
}, 'Can set fill to ' + fill);
--- a/testing/web-platform/tests/web-animations/interfaces/Document/getAnimations.html
+++ b/testing/web-platform/tests/web-animations/interfaces/Document/getAnimations.html
@@ -4,17 +4,17 @@
<link rel="help" href="https://w3c.github.io/web-animations/#dom-document-getanimations">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="../../testcommon.js"></script>
<body>
<div id="log"></div>
<div id="target"></div>
<script>
-"use strict";
+'use strict';
const gKeyFrames = { 'marginLeft': ['100px', '200px'] };
test(t => {
assert_equals(document.getAnimations().length, 0,
'getAnimations returns an empty sequence for a document ' +
'with no animations');
}, 'Test document.getAnimations for non-animated content');
--- a/testing/web-platform/tests/web-animations/interfaces/DocumentTimeline/constructor.html
+++ b/testing/web-platform/tests/web-animations/interfaces/DocumentTimeline/constructor.html
@@ -3,17 +3,17 @@
<title>DocumentTimeline constructor tests</title>
<link rel="help" href="https://w3c.github.io/web-animations/#the-documenttimeline-interface">
<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";
+'use strict';
test(t => {
const timeline = new DocumentTimeline();
assert_times_equal(timeline.currentTime, document.timeline.currentTime);
}, 'An origin time of zero is used when none is supplied');
test(t => {
--- a/testing/web-platform/tests/web-animations/interfaces/KeyframeEffect/getComputedTiming.html
+++ b/testing/web-platform/tests/web-animations/interfaces/KeyframeEffect/getComputedTiming.html
@@ -4,208 +4,208 @@
<link rel="help" href="https://w3c.github.io/web-animations/#dom-animationeffectreadonly-getcomputedtiming">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="../../testcommon.js"></script>
<body>
<div id="log"></div>
<div id="target"></div>
<script>
-"use strict";
+'use strict';
-const target = document.getElementById("target");
+const target = document.getElementById('target');
test(t => {
const effect = new KeyframeEffectReadOnly(target,
- { left: ["10px", "20px"] });
+ { left: ['10px', '20px'] });
const ct = effect.getComputedTiming();
- assert_equals(ct.delay, 0, "computed delay");
- assert_equals(ct.fill, "none", "computed fill");
- assert_equals(ct.iterations, 1.0, "computed iterations");
- assert_equals(ct.duration, 0, "computed duration");
- assert_equals(ct.direction, "normal", "computed direction");
-}, "values of getComputedTiming() when a KeyframeEffectReadOnly is " +
- "constructed without any KeyframeEffectOptions object");
+ assert_equals(ct.delay, 0, 'computed delay');
+ assert_equals(ct.fill, 'none', 'computed fill');
+ assert_equals(ct.iterations, 1.0, 'computed iterations');
+ assert_equals(ct.duration, 0, 'computed duration');
+ assert_equals(ct.direction, 'normal', 'computed direction');
+}, 'values of getComputedTiming() when a KeyframeEffectReadOnly is ' +
+ 'constructed without any KeyframeEffectOptions object');
const gGetComputedTimingTests = [
- { desc: "an empty KeyframeEffectOptions object",
+ { desc: 'an empty KeyframeEffectOptions object',
input: { },
expected: { } },
- { desc: "a normal KeyframeEffectOptions object",
+ { desc: 'a normal KeyframeEffectOptions object',
input: { delay: 1000,
- fill: "auto",
+ fill: 'auto',
iterations: 5.5,
- duration: "auto",
- direction: "alternate" },
+ duration: 'auto',
+ direction: 'alternate' },
expected: { delay: 1000,
- fill: "none",
+ fill: 'none',
iterations: 5.5,
duration: 0,
- direction: "alternate" } },
- { desc: "a double value",
+ direction: 'alternate' } },
+ { desc: 'a double value',
input: 3000,
timing: { duration: 3000 },
expected: { delay: 0,
- fill: "none",
+ fill: 'none',
iterations: 1,
duration: 3000,
- direction: "normal" } },
- { desc: "+Infinity",
+ direction: 'normal' } },
+ { desc: '+Infinity',
input: Infinity,
expected: { duration: Infinity } },
- { desc: "an Infinity duration",
+ { desc: 'an Infinity duration',
input: { duration: Infinity },
expected: { duration: Infinity } },
- { desc: "an auto duration",
- input: { duration: "auto" },
+ { desc: 'an auto duration',
+ input: { duration: 'auto' },
expected: { duration: 0 } },
- { desc: "an Infinity iterations",
+ { desc: 'an Infinity iterations',
input: { iterations: Infinity },
expected: { iterations: Infinity } },
- { desc: "an auto fill",
- input: { fill: "auto" },
- expected: { fill: "none" } },
- { desc: "a forwards fill",
- input: { fill: "forwards" },
- expected: { fill: "forwards" } }
+ { desc: 'an auto fill',
+ input: { fill: 'auto' },
+ expected: { fill: 'none' } },
+ { desc: 'a forwards fill',
+ input: { fill: 'forwards' },
+ expected: { fill: 'forwards' } }
];
gGetComputedTimingTests.forEach(stest => {
test(t => {
const effect = new KeyframeEffectReadOnly(target,
- { left: ["10px", "20px"] },
+ { left: ['10px', '20px'] },
stest.input);
// Helper function to provide default expected values when the test does
// not supply them.
const expected = (field, defaultValue) => {
return field in stest.expected ? stest.expected[field] : defaultValue;
};
const ct = effect.getComputedTiming();
- assert_equals(ct.delay, expected("delay", 0),
- "computed delay");
- assert_equals(ct.fill, expected("fill", "none"),
- "computed fill");
- assert_equals(ct.iterations, expected("iterations", 1),
- "computed iterations");
- assert_equals(ct.duration, expected("duration", 0),
- "computed duration");
- assert_equals(ct.direction, expected("direction", "normal"),
- "computed direction");
+ assert_equals(ct.delay, expected('delay', 0),
+ 'computed delay');
+ assert_equals(ct.fill, expected('fill', 'none'),
+ 'computed fill');
+ assert_equals(ct.iterations, expected('iterations', 1),
+ 'computed iterations');
+ assert_equals(ct.duration, expected('duration', 0),
+ 'computed duration');
+ assert_equals(ct.direction, expected('direction', 'normal'),
+ 'computed direction');
- }, "values of getComputedTiming() when a KeyframeEffectReadOnly is " +
- "constructed by " + stest.desc);
+ }, 'values of getComputedTiming() when a KeyframeEffectReadOnly is ' +
+ 'constructed by ' + stest.desc);
});
const gActiveDurationTests = [
- { desc: "an empty KeyframeEffectOptions object",
+ { desc: 'an empty KeyframeEffectOptions object',
input: { },
expected: 0 },
- { desc: "a non-zero duration and default iteration count",
+ { desc: 'a non-zero duration and default iteration count',
input: { duration: 1000 },
expected: 1000 },
- { desc: "a non-zero duration and integral iteration count",
+ { desc: 'a non-zero duration and integral iteration count',
input: { duration: 1000, iterations: 7 },
expected: 7000 },
- { desc: "a non-zero duration and fractional iteration count",
+ { desc: 'a non-zero duration and fractional iteration count',
input: { duration: 1000, iterations: 2.5 },
expected: 2500 },
- { desc: "an non-zero duration and infinite iteration count",
+ { desc: 'an non-zero duration and infinite iteration count',
input: { duration: 1000, iterations: Infinity },
expected: Infinity },
- { desc: "an non-zero duration and zero iteration count",
+ { desc: 'an non-zero duration and zero iteration count',
input: { duration: 1000, iterations: 0 },
expected: 0 },
- { desc: "a zero duration and default iteration count",
+ { desc: 'a zero duration and default iteration count',
input: { duration: 0 },
expected: 0 },
- { desc: "a zero duration and fractional iteration count",
+ { desc: 'a zero duration and fractional iteration count',
input: { duration: 0, iterations: 2.5 },
expected: 0 },
- { desc: "a zero duration and infinite iteration count",
+ { desc: 'a zero duration and infinite iteration count',
input: { duration: 0, iterations: Infinity },
expected: 0 },
- { desc: "a zero duration and zero iteration count",
+ { desc: 'a zero duration and zero iteration count',
input: { duration: 0, iterations: 0 },
expected: 0 },
- { desc: "an infinite duration and default iteration count",
+ { desc: 'an infinite duration and default iteration count',
input: { duration: Infinity },
expected: Infinity },
- { desc: "an infinite duration and zero iteration count",
+ { desc: 'an infinite duration and zero iteration count',
input: { duration: Infinity, iterations: 0 },
expected: 0 },
- { desc: "an infinite duration and fractional iteration count",
+ { desc: 'an infinite duration and fractional iteration count',
input: { duration: Infinity, iterations: 2.5 },
expected: Infinity },
- { desc: "an infinite duration and infinite iteration count",
+ { desc: 'an infinite duration and infinite iteration count',
input: { duration: Infinity, iterations: Infinity },
expected: Infinity },
];
gActiveDurationTests.forEach(stest => {
test(t => {
const effect = new KeyframeEffectReadOnly(target,
- { left: ["10px", "20px"] },
+ { left: ['10px', '20px'] },
stest.input);
assert_equals(effect.getComputedTiming().activeDuration,
stest.expected);
- }, "getComputedTiming().activeDuration for " + stest.desc);
+ }, 'getComputedTiming().activeDuration for ' + stest.desc);
});
const gEndTimeTests = [
- { desc: "an empty KeyframeEffectOptions object",
+ { desc: 'an empty KeyframeEffectOptions object',
input: { },
expected: 0 },
- { desc: "a non-zero duration and default iteration count",
+ { desc: 'a non-zero duration and default iteration count',
input: { duration: 1000 },
expected: 1000 },
- { desc: "a non-zero duration and non-default iteration count",
+ { desc: 'a non-zero duration and non-default iteration count',
input: { duration: 1000, iterations: 2.5 },
expected: 2500 },
- { desc: "a non-zero duration and non-zero delay",
+ { desc: 'a non-zero duration and non-zero delay',
input: { duration: 1000, delay: 1500 },
expected: 2500 },
- { desc: "a non-zero duration, non-zero delay and non-default iteration",
+ { desc: 'a non-zero duration, non-zero delay and non-default iteration',
input: { duration: 1000, delay: 1500, iterations: 2 },
expected: 3500 },
- { desc: "an infinite iteration count",
+ { desc: 'an infinite iteration count',
input: { duration: 1000, iterations: Infinity },
expected: Infinity },
- { desc: "an infinite duration",
+ { desc: 'an infinite duration',
input: { duration: Infinity, iterations: 10 },
expected: Infinity },
- { desc: "an infinite duration and delay",
+ { desc: 'an infinite duration and delay',
input: { duration: Infinity, iterations: 10, delay: 1000 },
expected: Infinity },
- { desc: "an infinite duration and negative delay",
+ { desc: 'an infinite duration and negative delay',
input: { duration: Infinity, iterations: 10, delay: -1000 },
expected: Infinity },
- { desc: "an non-zero duration and negative delay",
+ { desc: 'an non-zero duration and negative delay',
input: { duration: 1000, iterations: 2, delay: -1000 },
expected: 1000 },
- { desc: "an non-zero duration and negative delay greater than active " +
- "duration",
+ { desc: 'an non-zero duration and negative delay greater than active ' +
+ 'duration',
input: { duration: 1000, iterations: 2, delay: -3000 },
expected: 0 },
- { desc: "a zero duration and negative delay",
+ { desc: 'a zero duration and negative delay',
input: { duration: 0, iterations: 2, delay: -1000 },
expected: 0 }
];
gEndTimeTests.forEach(stest => {
test(t => {
const effect = new KeyframeEffectReadOnly(target,
- { left: ["10px", "20px"] },
+ { left: ['10px', '20px'] },
stest.input);
assert_equals(effect.getComputedTiming().endTime,
stest.expected);
- }, "getComputedTiming().endTime for " + stest.desc);
+ }, 'getComputedTiming().endTime for ' + stest.desc);
});
done();
</script>
</body>
--- a/testing/web-platform/tests/web-animations/interfaces/KeyframeEffect/processing-a-keyframes-argument-001.html
+++ b/testing/web-platform/tests/web-animations/interfaces/KeyframeEffect/processing-a-keyframes-argument-001.html
@@ -196,17 +196,17 @@ test(() => {
keyframes.easing = 'ease-in-out';
keyframes.offset = '0.1';
const effect = new KeyframeEffect(null, keyframes);
assert_frame_lists_equal(effect.getKeyframes(), [
{ offset: null, computedOffset: 0, easing: 'linear', left: '100px' },
{ offset: null, computedOffset: 0.5, easing: 'linear', left: '300px' },
{ offset: null, computedOffset: 1, easing: 'linear', left: '200px' },
]);
-}, "'easing' and 'offset' are ignored on iterable objects");
+}, '\'easing\' and \'offset\' are ignored on iterable objects');
test(() => {
const effect = new KeyframeEffect(null, createIterable([
{ done: false, value: { left: '100px', top: '200px' } },
{ done: false, value: { left: '300px' } },
{ done: false, value: { left: '200px', top: '100px' } },
{ done: true },
]));
--- a/testing/web-platform/tests/web-animations/interfaces/KeyframeEffect/target.html
+++ b/testing/web-platform/tests/web-animations/interfaces/KeyframeEffect/target.html
@@ -4,17 +4,17 @@
<link rel="help"
href="https://w3c.github.io/web-animations/#dom-keyframeeffect-target">
<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";
+'use strict';
const gKeyFrames = { 'marginLeft': ['0px', '100px'] };
test(t => {
const div = createDiv(t);
const effect = new KeyframeEffect(null, gKeyFrames, 100 * MS_PER_SEC);
effect.target = div;
--- a/testing/web-platform/tests/web-animations/testcommon.js
+++ b/testing/web-platform/tests/web-animations/testcommon.js
@@ -232,11 +232,11 @@ function assert_matrix_equals(actual, ex
actual.match(matrixRegExp)[1].split(',').map(Number);
const expectedMatrixArray =
expected.match(matrixRegExp)[1].split(',').map(Number);
assert_equals(actualMatrixArray.length, expectedMatrixArray.length,
'dimension of the matrix: ' + description);
for (let i = 0; i < actualMatrixArray.length; i++) {
assert_approx_equals(actualMatrixArray[i], expectedMatrixArray[i], 0.0001,
- 'expected ' + expected + ' but got ' + actual + ": " + description);
+ 'expected ' + expected + ' but got ' + actual + ': ' + description);
}
}
--- a/testing/web-platform/tests/web-animations/timing-model/animations/canceling-an-animation.html
+++ b/testing/web-platform/tests/web-animations/timing-model/animations/canceling-an-animation.html
@@ -4,17 +4,17 @@
<link rel="help"
href="https://w3c.github.io/web-animations/#canceling-an-animation-section">
<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";
+'use strict';
promise_test(t => {
const animation = createDiv(t).animate(null, 100 * MS_PER_SEC);
const retPromise = animation.ready.then(() => {
assert_unreached('ready promise was fulfilled');
}).catch(err => {
assert_equals(err.name, 'AbortError',
'ready promise is rejected with AbortError');
--- a/testing/web-platform/tests/web-animations/timing-model/animations/reversing-an-animation.html
+++ b/testing/web-platform/tests/web-animations/timing-model/animations/reversing-an-animation.html
@@ -4,17 +4,17 @@
<link rel="help"
href="https://w3c.github.io/web-animations/#reverse-an-animation">
<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";
+'use strict';
promise_test(t => {
const div = createDiv(t);
const animation = div.animate({}, { duration: 100 * MS_PER_SEC,
iterations: Infinity });
// Wait a frame because if currentTime is still 0 when we call
// reverse(), it will throw (per spec).