Bug 1415448 - Consistently use single quotes for string literals in web-platform-tests/web-animations; r=hiro
authorBrian Birtles <birtles@gmail.com>
Thu, 16 Nov 2017 12:38:04 +0900
changeset 436676 b0811e58e9322569f276ec8b4e5f8716f53f0158
parent 436675 31f60780e3c0abe34540c10f85fba07ccc3f5b7a
child 436677 066264c8cc1f1ccb4140258caf00b5fe7d67f703
push id117
push userfmarier@mozilla.com
push dateTue, 28 Nov 2017 20:17:16 +0000
reviewershiro
bugs1415448
milestone59.0a1
Bug 1415448 - Consistently use single quotes for string literals in web-platform-tests/web-animations; r=hiro We will introduce template literals in the next patch in this series. MozReview-Commit-ID: H0cF0SjI1U5
testing/web-platform/tests/web-animations/interfaces/Animation/constructor.html
testing/web-platform/tests/web-animations/interfaces/Animation/effect.html
testing/web-platform/tests/web-animations/interfaces/Animation/finished.html
testing/web-platform/tests/web-animations/interfaces/Animation/id.html
testing/web-platform/tests/web-animations/interfaces/Animation/oncancel.html
testing/web-platform/tests/web-animations/interfaces/Animation/onfinish.html
testing/web-platform/tests/web-animations/interfaces/Animation/pause.html
testing/web-platform/tests/web-animations/interfaces/Animation/playbackRate.html
testing/web-platform/tests/web-animations/interfaces/Animation/ready.html
testing/web-platform/tests/web-animations/interfaces/AnimationEffectTiming/endDelay.html
testing/web-platform/tests/web-animations/interfaces/AnimationEffectTiming/fill.html
testing/web-platform/tests/web-animations/interfaces/Document/getAnimations.html
testing/web-platform/tests/web-animations/interfaces/DocumentTimeline/constructor.html
testing/web-platform/tests/web-animations/interfaces/KeyframeEffect/getComputedTiming.html
testing/web-platform/tests/web-animations/interfaces/KeyframeEffect/processing-a-keyframes-argument-001.html
testing/web-platform/tests/web-animations/interfaces/KeyframeEffect/target.html
testing/web-platform/tests/web-animations/testcommon.js
testing/web-platform/tests/web-animations/timing-model/animations/canceling-an-animation.html
testing/web-platform/tests/web-animations/timing-model/animations/reversing-an-animation.html
--- 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).