Re: [web-animations-tests] Upstream animation-effect-timing-easing.html from Blink (#3337)

 [View the complete job log.](https://travis-ci.org/w3c/web-platform-tests/jobs/209638685)

# Chrome (unstable channel) #
Testing web-platform-tests at revision f64f9f07f4f2a23e851c4e80a80d85682d740878
Using browser at version 58.0.3029.6 dev
Starting 10 test iterations
All results were stable
## All results ##
<details>
<summary>5 tests ran</summary>
<details>
<summary><a href="http://w3c-test.org/submissions/3337/web-animations/animation-model/keyframe-effects/effect-value-transformed-distance.html">/web-animations/animation-model/keyframe-effects/effect-value-transformed-distance.html</a></summary>


|                                                                           Subtest                                                                           | Results |                                                                   Messages                                                                  |
|-------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------|
|                                                                                                                                                             | OK      |                                                                                                                                             |
| `A step-start function on a keyframe affects the resulting style`                                                                                           | PASS    |                                                                                                                                             |
| `A steps(1, start) function on a keyframe affects the resulting style`                                                                                      | PASS    |                                                                                                                                             |
| `A steps(2, start) function on a keyframe affects the resulting style`                                                                                      | PASS    |                                                                                                                                             |
| `A step-end function on a keyframe affects the resulting style`                                                                                             | PASS    |                                                                                                                                             |
| `A steps(1) function on a keyframe affects the resulting style`                                                                                             | PASS    |                                                                                                                                             |
| `A steps(1, end) function on a keyframe affects the resulting style`                                                                                        | PASS    |                                                                                                                                             |
| `A steps(2, end) function on a keyframe affects the resulting style`                                                                                        | PASS    |                                                                                                                                             |
| `A linear function on a keyframe affects the resulting style`                                                                                               | PASS    |                                                                                                                                             |
| `A ease function on a keyframe affects the resulting style`                                                                                                 | FAIL    | `assert_approx_equals: The width should be approximately 109.47963055884654 at 1100ms expected 109.47963055884654 +/- 0.01 but got 109.312` |
| `A ease-in function on a keyframe affects the resulting style`                                                                                              | PASS    |                                                                                                                                             |
| `A ease-in-out function on a keyframe affects the resulting style`                                                                                          | FAIL    | `assert_approx_equals: The width should be approximately 101.97224534417684 at 1100ms expected 101.97224534417684 +/- 0.01 but got 101.953` |
| `A ease-out function on a keyframe affects the resulting style`                                                                                             | FAIL    | `assert_approx_equals: The width should be approximately 116.05721544376388 at 1100ms expected 116.05721544376388 +/- 0.01 but got 116.078` |
| `A easing function which produces values greater than 1 on a keyframe affects the resulting style`                                                          | FAIL    | `assert_approx_equals: The width should be approximately 171.60874310990272 at 1100ms expected 171.60874310990272 +/- 0.01 but got 172.219` |
| `A easing function which produces values less than 1 on a keyframe affects the resulting style`                                                             | FAIL    | `assert_approx_equals: The width should be approximately 77.13128857063907 at 1100ms expected 77.13128857063907 +/- 0.01 but got 76.9531`   |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a step-start function does not alter the result`                                  | PASS    |                                                                                                                                             |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a steps(1, start) function does not alter the result`                             | PASS    |                                                                                                                                             |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a steps(2, start) function does not alter the result`                             | FAIL    | `assert_equals: The 'width' of the animated elements should be equal at 0ms expected "50.3438px" but got "50px"`                            |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a step-end function does not alter the result`                                    | PASS    |                                                                                                                                             |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a steps(1) function does not alter the result`                                    | PASS    |                                                                                                                                             |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a steps(1, end) function does not alter the result`                               | PASS    |                                                                                                                                             |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a steps(2, end) function does not alter the result`                               | FAIL    | `assert_equals: The 'width' of the animated elements should be equal at 500ms expected "50.3438px" but got "50px"`                          |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a linear function does not alter the result`                                      | FAIL    | `assert_equals: The 'width' of the animated elements should be equal at 250ms expected "25.0938px" but got "25px"`                          |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a ease function does not alter the result`                                        | FAIL    | `assert_equals: The 'width' of the animated elements should be equal at 250ms expected "41.875px" but got "41.8594px"`                      |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a ease-in function does not alter the result`                                     | FAIL    | `assert_equals: The 'width' of the animated elements should be equal at 250ms expected "8.95312px" but got "9.32812px"`                     |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a ease-in-out function does not alter the result`                                 | FAIL    | `assert_equals: The 'width' of the animated elements should be equal at 250ms expected "12.9375px" but got "12.875px"`                      |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a ease-out function does not alter the result`                                    | FAIL    | `assert_equals: The 'width' of the animated elements should be equal at 250ms expected "38.0469px" but got "37.9688px"`                     |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a easing function which produces values greater than 1 does not alter the result` | FAIL    | `assert_equals: The 'width' of the animated elements should be equal at 250ms expected "100px" but got "102.406px"`                         |
| `Linear-equivalent cubic-bezier keyframe easing applied to an effect with a easing function which produces values less than 1 does not alter the result`    | PASS    |                                                                                                                                             |
| `step-start easing with input progress greater than 1`                                                                                                      | FAIL    | `assert_equals: expected "200px" but got "100px"`                                                                                           |
| `step-end easing with input progress greater than 1`                                                                                                        | PASS    |                                                                                                                                             |
| `step-end easing with input progress greater than 2`                                                                                                        | FAIL    | `assert_equals: expected "200px" but got "100px"`                                                                                           |
| `step-start easing with input progress less than 0`                                                                                                         | PASS    |                                                                                                                                             |
| `step-start easing with input progress less than -1`                                                                                                        | FAIL    | `assert_equals: expected "-100px" but got "0px"`                                                                                            |
| `step-end easing with input progress less than 0`                                                                                                           | FAIL    | `assert_equals: expected "-100px" but got "0px"`                                                                                            |
| `cubic-bezier easing with input progress greater than 1`                                                                                                    | FAIL    | `Cannot read property 'timing' of undefined`                                                                                                |
| `cubic-bezier easing with input progress greater than 1 and where the tangent on the upper boundary is infinity`                                            | FAIL    | `Cannot read property 'timing' of undefined`                                                                                                |
| `cubic-bezier easing with input progress less than 0`                                                                                                       | FAIL    | `Cannot read property 'timing' of undefined`                                                                                                |
| `cubic-bezier easing with input progress less than 0 and where the tangent on the lower boundary is infinity`                                               | FAIL    | `Cannot read property 'timing' of undefined`                                                                                                |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/3337/web-animations/interfaces/Animatable/animate.html">/web-animations/interfaces/Animatable/animate.html</a></summary>


|                                                                             Subtest                                                                             | Results |                                                         Messages                                                         |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|--------------------------------------------------------------------------------------------------------------------------|
|                                                                                                                                                                 | OK      |                                                                                                                          |
| `Element.animate() creates an Animation object`                                                                                                                 | PASS    |                                                                                                                          |
| `Element.animate() creates an Animation object in the relevant realm of the target element`                                                                     | FAIL    | `Cannot read property 'prototype' of undefined`                                                                          |
| `Element.animate() creates an Animation object with a KeyframeEffect`                                                                                           | FAIL    | `assert_equals: Returned Animation has a KeyframeEffect expected "[object KeyframeEffect]" but got "[object Undefined]"` |
| `Element.animate() creates an Animation object with a KeyframeEffect that is created in the relevant realm of the target element`                               | FAIL    | `Cannot convert undefined or null to object`                                                                             |
| `Element.animate() creates an Animation object with a KeyframeEffect whose AnimationEffectTiming object is created in the relevant realm of the target element` | FAIL    | `Cannot read property 'timing' of undefined`                                                                             |
| `Element.animate() accepts empty keyframe lists (input: [])`                                                                                                    | PASS    |                                                                                                                          |
| `Element.animate() accepts empty keyframe lists (input: null)`                                                                                                  | PASS    |                                                                                                                          |
| `Element.animate() accepts empty keyframe lists (input: undefined)`                                                                                             | PASS    |                                                                                                                          |
| `Element.animate() accepts a one property two value property-indexed keyframes specification`                                                                   | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a one shorthand property two value property-indexed keyframes specification`                                                         | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a two property (one shorthand and one of its longhand components) two value property-indexed keyframes specification`                | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a two property two value property-indexed keyframes specification`                                                                   | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a two property property-indexed keyframes specification with different numbers of values`                                            | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a property-indexed keyframes specification with an invalid value`                                                                    | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a one property two value property-indexed keyframes specification that needs to stringify its values`                                | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a property-indexed keyframes specification with a CSS variable reference`                                                            | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a property-indexed keyframes specification with a CSS variable reference in a shorthand property`                                    | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a one property one value property-indexed keyframes specification`                                                                   | FAIL    | `Failed to execute 'animate' on 'Element': Partial keyframes are not supported.`                                         |
| `Element.animate() accepts a one property one non-array value property-indexed keyframes specification`                                                         | FAIL    | `Failed to execute 'animate' on 'Element': Partial keyframes are not supported.`                                         |
| `Element.animate() accepts a one property two value property-indexed keyframes specification where the first value is invalid`                                  | FAIL    | `Failed to execute 'animate' on 'Element': Partial keyframes are not supported.`                                         |
| `Element.animate() accepts a one property two value property-indexed keyframes specification where the second value is invalid`                                 | FAIL    | `Failed to execute 'animate' on 'Element': Partial keyframes are not supported.`                                         |
| `Element.animate() accepts a one property one keyframe sequence`                                                                                                | FAIL    | `Failed to execute 'animate' on 'Element': Partial keyframes are not supported.`                                         |
| `Element.animate() accepts a one property two keyframe sequence`                                                                                                | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a two property two keyframe sequence`                                                                                                | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a one shorthand property two keyframe sequence`                                                                                      | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a two property (a shorthand and one of its component longhands) two keyframe sequence`                                               | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a keyframe sequence with duplicate values for a given interior offset`                                                               | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a keyframe sequence with duplicate values for offsets 0 and 1`                                                                       | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a two property four keyframe sequence`                                                                                               | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a single keyframe sequence with omitted offset`                                                                                      | FAIL    | `Failed to execute 'animate' on 'Element': Partial keyframes are not supported.`                                         |
| `Element.animate() accepts a single keyframe sequence with null offset`                                                                                         | FAIL    | `Failed to execute 'animate' on 'Element': Partial keyframes are not supported.`                                         |
| `Element.animate() accepts a single keyframe sequence with string offset`                                                                                       | FAIL    | `Failed to execute 'animate' on 'Element': Partial keyframes are not supported.`                                         |
| `Element.animate() accepts a one property keyframe sequence with some omitted offsets`                                                                          | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a one property keyframe sequence with some null offsets`                                                                             | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a two property keyframe sequence with some omitted offsets`                                                                          | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a one property keyframe sequence with all omitted offsets`                                                                           | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a keyframe sequence with different easing values, but the same easing value for a given offset`                                      | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a keyframe sequence with different composite values, but the same composite value for a given offset`                                | FAIL    | `Failed to execute 'animate' on 'Element': Additive animations are not supported.`                                       |
| `Element.animate() accepts a one property two keyframe sequence that needs to stringify its values`                                                             | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a keyframe sequence with a CSS variable reference`                                                                                   | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a keyframe sequence with a CSS variable reference in a shorthand property`                                                           | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a keyframe sequence where shorthand precedes longhand`                                                                               | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a keyframe sequence where longhand precedes shorthand`                                                                               | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a keyframe sequence where lesser shorthand precedes greater shorthand`                                                               | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a keyframe sequence where greater shorthand precedes lesser shorthand`                                                               | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() accepts a two property keyframe sequence where one property is missing from the first keyframe`                                              | FAIL    | `Failed to execute 'animate' on 'Element': Partial keyframes are not supported.`                                         |
| `Element.animate() accepts a two property keyframe sequence where one property is missing from the last keyframe`                                               | FAIL    | `Failed to execute 'animate' on 'Element': Partial keyframes are not supported.`                                         |
| `Element.animate() accepts a keyframe sequence with repeated values at offset 1 with different easings`                                                         | FAIL    | `Cannot read property 'getKeyframes' of undefined`                                                                       |
| `Element.animate() does not accept keyframes with an out-of-bounded positive offset`                                                                            | PASS    |                                                                                                                          |
| `Element.animate() does not accept keyframes with an out-of-bounded negative offset`                                                                            | PASS    |                                                                                                                          |
| `Element.animate() does not accept keyframes not loosely sorted by offset`                                                                                      | PASS    |                                                                                                                          |
| `Element.animate() does not accept property-indexed keyframes with an invalid easing value`                                                                     | PASS    |                                                                                                                          |
| `Element.animate() does not accept a keyframe sequence with an invalid easing value`                                                                            | PASS    |                                                                                                                          |
| `Element.animate() does not accept keyframes with an invalid composite value`                                                                                   | FAIL    | `assert_throws: function "function () {\n      div.animate(subtest.input, 2000);\n    }" did not throw`                  |
| `Element.animate() does not accept invalid easing: ''`                                                                                                          | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: '7'`                                                                                                         | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'test'`                                                                                                      | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'initial'`                                                                                                   | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'inherit'`                                                                                                   | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'unset'`                                                                                                     | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'cubic-bezier(1.1, 0, 1, 1)'`                                                                                | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'cubic-bezier(0, 0, 1.1, 1)'`                                                                                | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'cubic-bezier(-0.1, 0, 1, 1)'`                                                                               | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'cubic-bezier(0, 0, -0.1, 1)'`                                                                               | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'cubic-bezier(0.1, 0, 4, 0.4)'`                                                                              | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'steps(-1, start)'`                                                                                          | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'steps(0.1, start)'`                                                                                         | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'steps(3, nowhere)'`                                                                                         | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'steps(-3, end)'`                                                                                            | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'function (a){return a}'`                                                                                    | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'function (x){return x}'`                                                                                    | PASS    |                                                                                                                          |
| `Element.animate() does not accept invalid easing: 'function(x, y){return 0.3}'`                                                                                | PASS    |                                                                                                                          |
| `Element.animate() accepts a double as an options argument`                                                                                                     | FAIL    | `Cannot read property 'timing' of undefined`                                                                             |
| `Element.animate() accepts a KeyframeAnimationOptions argument`                                                                                                 | FAIL    | `Cannot read property 'timing' of undefined`                                                                             |
| `Element.animate() accepts an absent options argument`                                                                                                          | FAIL    | `Cannot read property 'timing' of undefined`                                                                             |
| `Element.animate() correctly sets the id attribute when no id is specified`                                                                                     | PASS    |                                                                                                                          |
| `Element.animate() correctly sets the id attribute`                                                                                                             | PASS    |                                                                                                                          |
| `Element.animate() correctly sets the Animation's timeline`                                                                                                     | PASS    |                                                                                                                          |
| `Element.animate() correctly sets the Animation's timeline when triggered on an element in a different document`                                                | PASS    |                                                                                                                          |
| `Element.animate() calls play on the Animation`                                                                                                                 | PASS    |                                                                                                                          |
| `CSSPseudoElement.animate() creates an Animation object`                                                                                                        | FAIL    | `document.getAnimations is not a function`                                                                               |
| `CSSPseudoElement.animate() creates an Animation object targeting to the correct CSSPseudoElement object`                                                       | FAIL    | `document.getAnimations is not a function`                                                                               |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/3337/web-animations/interfaces/AnimationEffectTiming/easing.html">/web-animations/interfaces/AnimationEffectTiming/easing.html</a></summary>


|                                Subtest                                | Results |                   Messages                   |
|-----------------------------------------------------------------------|---------|----------------------------------------------|
|                                                                       | OK      |                                              |
| `Test default value`                                                  | FAIL    | `Cannot read property 'timing' of undefined` |
| `step-start function`                                                 | FAIL    | `Cannot read property 'timing' of undefined` |
| `steps(1, start) function`                                            | FAIL    | `Cannot read property 'timing' of undefined` |
| `steps(2, start) function`                                            | FAIL    | `Cannot read property 'timing' of undefined` |
| `step-end function`                                                   | FAIL    | `Cannot read property 'timing' of undefined` |
| `steps(1) function`                                                   | FAIL    | `Cannot read property 'timing' of undefined` |
| `steps(1, end) function`                                              | FAIL    | `Cannot read property 'timing' of undefined` |
| `steps(2, end) function`                                              | FAIL    | `Cannot read property 'timing' of undefined` |
| `linear function`                                                     | FAIL    | `Cannot read property 'timing' of undefined` |
| `ease function`                                                       | FAIL    | `Cannot read property 'timing' of undefined` |
| `ease-in function`                                                    | FAIL    | `Cannot read property 'timing' of undefined` |
| `ease-in-out function`                                                | FAIL    | `Cannot read property 'timing' of undefined` |
| `ease-out function`                                                   | FAIL    | `Cannot read property 'timing' of undefined` |
| `easing function which produces values greater than 1`                | FAIL    | `Cannot read property 'timing' of undefined` |
| `easing function which produces values less than 1`                   | FAIL    | `Cannot read property 'timing' of undefined` |
| `Invalid effect easing value test: ''`                                | PASS    |                                              |
| `Invalid effect easing value test: '7'`                               | PASS    |                                              |
| `Invalid effect easing value test: 'test'`                            | PASS    |                                              |
| `Invalid effect easing value test: 'initial'`                         | PASS    |                                              |
| `Invalid effect easing value test: 'inherit'`                         | PASS    |                                              |
| `Invalid effect easing value test: 'unset'`                           | PASS    |                                              |
| `Invalid effect easing value test: 'cubic-bezier(1.1, 0, 1, 1)'`      | PASS    |                                              |
| `Invalid effect easing value test: 'cubic-bezier(0, 0, 1.1, 1)'`      | PASS    |                                              |
| `Invalid effect easing value test: 'cubic-bezier(-0.1, 0, 1, 1)'`     | PASS    |                                              |
| `Invalid effect easing value test: 'cubic-bezier(0, 0, -0.1, 1)'`     | PASS    |                                              |
| `Invalid effect easing value test: 'cubic-bezier(0.1, 0, 4, 0.4)'`    | PASS    |                                              |
| `Invalid effect easing value test: 'steps(-1, start)'`                | PASS    |                                              |
| `Invalid effect easing value test: 'steps(0.1, start)'`               | PASS    |                                              |
| `Invalid effect easing value test: 'steps(3, nowhere)'`               | PASS    |                                              |
| `Invalid effect easing value test: 'steps(-3, end)'`                  | PASS    |                                              |
| `Invalid effect easing value test: 'function (a){return a}'`          | PASS    |                                              |
| `Invalid effect easing value test: 'function (x){return x}'`          | PASS    |                                              |
| `Invalid effect easing value test: 'function(x, y){return 0.3}'`      | PASS    |                                              |
| `Canonical easing 'ease' is returned as set`                          | FAIL    | `Cannot read property 'timing' of undefined` |
| `Canonical easing 'linear' is returned as set`                        | FAIL    | `Cannot read property 'timing' of undefined` |
| `Canonical easing 'ease-in' is returned as set`                       | FAIL    | `Cannot read property 'timing' of undefined` |
| `Canonical easing 'ease-out' is returned as set`                      | FAIL    | `Cannot read property 'timing' of undefined` |
| `Canonical easing 'ease-in-out' is returned as set`                   | FAIL    | `Cannot read property 'timing' of undefined` |
| `Canonical easing 'cubic-bezier(0.1, 5, 0.23, 0)' is returned as set` | FAIL    | `Cannot read property 'timing' of undefined` |
| `Canonical easing 'steps(3, start)' is returned as set`               | FAIL    | `Cannot read property 'timing' of undefined` |
| `Canonical easing 'steps(3)' is returned as set`                      | FAIL    | `Cannot read property 'timing' of undefined` |
| `Canonical easing 'frames(3)' is returned as set`                     | FAIL    | `Cannot read property 'timing' of undefined` |
| `Change the easing while the animation is running`                    | FAIL    | `Cannot read property 'timing' of undefined` |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/3337/web-animations/interfaces/KeyframeEffect/constructor.html">/web-animations/interfaces/KeyframeEffect/constructor.html</a></summary>


|                                                                                   Subtest                                                                                   | Results |                                                                                                                                                                     Messages                                                                                                                                                                     |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|                                                                                                                                                                             | OK      |                                                                                                                                                                                                                                                                                                                                                  |
| `a KeyframeEffectReadOnly can be constructed with no frames`                                                                                                                | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `easing values are parsed correctly when passed to the KeyframeEffectReadOnly constructor in a property-indexed keyframe`                                                   | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `easing values are parsed correctly when passed to the KeyframeEffectReadOnly constructor in regular keyframes`                                                             | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `easing values are parsed correctly when passed to the KeyframeEffectReadOnly constructor in KeyframeEffectOptions`                                                         | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `invalid easing values are correctly rejected when passed to the KeyframeEffectReadOnly constructor in regular keyframes`                                                   | FAIL    | `assert_throws: TypeError is thrown for easing '' function "() => {\n      new KeyframeEffectReadOnly(target, { easing: invalidEasing });\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "TypeError" ("TypeError")`                                                             |
| `invalid easing values are correctly rejected when passed to the KeyframeEffectReadOnly constructor in KeyframeEffectOptions`                                               | FAIL    | `assert_throws: TypeError is thrown for easing '' function "() => {\n      new KeyframeEffectReadOnly(target, null, { easing: invalidEasing });\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "TypeError" ("TypeError")`                                                       |
| `composite values are parsed correctly when passed to the KeyframeEffectReadOnly constructor in property-indexed keyframes`                                                 | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `composite values are parsed correctly when passed to the KeyframeEffectReadOnly constructor in regular keyframes`                                                          | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `composite value is absent if the composite operation specified on the keyframe effect is being used`                                                                       | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one property two value property-indexed keyframes specification`                                                        | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one property two value property-indexed keyframes specification roundtrips`                                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one shorthand property two value property-indexed keyframes specification`                                              | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one shorthand property two value property-indexed keyframes specification roundtrips`                                          | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a two property (one shorthand and one of its longhand components) two value property-indexed keyframes specification`     | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a two property (one shorthand and one of its longhand components) two value property-indexed keyframes specification roundtrips` | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a two property two value property-indexed keyframes specification`                                                        | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a two property two value property-indexed keyframes specification roundtrips`                                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a two property property-indexed keyframes specification with different numbers of values`                                 | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a two property property-indexed keyframes specification with different numbers of values roundtrips`                             | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a property-indexed keyframes specification with an invalid value`                                                         | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a property-indexed keyframes specification with an invalid value roundtrips`                                                     | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one property two value property-indexed keyframes specification that needs to stringify its values`                     | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one property two value property-indexed keyframes specification that needs to stringify its values roundtrips`                 | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a property-indexed keyframes specification with a CSS variable reference`                                                 | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a property-indexed keyframes specification with a CSS variable reference roundtrips`                                             | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a property-indexed keyframes specification with a CSS variable reference in a shorthand property`                         | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a property-indexed keyframes specification with a CSS variable reference in a shorthand property roundtrips`                     | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one property one value property-indexed keyframes specification`                                                        | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one property one value property-indexed keyframes specification roundtrips`                                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one property one non-array value property-indexed keyframes specification`                                              | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one property one non-array value property-indexed keyframes specification roundtrips`                                          | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one property two value property-indexed keyframes specification where the first value is invalid`                       | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one property two value property-indexed keyframes specification where the first value is invalid roundtrips`                   | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one property two value property-indexed keyframes specification where the second value is invalid`                      | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one property two value property-indexed keyframes specification where the second value is invalid roundtrips`                  | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `the KeyframeEffectReadOnly constructor reads keyframe properties in the expected order`                                                                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one property one keyframe sequence`                                                                                     | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one property one keyframe sequence roundtrips`                                                                                 | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one property two keyframe sequence`                                                                                     | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one property two keyframe sequence roundtrips`                                                                                 | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a two property two keyframe sequence`                                                                                     | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a two property two keyframe sequence roundtrips`                                                                                 | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one shorthand property two keyframe sequence`                                                                           | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one shorthand property two keyframe sequence roundtrips`                                                                       | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a two property (a shorthand and one of its component longhands) two keyframe sequence`                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a two property (a shorthand and one of its component longhands) two keyframe sequence roundtrips`                                | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a keyframe sequence with duplicate values for a given interior offset`                                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a keyframe sequence with duplicate values for a given interior offset roundtrips`                                                | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a keyframe sequence with duplicate values for offsets 0 and 1`                                                            | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a keyframe sequence with duplicate values for offsets 0 and 1 roundtrips`                                                        | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a two property four keyframe sequence`                                                                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a two property four keyframe sequence roundtrips`                                                                                | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a single keyframe sequence with omitted offset`                                                                           | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a single keyframe sequence with omitted offset roundtrips`                                                                       | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a single keyframe sequence with null offset`                                                                              | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a single keyframe sequence with null offset roundtrips`                                                                          | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a single keyframe sequence with string offset`                                                                            | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a single keyframe sequence with string offset roundtrips`                                                                        | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one property keyframe sequence with some omitted offsets`                                                               | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one property keyframe sequence with some omitted offsets roundtrips`                                                           | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one property keyframe sequence with some null offsets`                                                                  | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one property keyframe sequence with some null offsets roundtrips`                                                              | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a two property keyframe sequence with some omitted offsets`                                                               | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a two property keyframe sequence with some omitted offsets roundtrips`                                                           | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one property keyframe sequence with all omitted offsets`                                                                | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one property keyframe sequence with all omitted offsets roundtrips`                                                            | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a keyframe sequence with different easing values, but the same easing value for a given offset`                           | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a keyframe sequence with different easing values, but the same easing value for a given offset roundtrips`                       | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a keyframe sequence with different composite values, but the same composite value for a given offset`                     | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a keyframe sequence with different composite values, but the same composite value for a given offset roundtrips`                 | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a one property two keyframe sequence that needs to stringify its values`                                                  | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a one property two keyframe sequence that needs to stringify its values roundtrips`                                              | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a keyframe sequence with a CSS variable reference`                                                                        | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a keyframe sequence with a CSS variable reference roundtrips`                                                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a keyframe sequence with a CSS variable reference in a shorthand property`                                                | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a keyframe sequence with a CSS variable reference in a shorthand property roundtrips`                                            | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a keyframe sequence where shorthand precedes longhand`                                                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a keyframe sequence where shorthand precedes longhand roundtrips`                                                                | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a keyframe sequence where longhand precedes shorthand`                                                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a keyframe sequence where longhand precedes shorthand roundtrips`                                                                | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a keyframe sequence where lesser shorthand precedes greater shorthand`                                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a keyframe sequence where lesser shorthand precedes greater shorthand roundtrips`                                                | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a keyframe sequence where greater shorthand precedes lesser shorthand`                                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a keyframe sequence where greater shorthand precedes lesser shorthand roundtrips`                                                | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a two property keyframe sequence where one property is missing from the first keyframe`                                   | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a two property keyframe sequence where one property is missing from the first keyframe roundtrips`                               | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a two property keyframe sequence where one property is missing from the last keyframe`                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a two property keyframe sequence where one property is missing from the last keyframe roundtrips`                                | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly can be constructed with a keyframe sequence with repeated values at offset 1 with different easings`                                              | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed with a keyframe sequence with repeated values at offset 1 with different easings roundtrips`                                          | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `KeyframeEffectReadOnly constructor throws with keyframes with an out-of-bounded positive offset`                                                                           | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target, subtest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")`                                                                                               |
| `KeyframeEffectReadOnly constructor throws with keyframes with an out-of-bounded negative offset`                                                                           | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target, subtest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")`                                                                                               |
| `KeyframeEffectReadOnly constructor throws with keyframes not loosely sorted by offset`                                                                                     | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target, subtest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")`                                                                                               |
| `KeyframeEffectReadOnly constructor throws with property-indexed keyframes with an invalid easing value`                                                                    | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target, subtest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")`                                                                                               |
| `KeyframeEffectReadOnly constructor throws with a keyframe sequence with an invalid easing value`                                                                           | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target, subtest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")`                                                                                               |
| `KeyframeEffectReadOnly constructor throws with keyframes with an invalid composite value`                                                                                  | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target, subtest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")`                                                                                               |
| `Invalid easing [a blank easing] in keyframe sequence should be thrown`                                                                                                     | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target, subtest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "TypeError" ("TypeError")`                                                                                                     |
| `Invalid easing [an unrecognized easing] in keyframe sequence should be thrown`                                                                                             | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target, subtest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "TypeError" ("TypeError")`                                                                                                     |
| `Invalid easing [an 'initial' easing] in keyframe sequence should be thrown`                                                                                                | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target, subtest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "TypeError" ("TypeError")`                                                                                                     |
| `Invalid easing [an 'inherit' easing] in keyframe sequence should be thrown`                                                                                                | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target, subtest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "TypeError" ("TypeError")`                                                                                                     |
| `Invalid easing [a variable easing] in keyframe sequence should be thrown`                                                                                                  | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target, subtest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "TypeError" ("TypeError")`                                                                                                     |
| `Invalid easing [a multi-value easing] in keyframe sequence should be thrown`                                                                                               | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target, subtest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "TypeError" ("TypeError")`                                                                                                     |
| `a KeyframeEffectReadOnly constructed without any KeyframeEffectOptions object`                                                                                             | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed by an empty KeyframeEffectOptions object`                                                                                             | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed by a normal KeyframeEffectOptions object`                                                                                             | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed by a double value`                                                                                                                    | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed by +Infinity`                                                                                                                         | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed by an Infinity duration`                                                                                                              | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed by an auto duration`                                                                                                                  | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed by an Infinity iterations`                                                                                                            | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed by an auto fill`                                                                                                                      | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `a KeyframeEffectReadOnly constructed by a forwards fill`                                                                                                                   | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `Invalid KeyframeEffectReadOnly option by -Infinity`                                                                                                                        | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by NaN`                                                                                                                              | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by a negative value`                                                                                                                 | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by a negative Infinity duration`                                                                                                     | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by a NaN duration`                                                                                                                   | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by a negative duration`                                                                                                              | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by a string duration`                                                                                                                | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by a negative Infinity iterations`                                                                                                   | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by a NaN iterations`                                                                                                                 | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by a negative iterations`                                                                                                            | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by a blank easing`                                                                                                                   | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by an unrecognized easing`                                                                                                           | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by an 'initial' easing`                                                                                                              | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by an 'inherit' easing`                                                                                                              | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by a variable easing`                                                                                                                | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `Invalid KeyframeEffectReadOnly option by a multi-value easing`                                                                                                             | FAIL    | `assert_throws: function "function () {\n      new KeyframeEffectReadOnly(target,\n                                 { left: ["10px", "20px"] },\n                                 stest.input);\n    }" threw object "ReferenceError: KeyframeEffectReadOnly is not defined" ("ReferenceError") expected object "[object Object]" ("TypeError")` |
| `a KeyframeEffectReadOnly constructed with null target`                                                                                                                     | FAIL    | `KeyframeEffectReadOnly is not defined`                                                                                                                                                                                                                                                                                                          |
| `KeyframeEffect constructor creates an AnimationEffectTiming timing object`                                                                                                 | FAIL    | `KeyframeEffect is not defined`                                                                                                                                                                                                                                                                                                                  |
| `KeyframeEffect constructor propagates exceptions generated by accessing the options object`                                                                                | FAIL    | `assert_throws: function "function () {\n    new KeyframeEffect(target, { get left() { throw test_error }})\n  }" threw object "ReferenceError: KeyframeEffect is not defined" ("ReferenceError") expected object "[object Object]" ("test")`                                                                                                    |

</details>
<details>
<summary><a href="http://w3c-test.org/submissions/3337/web-animations/timing-model/time-transformations/transformed-progress.html">/web-animations/timing-model/time-transformations/transformed-progress.html</a></summary>


|                                        Subtest                                         | Results |                         Messages                        |
|----------------------------------------------------------------------------------------|---------|---------------------------------------------------------|
|                                                                                        | OK      |                                                         |
| `Transformed progress for step-start function`                                         | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for steps(1, start) function`                                    | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for steps(2, start) function`                                    | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for step-end function`                                           | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for steps(1) function`                                           | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for steps(1, end) function`                                      | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for steps(2, end) function`                                      | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for linear function`                                             | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for ease function`                                               | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for ease-in function`                                            | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for ease-in-out function`                                        | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for ease-out function`                                           | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for easing function which produces values greater than 1`        | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Transformed progress for easing function which produces values less than 1`           | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Test bounds point of step-start easing`                                               | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Test bounds point of step-start easing with reverse direction`                        | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Test bounds point of step-start easing with iterationStart not at a transition point` | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Test bounds point of step-start easing with iterationStart and delay`                 | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Test bounds point of step-start easing with iterationStart and reverse direction`     | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Test bounds point of step(4, start) easing with iterationStart 0.75 and delay`        | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Test bounds point of step-start easing with alternate direction`                      | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Test bounds point of step-start easing with alternate-reverse direction`              | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Test bounds point of step-end easing`                                                 | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Test bounds point of step-end easing with iterationStart and delay`                   | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |
| `Test bounds point of step-end easing with iterationStart not at a transition point`   | FAIL    | `Cannot read property 'getComputedTiming' of undefined` |

</details>
</details>

View on GitHub: https://github.com/w3c/web-platform-tests/pull/3337#issuecomment-285589978

Received on Friday, 10 March 2017 06:34:18 UTC