1 files changed, 53 insertions, 55 deletions
diff --git a/tests/wpt/web-platform-tests/web-animations/interfaces/KeyframeEffect/constructor.html b/tests/wpt/web-platform-tests/web-animations/interfaces/KeyframeEffect/constructor.html
index 711b4ed7bd7..b257257b2ca 100644
--- a/tests/wpt/web-platform-tests/web-animations/interfaces/KeyframeEffect/constructor.html
+++ b/tests/wpt/web-platform-tests/web-animations/interfaces/KeyframeEffect/constructor.html
@@ -2,9 +2,9 @@
 <meta charset=utf-8>
 <title>KeyframeEffect and KeyframeEffectReadOnly constructor</title>
 <link rel="help"
-      href="https://w3c.github.io/web-animations/#dom-keyframeeffect-keyframeeffect">
+      href="https://drafts.csswg.org/web-animations/#dom-keyframeeffect-keyframeeffect">
 <link rel="help"
-      href="https://w3c.github.io/web-animations/#dom-keyframeeffectreadonly-keyframeeffectreadonly">
+      href="https://drafts.csswg.org/web-animations/#dom-keyframeeffectreadonly-keyframeeffectreadonly">
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="../../testcommon.js"></script>
@@ -19,16 +19,16 @@
 
 const target = document.getElementById('target');
 
-test(function(t) {
-  gEmptyKeyframeListTests.forEach(function(frames) {
+test(t => {
+  for (const frames of gEmptyKeyframeListTests) {
     assert_equals(new KeyframeEffectReadOnly(target, frames)
                         .getKeyframes().length,
-                  0, 'number of frames for ' + JSON.stringify(frames));
-  });
+                  0, `number of frames for ${JSON.stringify(frames)}`);
+  }
 }, 'A KeyframeEffectReadOnly can be constructed with no frames');
 
-test(function(t) {
-  gEasingParsingTests.forEach(function(subtest) {
+test(t => {
+  for (const subtest of gEasingParsingTests) {
     const easing = subtest[0];
     const expected = subtest[1];
     const effect = new KeyframeEffectReadOnly(target, {
@@ -36,98 +36,96 @@ test(function(t) {
     }, { easing: easing });
     assert_equals(effect.timing.easing, expected,
                   `resulting easing for '${easing}'`);
-  });
+  }
 }, 'easing values are parsed correctly when passed to the ' +
    'KeyframeEffectReadOnly constructor in KeyframeEffectOptions');
 
-test(function(t) {
-  gInvalidEasings.forEach(invalidEasing => {
+test(t => {
+  for (const invalidEasing of gInvalidEasings) {
     assert_throws(new TypeError, () => {
       new KeyframeEffectReadOnly(target, null, { easing: invalidEasing });
     }, `TypeError is thrown for easing '${invalidEasing}'`);
-  });
+  }
 }, 'Invalid easing values are correctly rejected when passed to the ' +
    'KeyframeEffectReadOnly constructor in KeyframeEffectOptions');
 
-test(function(t) {
-  const getKeyframe = function(composite) {
-    return { left: [ '10px', '20px' ], composite: composite };
-  };
-  gGoodKeyframeCompositeValueTests.forEach(function(composite) {
+test(t => {
+  const getKeyframe =
+    composite => ({ left: [ '10px', '20px' ], composite: composite });
+  for (const composite of gGoodKeyframeCompositeValueTests) {
     const effect = new KeyframeEffectReadOnly(target, getKeyframe(composite));
     assert_equals(effect.getKeyframes()[0].composite, composite,
                   `resulting composite for '${composite}'`);
-  });
-  gBadCompositeValueTests.forEach(function(composite) {
-    assert_throws(new TypeError, function() {
+  }
+  for (const composite of gBadCompositeValueTests) {
+    assert_throws(new TypeError, () => {
       new KeyframeEffectReadOnly(target, getKeyframe(composite));
     });
-  });
+  }
 }, 'composite values are parsed correctly when passed to the ' +
    'KeyframeEffectReadOnly constructor in property-indexed keyframes');
 
-test(function(t) {
-  const getKeyframes = function(composite) {
-    return [
+test(t => {
+  const getKeyframes = composite =>
+    [
       { offset: 0, left: '10px', composite: composite },
       { offset: 1, left: '20px' }
     ];
-  };
-  gGoodKeyframeCompositeValueTests.forEach(function(composite) {
+  for (const composite of gGoodKeyframeCompositeValueTests) {
     const effect = new KeyframeEffectReadOnly(target, getKeyframes(composite));
     assert_equals(effect.getKeyframes()[0].composite, composite,
                   `resulting composite for '${composite}'`);
-  });
-  gBadCompositeValueTests.forEach(function(composite) {
-    assert_throws(new TypeError, function() {
+  }
+  for (const composite of gBadCompositeValueTests) {
+    assert_throws(new TypeError, () => {
       new KeyframeEffectReadOnly(target, getKeyframes(composite));
     });
-  });
+  }
 }, 'composite values are parsed correctly when passed to the ' +
    'KeyframeEffectReadOnly constructor in regular keyframes');
 
-test(function(t) {
-  gGoodOptionsCompositeValueTests.forEach(function(composite) {
+test(t => {
+  for (const composite of gGoodOptionsCompositeValueTests) {
     const effect = new KeyframeEffectReadOnly(target, {
       left: ['10px', '20px']
     }, { composite: composite });
     assert_equals(effect.getKeyframes()[0].composite, undefined,
                   `resulting composite for '${composite}'`);
-  });
-  gBadCompositeValueTests.forEach(function(composite) {
-    assert_throws(new TypeError, function() {
+  }
+  for (const composite of gBadCompositeValueTests) {
+    assert_throws(new TypeError, () => {
       new KeyframeEffectReadOnly(target, {
         left: ['10px', '20px']
       }, { composite: composite });
     });
-  });
+  }
 }, 'composite value is absent if the composite operation specified on the ' +
    'keyframe effect is being used');
 
-gKeyframesTests.forEach(function(subtest) {
-  test(function(t) {
+for (const subtest of gKeyframesTests) {
+  test(t => {
     const effect = new KeyframeEffectReadOnly(target, subtest.input);
     assert_frame_lists_equal(effect.getKeyframes(), subtest.output);
   }, `A KeyframeEffectReadOnly can be constructed with ${subtest.desc}`);
 
-  test(function(t) {
+  test(t => {
     const effect = new KeyframeEffectReadOnly(target, subtest.input);
     const secondEffect =
       new KeyframeEffectReadOnly(target, effect.getKeyframes());
     assert_frame_lists_equal(secondEffect.getKeyframes(),
                              effect.getKeyframes());
   }, `A KeyframeEffectReadOnly constructed with ${subtest.desc} roundtrips`);
-});
+}
 
-gInvalidKeyframesTests.forEach(function(subtest) {
-  test(function(t) {
-    assert_throws(new TypeError, function() {
+for (const subtest of gInvalidKeyframesTests) {
+  test(t => {
+    assert_throws(new TypeError, () => {
       new KeyframeEffectReadOnly(target, subtest.input);
     });
   }, `KeyframeEffectReadOnly constructor throws with ${subtest.desc}`);
-});
+}
 
-test(function(t) {
+test(t => {
   const effect = new KeyframeEffectReadOnly(target,
                                             { left: ['10px', '20px'] });
 
@@ -147,8 +145,8 @@ test(function(t) {
 }, 'A KeyframeEffectReadOnly constructed without any ' +
    'KeyframeEffectOptions object');
 
-gKeyframeEffectOptionTests.forEach(function(subtest) {
-  test(function(t) {
+for (const subtest of gKeyframeEffectOptionTests) {
+  test(t => {
     const effect = new KeyframeEffectReadOnly(target,
                                               { left: ['10px', '20px'] },
                                               subtest.input);
@@ -172,19 +170,19 @@ gKeyframeEffectOptionTests.forEach(function(subtest) {
                   'timing direction');
 
   }, `A KeyframeEffectReadOnly constructed by ${subtest.desc}`);
-});
+}
 
-gInvalidKeyframeEffectOptionTests.forEach(function(subtest) {
-  test(function(t) {
-    assert_throws(new TypeError, function() {
+for (const subtest of gInvalidKeyframeEffectOptionTests) {
+  test(t => {
+    assert_throws(new TypeError, () => {
       new KeyframeEffectReadOnly(target,
                                  { left: ['10px', '20px'] },
                                  subtest.input);
     });
   }, `Invalid KeyframeEffectReadOnly option by ${subtest.desc}`);
-});
+}
 
-test(function(t) {
+test(t => {
   const effect = new KeyframeEffectReadOnly(null,
                                             { left: ['10px', '20px'] },
                                             { duration: 100 * MS_PER_SEC,
@@ -193,10 +191,10 @@ test(function(t) {
                 'Effect created with null target has correct target');
 }, 'A KeyframeEffectReadOnly constructed with null target');
 
-test(function(t) {
+test(t => {
   const test_error = { name: 'test' };
 
-  assert_throws(test_error, function() {
+  assert_throws(test_error, () => {
     new KeyframeEffect(target, { get left() { throw test_error }})
   });
 }, 'KeyframeEffect constructor propagates exceptions generated by accessing'