From 086c044dc34dfc0f74fbe41f4ecb402b2cd34884 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Fri, 19 Apr 2024 03:13:33 +0200
Subject: Merging upstream version 125.0.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 ...nvasFilterObject.blur.exceptions.tentative.html |  22 +-
 ...r.canvasFilterObject.colorMatrix.tentative.html |  69 +++--
 ...ponentTransfer.discrete.tentative-expected.html |  50 ++++
 ...bject.componentTransfer.discrete.tentative.html |  49 +---
 ...componentTransfer.gamma.tentative-expected.html |  44 +++
 ...erObject.componentTransfer.gamma.tentative.html |  49 ++--
 ...ponentTransfer.identity.tentative-expected.html |  27 ++
 ...bject.componentTransfer.identity.tentative.html |  31 +-
 ...omponentTransfer.linear.tentative-expected.html |  43 +++
 ...rObject.componentTransfer.linear.tentative.html |  40 +--
 ...componentTransfer.table.tentative-expected.html |  51 ++++
 ...erObject.componentTransfer.table.tentative.html |  49 +---
 ...Object.convolveMatrix.exceptions.tentative.html |  48 ++--
 ...lterObject.dropShadow.exceptions.tentative.html | 320 +++++++++++++++------
 ...er.canvasFilterObject.dropShadow.tentative.html |  56 +---
 ....gaussianBlur.isotropic.tentative-expected.html |  15 +
 ...terObject.gaussianBlur.isotropic.tentative.html |  20 ++
 ...t.gaussianBlur.mostly-x.tentative-expected.html |  15 +
 ...lterObject.gaussianBlur.mostly-x.tentative.html |  20 ++
 ...t.gaussianBlur.mostly-y.tentative-expected.html |  15 +
 ...lterObject.gaussianBlur.mostly-y.tentative.html |  20 ++
 ....gaussianBlur.tentative.isotropic-expected.html |  15 -
 ...terObject.gaussianBlur.tentative.isotropic.html |  20 --
 ...t.gaussianBlur.tentative.mostly-x-expected.html |  15 -
 ...lterObject.gaussianBlur.tentative.mostly-x.html |  20 --
 ...t.gaussianBlur.tentative.mostly-y-expected.html |  15 -
 ...lterObject.gaussianBlur.tentative.mostly-y.html |  20 --
 ...ect.gaussianBlur.tentative.x-only-expected.html |  15 -
 ...FilterObject.gaussianBlur.tentative.x-only.html |  20 --
 ...ect.gaussianBlur.tentative.y-only-expected.html |  15 -
 ...FilterObject.gaussianBlur.tentative.y-only.html |  20 --
 ...ect.gaussianBlur.x-only.tentative-expected.html |  15 +
 ...FilterObject.gaussianBlur.x-only.tentative.html |  20 ++
 ...ect.gaussianBlur.y-only.tentative-expected.html |  15 +
 ...FilterObject.gaussianBlur.y-only.tentative.html |  20 ++
 ...lterObject.turbulence.inputTypes.tentative.html |   4 +-
 .../filters/2d.filter.layers.blur.exceptions.html  |  37 +++
 .../filters/2d.filter.layers.colorMatrix.html      | 104 +++++++
 ...layers.componentTransfer.discrete-expected.html |  50 ++++
 ...d.filter.layers.componentTransfer.discrete.html |  38 +++
 ...er.layers.componentTransfer.gamma-expected.html |  44 +++
 .../2d.filter.layers.componentTransfer.gamma.html  |  41 +++
 ...layers.componentTransfer.identity-expected.html |  27 ++
 ...d.filter.layers.componentTransfer.identity.html |  34 +++
 ...r.layers.componentTransfer.linear-expected.html |  44 +++
 .../2d.filter.layers.componentTransfer.linear.html |  37 +++
 ...er.layers.componentTransfer.table-expected.html |  51 ++++
 .../2d.filter.layers.componentTransfer.table.html  |  38 +++
 ...2d.filter.layers.convolveMatrix.exceptions.html |  60 ++++
 .../2d.filter.layers.dropShadow-expected.html      |  57 ++++
 .../2d.filter.layers.dropShadow.exceptions.html    | 269 +++++++++++++++++
 .../filters/2d.filter.layers.dropShadow.html       |  94 ++++++
 ...ter.layers.gaussianBlur.isotropic-expected.html |  15 +
 .../2d.filter.layers.gaussianBlur.isotropic.html   |  21 ++
 ...lter.layers.gaussianBlur.mostly-x-expected.html |  15 +
 .../2d.filter.layers.gaussianBlur.mostly-x.html    |  21 ++
 ...lter.layers.gaussianBlur.mostly-y-expected.html |  15 +
 .../2d.filter.layers.gaussianBlur.mostly-y.html    |  21 ++
 ...filter.layers.gaussianBlur.x-only-expected.html |  15 +
 .../2d.filter.layers.gaussianBlur.x-only.html      |  21 ++
 ...filter.layers.gaussianBlur.y-only-expected.html |  15 +
 .../2d.filter.layers.gaussianBlur.y-only.html      |  21 ++
 .../2d.filter.layers.turbulence.inputTypes.html    | 130 +++++++++
 63 files changed, 2125 insertions(+), 512 deletions(-)
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.discrete.tentative-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.gamma.tentative-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.identity.tentative-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.linear.tentative-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.table.tentative-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative.html
 delete mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic-expected.html
 delete mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic.html
 delete mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x-expected.html
 delete mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x.html
 delete mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y-expected.html
 delete mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y.html
 delete mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only-expected.html
 delete mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only.html
 delete mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only-expected.html
 delete mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.blur.exceptions.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.colorMatrix.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.discrete-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.discrete.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.gamma-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.gamma.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.identity-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.identity.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.linear-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.linear.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.table-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.table.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.convolveMatrix.exceptions.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.dropShadow-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.dropShadow.exceptions.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.dropShadow.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.isotropic-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.isotropic.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-x-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-x.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-y-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-y.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.x-only-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.x-only.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.y-only-expected.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.y-only.html
 create mode 100644 testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.turbulence.inputTypes.html

(limited to 'testing/web-platform/tests/html/canvas/element/filters')

diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.blur.exceptions.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.blur.exceptions.tentative.html
index 42fb1ee8f8..dc94792867 100644
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.blur.exceptions.tentative.html
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.blur.exceptions.tentative.html
@@ -8,7 +8,7 @@
 <body class="show_output">
 
 <h1>2d.filter.canvasFilterObject.blur.exceptions.tentative</h1>
-<p class="desc">Test exceptions on CanvasFilter() blur.object</p>
+<p class="desc">Test exceptions on gaussianBlur filter</p>
 
 
 <p class="output">Actual output:</p>
@@ -16,15 +16,21 @@
 
 <ul id="d"></ul>
 <script>
-var t = async_test("Test exceptions on CanvasFilter() blur.object");
+var t = async_test("Test exceptions on gaussianBlur filter");
 _addTest(function(canvas, ctx) {
 
-  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter({name: 'gaussianBlur'}); });
-  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter({name: 'gaussianBlur', stdDeviation: undefined}); });
-  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter({name: 'gaussianBlur', stdDeviation: 'foo'}); });
-  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter({name: 'gaussianBlur', stdDeviation: [1,2,3]}); });
-  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter({name: 'gaussianBlur', stdDeviation: NaN}); });
-  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter({name: 'gaussianBlur', stdDeviation: {}}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'gaussianBlur'}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'gaussianBlur', stdDeviation: undefined}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'gaussianBlur', stdDeviation: 'foo'}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'gaussianBlur', stdDeviation: [1,2,3]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'gaussianBlur', stdDeviation: NaN}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'gaussianBlur', stdDeviation: {}}); });
 
 });
 </script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.colorMatrix.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.colorMatrix.tentative.html
index b2f6a6ac97..56cf1bf0b1 100644
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.colorMatrix.tentative.html
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.colorMatrix.tentative.html
@@ -8,7 +8,7 @@
 <body class="show_output">
 
 <h1>2d.filter.canvasFilterObject.colorMatrix.tentative</h1>
-<p class="desc">Test the functionality of ColorMatrix filters in CanvasFilter objects</p>
+<p class="desc">Test the functionality of ColorMatrix filters</p>
 
 
 <p class="output">Actual output:</p>
@@ -16,41 +16,70 @@
 
 <ul id="d"></ul>
 <script>
-var t = async_test("Test the functionality of ColorMatrix filters in CanvasFilter objects");
+var t = async_test("Test the functionality of ColorMatrix filters");
 _addTest(function(canvas, ctx) {
 
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'colorMatrix', values: undefined}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'colorMatrix', values: 'foo'}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'colorMatrix', values: null}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'colorMatrix', values: [1, 2, 3]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'colorMatrix', values: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 'a']}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'colorMatrix', values: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, Infinity]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix', values: undefined}); });
+
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix', values: 'foo'}); });
+
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix', values: null}); });
+
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix', values: [1, 2, 3]}); });
+
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix',
+     values: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+              19, 'a']}); });
+
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix',
+     values: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+              19, Infinity]}); });
+
   ctx.fillStyle = '#f00';
-  ctx.filter = new CanvasFilter({name: 'colorMatrix', type: 'hueRotate', values: 0});
+  ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix', type: 'hueRotate', values: 0});
   ctx.fillRect(0, 0, 100, 50);
   _assertPixelApprox(canvas, 10,10, 255,0,0,255, 2);
-  ctx.filter = new CanvasFilter({name: 'colorMatrix', type: 'hueRotate', values: 90});
+
+  ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix', type: 'hueRotate', values: 90});
   ctx.fillRect(0, 0, 100, 50);
   _assertPixelApprox(canvas, 10,10, 0,91,0,255, 2);
-  ctx.filter = new CanvasFilter({name: 'colorMatrix', type: 'hueRotate', values: 180});
+
+  ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix', type: 'hueRotate', values: 180});
   ctx.fillRect(0, 0, 100, 50);
   _assertPixelApprox(canvas, 10,10, 0,109,109,255, 2);
-  ctx.filter = new CanvasFilter({name: 'colorMatrix', type: 'hueRotate', values: 270});
+
+  ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix', type: 'hueRotate', values: 270});
   ctx.fillRect(0, 0, 100, 50);
   _assertPixelApprox(canvas, 10,10, 109,18,255,255, 2);
-  ctx.filter = new CanvasFilter({name: 'colorMatrix', type: 'saturate', values: 0.5});
+
+  ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix', type: 'saturate', values: 0.5});
   ctx.fillRect(0, 0, 100, 50);
   _assertPixelApprox(canvas, 10,10, 155,27,27,255, 2);
+
   ctx.clearRect(0, 0, 100, 50);
-  ctx.filter = new CanvasFilter({name: 'colorMatrix', type: 'luminanceToAlpha'});
+  ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix', type: 'luminanceToAlpha'});
   ctx.fillRect(0, 0, 100, 50);
   _assertPixelApprox(canvas, 10,10, 0,0,0,54, 2);
-  ctx.filter = new CanvasFilter({name: 'colorMatrix', values: [
-          0, 0, 0, 0, 0,
-          1, 1, 1, 1, 0,
-          0, 0, 0, 0, 0,
-          0, 0, 0, 1, 0
-  ]});
+
+  ctx.filter = new CanvasFilter(
+    {name: 'colorMatrix', values: [
+      0, 0, 0, 0, 0,
+      1, 1, 1, 1, 0,
+      0, 0, 0, 0, 0,
+      0, 0, 0, 1, 0
+    ]});
   ctx.fillRect(0, 0, 50, 25);
   ctx.fillStyle = '#0f0';
   ctx.fillRect(50, 0, 50, 25);
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.discrete.tentative-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.discrete.tentative-expected.html
new file mode 100644
index 0000000000..2b1c1c1c07
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.discrete.tentative-expected.html
@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.canvasFilterObject.componentTransfer.discrete.tentative</title>
+<h1>2d.filter.canvasFilterObject.componentTransfer.discrete.tentative</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with discrete type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  // From https://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
+  function getTransformedValue(C, V) {
+      // Get the right interval
+      const n = V.length;
+      const k = C == 1 ? n - 1 : Math.floor(C * n);
+      return V[k];
+  }
+
+  function getColor(inputColor, tableValues) {
+      const result = [0, 0, 0];
+      for (const i in inputColor) {
+          const C = inputColor[i]/255;
+          const Cprime = getTransformedValue(C, tableValues[i]);
+          result[i] = Math.max(0, Math.min(1, Cprime)) * 255;
+      }
+      return result;
+  }
+
+  tableValuesR = [0, 0, 1, 1];
+  tableValuesG = [2, 0, 0.5, 3];
+  tableValuesB = [1, -1, 5, 0];
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      let outputColor = getColor(
+          color, [tableValuesR, tableValuesG, tableValuesB]);
+      ctx.fillStyle = `rgb(${outputColor[0]}, ${outputColor[1]},
+        ${outputColor[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.discrete.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.discrete.tentative.html
index b392b189f2..0a4830568b 100644
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.discrete.tentative.html
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.discrete.tentative.html
@@ -1,41 +1,16 @@
 <!DOCTYPE html>
 <!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.canvasFilterObject.componentTransfer.discrete.tentative-expected.html">
+<meta name=fuzzy content="maxDifference=0-2; totalPixels=0-500">
 <title>Canvas test: 2d.filter.canvasFilterObject.componentTransfer.discrete.tentative</title>
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="/html/canvas/resources/canvas-tests.js"></script>
-<link rel="stylesheet" href="/html/canvas/resources/canvas-tests.css">
-<body class="show_output">
-
 <h1>2d.filter.canvasFilterObject.componentTransfer.discrete.tentative</h1>
 <p class="desc">Test pixels on CanvasFilter() componentTransfer with discrete type</p>
-
-
-<p class="output">Actual output:</p>
-<canvas id="c" class="output" width="100" height="50"><p class="fallback">FAIL (fallback content)</p></canvas>
-
-<ul id="d"></ul>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
 <script>
-var t = async_test("Test pixels on CanvasFilter() componentTransfer with discrete type");
-_addTest(function(canvas, ctx) {
-
-  // From https://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
-  function getTransformedValue(C, V) {
-      // Get the right interval
-      const n = V.length;
-      const k = C == 1 ? n - 1 : Math.floor(C * n);
-      return V[k];
-  }
-
-  function getColor(inputColor, tableValues) {
-      const result = [0, 0, 0];
-      for (const i in inputColor) {
-          const C = inputColor[i]/255;
-          const Cprime = getTransformedValue(C, tableValues[i]);
-          result[i] = Math.max(0, Math.min(1, Cprime)) * 255;
-      }
-      return result;
-  }
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
 
   tableValuesR = [0, 0, 1, 1];
   tableValuesG = [2, 0, 0.5, 3];
@@ -54,13 +29,9 @@ _addTest(function(canvas, ctx) {
       [50, 68, 87],
   ];
 
-  for (const color of inputColors) {
-      let outputColor = getColor(color, [tableValuesR, tableValuesG, tableValuesB]);
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
       ctx.fillStyle = `rgb(${color[0]}, ${color[1]}, ${color[2]})`;
-      ctx.fillRect(0, 0, 10, 10);
-      _assertPixelApprox(canvas, 5, 5, outputColor[0],outputColor[1],outputColor[2],255, 2);
+      ctx.fillRect(i * 10, i * 10, 10, 10);
   }
-
-});
 </script>
-
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.gamma.tentative-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.gamma.tentative-expected.html
new file mode 100644
index 0000000000..5adc9f53e2
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.gamma.tentative-expected.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.canvasFilterObject.componentTransfer.gamma.tentative</title>
+<h1>2d.filter.canvasFilterObject.componentTransfer.gamma.tentative</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with gamma type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  // From https://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
+  function getColor(inputColor, amplitude, exponent, offset) {
+      return [
+          Math.max(0, Math.min(1, Math.pow(inputColor[0]/255,
+            exponent[0]) * amplitude[0] + offset[0])) * 255,
+          Math.max(0, Math.min(1, Math.pow(inputColor[1]/255,
+            exponent[1]) * amplitude[1] + offset[1])) * 255,
+          Math.max(0, Math.min(1, Math.pow(inputColor[2]/255,
+            exponent[2]) * amplitude[2] + offset[2])) * 255,
+      ];
+  }
+
+  const amplitudes = [2, 1.1, 0.5];
+  const exponents = [5, 3, 1];
+  const offsets = [0.25, 0, 0.5];
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      let outputColor = getColor(color, amplitudes, exponents, offsets);
+      ctx.fillStyle = `rgb(${outputColor[0]}, ${outputColor[1]},
+        ${outputColor[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.gamma.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.gamma.tentative.html
index e5bff7e44d..22e3abe624 100644
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.gamma.tentative.html
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.gamma.tentative.html
@@ -1,40 +1,27 @@
 <!DOCTYPE html>
 <!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.canvasFilterObject.componentTransfer.gamma.tentative-expected.html">
+<meta name=fuzzy content="maxDifference=0-2; totalPixels=0-500">
 <title>Canvas test: 2d.filter.canvasFilterObject.componentTransfer.gamma.tentative</title>
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="/html/canvas/resources/canvas-tests.js"></script>
-<link rel="stylesheet" href="/html/canvas/resources/canvas-tests.css">
-<body class="show_output">
-
 <h1>2d.filter.canvasFilterObject.componentTransfer.gamma.tentative</h1>
 <p class="desc">Test pixels on CanvasFilter() componentTransfer with gamma type</p>
-
-
-<p class="output">Actual output:</p>
-<canvas id="c" class="output" width="100" height="50"><p class="fallback">FAIL (fallback content)</p></canvas>
-
-<ul id="d"></ul>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
 <script>
-var t = async_test("Test pixels on CanvasFilter() componentTransfer with gamma type");
-_addTest(function(canvas, ctx) {
-
-  // From https://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
-  function getColor(inputColor, amplitude, exponent, offset) {
-      return [
-          Math.max(0, Math.min(1, Math.pow(inputColor[0]/255, exponent[0]) * amplitude[0] + offset[0])) * 255,
-          Math.max(0, Math.min(1, Math.pow(inputColor[1]/255, exponent[1]) * amplitude[1] + offset[1])) * 255,
-          Math.max(0, Math.min(1, Math.pow(inputColor[2]/255, exponent[2]) * amplitude[2] + offset[2])) * 255,
-      ];
-  }
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
 
   const amplitudes = [2, 1.1, 0.5];
   const exponents = [5, 3, 1];
   const offsets = [0.25, 0, 0.5];
   ctx.filter = new CanvasFilter({name: 'componentTransfer',
-      funcR: {type: 'gamma', amplitude: amplitudes[0], exponent: exponents[0], offset: offsets[0]},
-      funcG: {type: 'gamma', amplitude: amplitudes[1], exponent: exponents[1], offset: offsets[1]},
-      funcB: {type: 'gamma', amplitude: amplitudes[2], exponent: exponents[2], offset: offsets[2]},
+      funcR: {type: 'gamma', amplitude: amplitudes[0],
+        exponent: exponents[0], offset: offsets[0]},
+      funcG: {type: 'gamma', amplitude: amplitudes[1],
+        exponent: exponents[1], offset: offsets[1]},
+      funcB: {type: 'gamma', amplitude: amplitudes[2],
+        exponent: exponents[2], offset: offsets[2]},
   });
 
   const inputColors = [
@@ -45,13 +32,9 @@ _addTest(function(canvas, ctx) {
       [50, 68, 87],
   ];
 
-  for (const color of inputColors) {
-      let outputColor = getColor(color, amplitudes, exponents, offsets);
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
       ctx.fillStyle = `rgb(${color[0]}, ${color[1]}, ${color[2]})`;
-      ctx.fillRect(0, 0, 10, 10);
-      _assertPixelApprox(canvas, 5, 5, outputColor[0],outputColor[1],outputColor[2],255, 2);
+      ctx.fillRect(i * 10, i * 10, 10, 10);
   }
-
-});
 </script>
-
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.identity.tentative-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.identity.tentative-expected.html
new file mode 100644
index 0000000000..895d531206
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.identity.tentative-expected.html
@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.canvasFilterObject.componentTransfer.identity.tentative</title>
+<h1>2d.filter.canvasFilterObject.componentTransfer.identity.tentative</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with identity type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      let outputColor = inputColors[i];
+      ctx.fillStyle = `rgb(${outputColor[0]}, ${outputColor[1]},
+        ${outputColor[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.identity.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.identity.tentative.html
index ecd3830be3..17761ce31a 100644
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.identity.tentative.html
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.identity.tentative.html
@@ -1,23 +1,15 @@
 <!DOCTYPE html>
 <!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.canvasFilterObject.componentTransfer.identity.tentative-expected.html">
 <title>Canvas test: 2d.filter.canvasFilterObject.componentTransfer.identity.tentative</title>
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="/html/canvas/resources/canvas-tests.js"></script>
-<link rel="stylesheet" href="/html/canvas/resources/canvas-tests.css">
-<body class="show_output">
-
 <h1>2d.filter.canvasFilterObject.componentTransfer.identity.tentative</h1>
 <p class="desc">Test pixels on CanvasFilter() componentTransfer with identity type</p>
-
-
-<p class="output">Actual output:</p>
-<canvas id="c" class="output" width="100" height="50"><p class="fallback">FAIL (fallback content)</p></canvas>
-
-<ul id="d"></ul>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
 <script>
-var t = async_test("Test pixels on CanvasFilter() componentTransfer with identity type");
-_addTest(function(canvas, ctx) {
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
 
   ctx.filter = new CanvasFilter({name: 'componentTransfer',
       funcR: {type: 'identity'},
@@ -33,12 +25,9 @@ _addTest(function(canvas, ctx) {
       [50, 68, 87],
   ];
 
-  for (const color of inputColors) {
-      ctx.fillStyle = `rgba(${color[0]}, ${color[1]}, ${color[2]}, 1)`,
-      ctx.fillRect(0, 0, 10, 10);
-      _assertPixel(canvas, 5, 5, color[0],color[1],color[2],255);
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      ctx.fillStyle = `rgb(${color[0]}, ${color[1]}, ${color[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
   }
-
-});
 </script>
-
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.linear.tentative-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.linear.tentative-expected.html
new file mode 100644
index 0000000000..c4ad790d56
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.linear.tentative-expected.html
@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.canvasFilterObject.componentTransfer.linear.tentative</title>
+<h1>2d.filter.canvasFilterObject.componentTransfer.linear.tentative</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with linear type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  // From https://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
+  function getColor(inputColor, slopes, intercepts) {
+      return [
+          Math.max(0, Math.min(1,
+            inputColor[0]/255 * slopes[0] + intercepts[0])) * 255,
+          Math.max(0, Math.min(1,
+            inputColor[1]/255 * slopes[1] + intercepts[1])) * 255,
+          Math.max(0, Math.min(1,
+            inputColor[2]/255 * slopes[2] + intercepts[2])) * 255,
+      ];
+  }
+
+  const slopes = [0.5, 1.2, -0.2];
+  const intercepts = [0.25, 0, 0.5];
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      let outputColor = getColor(color, slopes, intercepts);
+      ctx.fillStyle = `rgb(${outputColor[0]}, ${outputColor[1]},
+        ${outputColor[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.linear.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.linear.tentative.html
index 8708887f6a..5ea5f8e0e3 100644
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.linear.tentative.html
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.linear.tentative.html
@@ -1,32 +1,16 @@
 <!DOCTYPE html>
 <!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.canvasFilterObject.componentTransfer.linear.tentative-expected.html">
+<meta name=fuzzy content="maxDifference=0-2; totalPixels=0-500">
 <title>Canvas test: 2d.filter.canvasFilterObject.componentTransfer.linear.tentative</title>
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="/html/canvas/resources/canvas-tests.js"></script>
-<link rel="stylesheet" href="/html/canvas/resources/canvas-tests.css">
-<body class="show_output">
-
 <h1>2d.filter.canvasFilterObject.componentTransfer.linear.tentative</h1>
 <p class="desc">Test pixels on CanvasFilter() componentTransfer with linear type</p>
-
-
-<p class="output">Actual output:</p>
-<canvas id="c" class="output" width="100" height="50"><p class="fallback">FAIL (fallback content)</p></canvas>
-
-<ul id="d"></ul>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
 <script>
-var t = async_test("Test pixels on CanvasFilter() componentTransfer with linear type");
-_addTest(function(canvas, ctx) {
-
-  // From https://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
-  function getColor(inputColor, slopes, intercepts) {
-      return [
-          Math.max(0, Math.min(1, inputColor[0]/255 * slopes[0] + intercepts[0])) * 255,
-          Math.max(0, Math.min(1, inputColor[1]/255 * slopes[1] + intercepts[1])) * 255,
-          Math.max(0, Math.min(1, inputColor[2]/255 * slopes[2] + intercepts[2])) * 255,
-      ];
-  }
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
 
   const slopes = [0.5, 1.2, -0.2];
   const intercepts = [0.25, 0, 0.5];
@@ -44,13 +28,9 @@ _addTest(function(canvas, ctx) {
       [50, 68, 87],
   ];
 
-  for (const color of inputColors) {
-      let outputColor = getColor(color, slopes, intercepts);
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
       ctx.fillStyle = `rgb(${color[0]}, ${color[1]}, ${color[2]})`;
-      ctx.fillRect(0, 0, 10, 10);
-      _assertPixelApprox(canvas, 5, 5, outputColor[0],outputColor[1],outputColor[2],255, 2);
+      ctx.fillRect(i * 10, i * 10, 10, 10);
   }
-
-});
 </script>
-
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.table.tentative-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.table.tentative-expected.html
new file mode 100644
index 0000000000..29e250614c
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.table.tentative-expected.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.canvasFilterObject.componentTransfer.table.tentative</title>
+<h1>2d.filter.canvasFilterObject.componentTransfer.table.tentative</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with table type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  // From https://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
+  function getTransformedValue(C, V) {
+      // Get the right interval
+      const n = V.length - 1;
+      const k = C == 1 ? n - 1 : Math.floor(C * n);
+      return V[k] + (C - k/n) * n * (V[k + 1] - V[k]);
+  }
+
+  function getColor(inputColor, tableValues) {
+      const result = [0, 0, 0];
+      for (const i in inputColor) {
+          const C = inputColor[i]/255;
+          const Cprime = getTransformedValue(C, tableValues[i]);
+          result[i] = Math.max(0, Math.min(1, Cprime)) * 255;
+      }
+      return result;
+  }
+
+  tableValuesR = [0, 0, 1, 1];
+  tableValuesG = [2, 0, 0.5, 3];
+  tableValuesB = [1, -1, 5, 0];
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      let outputColor = getColor(
+          color, [tableValuesR, tableValuesG, tableValuesB]);
+      ctx.fillStyle = `rgb(${outputColor[0]}, ${outputColor[1]},
+        ${outputColor[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.table.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.table.tentative.html
index 4b296d9fd7..0f74d9c3bf 100644
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.table.tentative.html
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.componentTransfer.table.tentative.html
@@ -1,41 +1,16 @@
 <!DOCTYPE html>
 <!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.canvasFilterObject.componentTransfer.table.tentative-expected.html">
+<meta name=fuzzy content="maxDifference=0-2; totalPixels=0-500">
 <title>Canvas test: 2d.filter.canvasFilterObject.componentTransfer.table.tentative</title>
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="/html/canvas/resources/canvas-tests.js"></script>
-<link rel="stylesheet" href="/html/canvas/resources/canvas-tests.css">
-<body class="show_output">
-
 <h1>2d.filter.canvasFilterObject.componentTransfer.table.tentative</h1>
 <p class="desc">Test pixels on CanvasFilter() componentTransfer with table type</p>
-
-
-<p class="output">Actual output:</p>
-<canvas id="c" class="output" width="100" height="50"><p class="fallback">FAIL (fallback content)</p></canvas>
-
-<ul id="d"></ul>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
 <script>
-var t = async_test("Test pixels on CanvasFilter() componentTransfer with table type");
-_addTest(function(canvas, ctx) {
-
-  // From https://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
-  function getTransformedValue(C, V) {
-      // Get the right interval
-      const n = V.length - 1;
-      const k = C == 1 ? n - 1 : Math.floor(C * n);
-      return V[k] + (C - k/n) * n * (V[k + 1] - V[k]);
-  }
-
-  function getColor(inputColor, tableValues) {
-      const result = [0, 0, 0];
-      for (const i in inputColor) {
-          const C = inputColor[i]/255;
-          const Cprime = getTransformedValue(C, tableValues[i]);
-          result[i] = Math.max(0, Math.min(1, Cprime)) * 255;
-      }
-      return result;
-  }
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
 
   tableValuesR = [0, 0, 1, 1];
   tableValuesG = [2, 0, 0.5, 3];
@@ -54,13 +29,9 @@ _addTest(function(canvas, ctx) {
       [50, 68, 87],
   ];
 
-  for (const color of inputColors) {
-      let outputColor = getColor(color, [tableValuesR, tableValuesG, tableValuesB]);
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
       ctx.fillStyle = `rgb(${color[0]}, ${color[1]}, ${color[2]})`;
-      ctx.fillRect(0, 0, 10, 10);
-      _assertPixelApprox(canvas, 5, 5, outputColor[0],outputColor[1],outputColor[2],255, 2);
+      ctx.fillRect(i * 10, i * 10, 10, 10);
   }
-
-});
 </script>
-
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.convolveMatrix.exceptions.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.convolveMatrix.exceptions.tentative.html
index b80600c141..a288541057 100644
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.convolveMatrix.exceptions.tentative.html
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.convolveMatrix.exceptions.tentative.html
@@ -19,23 +19,39 @@
 var t = async_test("Test exceptions on CanvasFilter() convolveMatrix");
 _addTest(function(canvas, ctx) {
 
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix'}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', divisor: 2}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', kernelMatrix: null}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', kernelMatrix: 1}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', kernelMatrix: [[1, 0], [0]]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', kernelMatrix: [[1, 'a'], [0]]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', kernelMatrix: [[1, 0], 0]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', kernelMatrix: [[1, 0], [0, Infinity]]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', kernelMatrix: []}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', kernelMatrix: [1]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', kernelMatrix: [1, 2, 3, 4]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', kernelMatrix: [[], []]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', kernelMatrix: [[1, 2], []]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'convolveMatrix', kernelMatrix: [[], [1, 2]]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix'}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', divisor: 2}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: null}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: 1}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: [[1, 0], [0]]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: [[1, 'a'], [0]]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: [[1, 0], 0]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: [[1, 0], [0, Infinity]]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: []}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: [1]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: [1, 2, 3, 4]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: [[], []]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: [[1, 2], []]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: [[], [1, 2]]}); });
   // This should not throw an error
-  ctx.filter = new CanvasFilter({name: 'convolveMatrix', kernelMatrix: [[]]});
-  ctx.filter = new CanvasFilter({name: 'convolveMatrix', kernelMatrix: [[1]]});
+  ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: [[]]});
+  ctx.filter = new CanvasFilter(
+    {name: 'convolveMatrix', kernelMatrix: [[1]]});
 
 });
 </script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.dropShadow.exceptions.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.dropShadow.exceptions.tentative.html
index 8c07a72b2b..05984a47f8 100644
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.dropShadow.exceptions.tentative.html
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.dropShadow.exceptions.tentative.html
@@ -19,104 +19,250 @@
 var t = async_test("Test exceptions on CanvasFilter() dropShadow object");
 _addTest(function(canvas, ctx) {
 
+  // Should not throw an error.
   // dx
-  _assert(new CanvasFilter({name: 'dropShadow', dx: 10}), "new CanvasFilter({name: 'dropShadow', dx: 10})");
-  _assert(new CanvasFilter({name: 'dropShadow', dx: -1}), "new CanvasFilter({name: 'dropShadow', dx: -1})");
-  _assert(new CanvasFilter({name: 'dropShadow', dx: 0.5}), "new CanvasFilter({name: 'dropShadow', dx: 0.5})");
-  _assert(new CanvasFilter({name: 'dropShadow', dx: null}), "new CanvasFilter({name: 'dropShadow', dx: null})");
-  _assert(new CanvasFilter({name: 'dropShadow', dx: true}), "new CanvasFilter({name: 'dropShadow', dx: true})");
-  _assert(new CanvasFilter({name: 'dropShadow', dx: false}), "new CanvasFilter({name: 'dropShadow', dx: false})");
-  _assert(new CanvasFilter({name: 'dropShadow', dx: []}), "new CanvasFilter({name: 'dropShadow', dx: []})");
-  _assert(new CanvasFilter({name: 'dropShadow', dx: [20]}), "new CanvasFilter({name: 'dropShadow', dx: [\""+(20)+"\"]})");
-  _assert(new CanvasFilter({name: 'dropShadow', dx: '30'}), "new CanvasFilter({name: 'dropShadow', dx: '30'})");
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: 10});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: -1});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: 0.5});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: null});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: true});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: false});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: []});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: [20]});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: '30'});
   // dy
-  _assert(new CanvasFilter({name: 'dropShadow', dy: 10}), "new CanvasFilter({name: 'dropShadow', dy: 10})");
-  _assert(new CanvasFilter({name: 'dropShadow', dy: -1}), "new CanvasFilter({name: 'dropShadow', dy: -1})");
-  _assert(new CanvasFilter({name: 'dropShadow', dy: 0.5}), "new CanvasFilter({name: 'dropShadow', dy: 0.5})");
-  _assert(new CanvasFilter({name: 'dropShadow', dy: null}), "new CanvasFilter({name: 'dropShadow', dy: null})");
-  _assert(new CanvasFilter({name: 'dropShadow', dy: true}), "new CanvasFilter({name: 'dropShadow', dy: true})");
-  _assert(new CanvasFilter({name: 'dropShadow', dy: false}), "new CanvasFilter({name: 'dropShadow', dy: false})");
-  _assert(new CanvasFilter({name: 'dropShadow', dy: []}), "new CanvasFilter({name: 'dropShadow', dy: []})");
-  _assert(new CanvasFilter({name: 'dropShadow', dy: [20]}), "new CanvasFilter({name: 'dropShadow', dy: [\""+(20)+"\"]})");
-  _assert(new CanvasFilter({name: 'dropShadow', dy: '30'}), "new CanvasFilter({name: 'dropShadow', dy: '30'})");
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: 10});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: -1});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: 0.5});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: null});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: true});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: false});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: []});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: [20]});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: '30'});
   // floodOpacity
-  _assert(new CanvasFilter({name: 'dropShadow', floodOpacity: 10}), "new CanvasFilter({name: 'dropShadow', floodOpacity: 10})");
-  _assert(new CanvasFilter({name: 'dropShadow', floodOpacity: -1}), "new CanvasFilter({name: 'dropShadow', floodOpacity: -1})");
-  _assert(new CanvasFilter({name: 'dropShadow', floodOpacity: 0.5}), "new CanvasFilter({name: 'dropShadow', floodOpacity: 0.5})");
-  _assert(new CanvasFilter({name: 'dropShadow', floodOpacity: null}), "new CanvasFilter({name: 'dropShadow', floodOpacity: null})");
-  _assert(new CanvasFilter({name: 'dropShadow', floodOpacity: true}), "new CanvasFilter({name: 'dropShadow', floodOpacity: true})");
-  _assert(new CanvasFilter({name: 'dropShadow', floodOpacity: false}), "new CanvasFilter({name: 'dropShadow', floodOpacity: false})");
-  _assert(new CanvasFilter({name: 'dropShadow', floodOpacity: []}), "new CanvasFilter({name: 'dropShadow', floodOpacity: []})");
-  _assert(new CanvasFilter({name: 'dropShadow', floodOpacity: [20]}), "new CanvasFilter({name: 'dropShadow', floodOpacity: [\""+(20)+"\"]})");
-  _assert(new CanvasFilter({name: 'dropShadow', floodOpacity: '30'}), "new CanvasFilter({name: 'dropShadow', floodOpacity: '30'})");
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: 10});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: -1});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: 0.5});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: null});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: true});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: false});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: []});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: [20]});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: '30'});
+  // dx
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: 10});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: -1});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: 0.5});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: null});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: true});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: false});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: []});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: [20]});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: '30'});
+  // dy
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: 10});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: -1});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: 0.5});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: null});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: true});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: false});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: []});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: [20]});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: '30'});
+  // floodOpacity
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: 10});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: -1});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: 0.5});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: null});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: true});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: false});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: []});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: [20]});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: '30'});
   // stdDeviation
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: 10}), "new CanvasFilter({name: 'dropShadow', stdDeviation: 10})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: -1}), "new CanvasFilter({name: 'dropShadow', stdDeviation: -1})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: 0.5}), "new CanvasFilter({name: 'dropShadow', stdDeviation: 0.5})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: null}), "new CanvasFilter({name: 'dropShadow', stdDeviation: null})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: true}), "new CanvasFilter({name: 'dropShadow', stdDeviation: true})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: false}), "new CanvasFilter({name: 'dropShadow', stdDeviation: false})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: []}), "new CanvasFilter({name: 'dropShadow', stdDeviation: []})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: [20]}), "new CanvasFilter({name: 'dropShadow', stdDeviation: [\""+(20)+"\"]})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: '30'}), "new CanvasFilter({name: 'dropShadow', stdDeviation: '30'})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: [10, -1]}), "new CanvasFilter({name: 'dropShadow', stdDeviation: [10, -1]})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: [0.5, null]}), "new CanvasFilter({name: 'dropShadow', stdDeviation: [0.5, null]})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: [true, false]}), "new CanvasFilter({name: 'dropShadow', stdDeviation: [true, false]})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: [[], [20]]}), "new CanvasFilter({name: 'dropShadow', stdDeviation: [[], [\""+(20)+"\"]]})");
-  _assert(new CanvasFilter({name: 'dropShadow', stdDeviation: ['30', ['40']]}), "new CanvasFilter({name: 'dropShadow', stdDeviation: ['30', ['40']]})");
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: 10});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: -1});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: 0.5});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: null});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: true});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: false});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: []});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [20]});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: '30'});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [10, -1]});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [0.5, null]});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [true, false]});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [[], [20]]});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: ['30', ['40']]});
   // floodColor
-  _assert(new CanvasFilter({name: 'dropShadow', floodColor: 'red'}), "new CanvasFilter({name: 'dropShadow', floodColor: 'red'})");
-  _assert(new CanvasFilter({name: 'dropShadow', floodColor: 'canvas'}), "new CanvasFilter({name: 'dropShadow', floodColor: 'canvas'})");
-  _assert(new CanvasFilter({name: 'dropShadow', floodColor: 'rgba(4, -3, 0.5, 1)'}), "new CanvasFilter({name: 'dropShadow', floodColor: 'rgba(4, -3, 0.5, 1)'})");
-  _assert(new CanvasFilter({name: 'dropShadow', floodColor: '#aabbccdd'}), "new CanvasFilter({name: 'dropShadow', floodColor: '#aabbccdd'})");
-  _assert(new CanvasFilter({name: 'dropShadow', floodColor: '#abcd'}), "new CanvasFilter({name: 'dropShadow', floodColor: '#abcd'})");
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodColor: 'red'});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodColor: 'canvas'});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodColor: 'rgba(4, -3, 0.5, 1)'});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodColor: '#aabbccdd'});
+  ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodColor: '#abcd'});
 
+  // Should throw a TypeError.
   // dx
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dx: NaN}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dx: Infinity}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dx: -Infinity}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dx: undefined}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dx: 'test'}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dx: {}}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dx: [1, 2]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: NaN}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: Infinity}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: -Infinity}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: undefined}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: 'test'}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: {}}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dx: [1, 2]}); });
   // dy
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dy: NaN}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dy: Infinity}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dy: -Infinity}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dy: undefined}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dy: 'test'}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dy: {}}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', dy: [1, 2]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: NaN}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: Infinity}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: -Infinity}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: undefined}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: 'test'}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: {}}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', dy: [1, 2]}); });
   // floodOpacity
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodOpacity: NaN}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodOpacity: Infinity}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodOpacity: -Infinity}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodOpacity: undefined}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodOpacity: 'test'}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodOpacity: {}}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodOpacity: [1, 2]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: NaN}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: Infinity}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: -Infinity}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: undefined}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: 'test'}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: {}}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodOpacity: [1, 2]}); });
   // stdDeviation
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: NaN}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: Infinity}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: -Infinity}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: undefined}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: 'test'}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: {}}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: [1, 2, 3]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: [1, NaN]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: [1, Infinity]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: [1, -Infinity]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: [1, undefined]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: [1, 'test']}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: [1, {}]}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', stdDeviation: [1, [2, 3]]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: NaN}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: Infinity}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: -Infinity}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: undefined}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: 'test'}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: {}}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [1, 2, 3]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [1, NaN]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [1, Infinity]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [1, -Infinity]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [1, undefined]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [1, 'test']}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [1, {}]}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', stdDeviation: [1, [2, 3]]}); });
   // floodColor
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodColor: 'test'}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodColor: 'rgba(NaN, 3, 2, 1)'}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodColor: 10}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodColor: undefined}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodColor: null}); });
-  assert_throws_js(TypeError, function() { new CanvasFilter({name: 'dropShadow', floodColor: NaN}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodColor: 'test'}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodColor: 'rgba(NaN, 3, 2, 1)'}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodColor: 10}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodColor: undefined}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodColor: null}); });
+  assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(
+    {name: 'dropShadow', floodColor: NaN}); });
 
 });
 </script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.dropShadow.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.dropShadow.tentative.html
index 47bb891b3f..d6e7066473 100644
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.dropShadow.tentative.html
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.dropShadow.tentative.html
@@ -22,86 +22,58 @@
   // Parameter defaults.
   ctx.filter = new CanvasFilter({name: 'dropShadow'});
   ctx.fillRect(10, 10, 80, 80);
-
   // All parameters specified.
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 5,
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 5,
      floodColor: 'purple', floodOpacity: 0.7});
   ctx.fillRect(110, 10, 80, 80);
-
   // Named color.
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
      floodColor: 'purple'});
   ctx.fillRect(10, 110, 80, 80);
-
   // System color.
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
      floodColor: 'LinkText'});
   ctx.fillRect(110, 110, 80, 80);
-
   // Numerical color.
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
      floodColor: 'rgba(20, 50, 130, 1)'});
   ctx.fillRect(210, 110, 80, 80);
-
   // Transparent floodColor.
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
      floodColor: 'rgba(20, 50, 130, 0.7)'});
   ctx.fillRect(310, 110, 80, 80);
-
   // Transparent floodColor and floodOpacity.
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
      floodColor: 'rgba(20, 50, 130, 0.7)', floodOpacity: 0.7});
   ctx.fillRect(410, 110, 80, 80);
-
   // No blur.
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 0,
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 0,
      floodColor: 'purple'});
   ctx.fillRect(10, 210, 80, 80);
-
   // Single float blur.
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 5,
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 5,
      floodColor: 'purple'});
   ctx.fillRect(110, 210, 80, 80);
-
   // Single negative float blur.
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: -5,
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: 9, dy: 12, stdDeviation: -5,
      floodColor: 'purple'});
   ctx.fillRect(210, 210, 80, 80);
-
   // Two floats (X&Y) blur.
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: [3, 5],
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: 9, dy: 12, stdDeviation: [3, 5],
      floodColor: 'purple'});
   ctx.fillRect(310, 210, 80, 80);
-
   // Two negative floats (X&Y) blur.
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: [-3, -5],
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: 9, dy: 12, stdDeviation: [-3, -5],
      floodColor: 'purple'});
   ctx.fillRect(410, 210, 80, 80);
-
   // Degenerate parameter values.
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: [-5], dy: [], stdDeviation: null,
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: [-5], dy: [], stdDeviation: null,
      floodColor: 'purple', floodOpacity: [2]});
   ctx.fillRect(10, 310, 80, 80);
-
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: null, dy: '5', stdDeviation: [[-5], ['3']],
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: null, dy: '5', stdDeviation: [[-5], ['3']],
      floodColor: 'purple', floodOpacity: '0.8'});
   ctx.fillRect(110, 310, 80, 80);
-
-  ctx.filter = new CanvasFilter(
-    {name: 'dropShadow', dx: true, dy: ['10'], stdDeviation: false,
+  ctx.filter = new CanvasFilter({name: 'dropShadow', dx: true, dy: ['10'], stdDeviation: false,
      floodColor: 'purple', floodOpacity: ['0.4']});
   ctx.fillRect(210, 310, 80, 80);
 </script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative-expected.html
new file mode 100644
index 0000000000..dac31c97f1
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative-expected.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative</title>
+<h1>2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="100" height="100"
+     color-interpolation-filters="sRGB">
+  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
+    <feGaussianBlur stdDeviation="4 4" />
+  </filter>
+  <rect x="25" y="25" width="50" height="50"
+        fill="teal" filter="url(#blur)" />
+</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative.html
new file mode 100644
index 0000000000..f4c8c1033a
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative-expected.html">
+<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative</title>
+<h1>2d.filter.canvasFilterObject.gaussianBlur.isotropic.tentative</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  ctx.fillStyle = 'teal';
+  ctx.filter = new CanvasFilter({
+      name: 'gaussianBlur',
+      stdDeviation: [4, 4],
+  });
+  ctx.fillRect(25, 25, 50, 50);
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative-expected.html
new file mode 100644
index 0000000000..88d0cb2de2
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative-expected.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative</title>
+<h1>2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="100" height="100"
+     color-interpolation-filters="sRGB">
+  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
+    <feGaussianBlur stdDeviation="4 1" />
+  </filter>
+  <rect x="25" y="25" width="50" height="50"
+        fill="teal" filter="url(#blur)" />
+</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative.html
new file mode 100644
index 0000000000..b3efcb8c3e
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative-expected.html">
+<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative</title>
+<h1>2d.filter.canvasFilterObject.gaussianBlur.mostly-x.tentative</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  ctx.fillStyle = 'teal';
+  ctx.filter = new CanvasFilter({
+      name: 'gaussianBlur',
+      stdDeviation: [4, 1],
+  });
+  ctx.fillRect(25, 25, 50, 50);
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative-expected.html
new file mode 100644
index 0000000000..744983d4ae
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative-expected.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative</title>
+<h1>2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="100" height="100"
+     color-interpolation-filters="sRGB">
+  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
+    <feGaussianBlur stdDeviation="1 4" />
+  </filter>
+  <rect x="25" y="25" width="50" height="50"
+        fill="teal" filter="url(#blur)" />
+</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative.html
new file mode 100644
index 0000000000..d5cc6e0058
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative-expected.html">
+<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative</title>
+<h1>2d.filter.canvasFilterObject.gaussianBlur.mostly-y.tentative</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  ctx.fillStyle = 'teal';
+  ctx.filter = new CanvasFilter({
+      name: 'gaussianBlur',
+      stdDeviation: [1, 4],
+  });
+  ctx.fillRect(25, 25, 50, 50);
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic-expected.html
deleted file mode 100644
index f9571f208e..0000000000
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic-expected.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
-<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic</title>
-<h1>2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic</h1>
-<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
-
-<svg xmlns="http://www.w3.org/2000/svg"
-     width="100" height="100"
-     color-interpolation-filters="sRGB">
-  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
-    <feGaussianBlur stdDeviation="4 4" />
-  </filter>
-  <rect x="25" y="25" width="50" height="50"
-        fill="teal" filter="url(#blur)" />
-</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic.html
deleted file mode 100644
index 6376d07b0e..0000000000
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic.html
+++ /dev/null
@@ -1,20 +0,0 @@
-<!DOCTYPE html>
-<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
-<link rel="match" href="2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic-expected.html">
-<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic</title>
-<h1>2d.filter.canvasFilterObject.gaussianBlur.tentative.isotropic</h1>
-<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
-<canvas id="canvas" width="100" height="100">
-  <p class="fallback">FAIL (fallback content)</p>
-</canvas>
-<script>
-  const canvas = document.getElementById("canvas");
-  const ctx = canvas.getContext('2d');
-
-  ctx.fillStyle = 'teal';
-  ctx.filter = new CanvasFilter({
-      name: 'gaussianBlur',
-      stdDeviation: [4, 4],
-  });
-  ctx.fillRect(25, 25, 50, 50);
-</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x-expected.html
deleted file mode 100644
index e76613271f..0000000000
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x-expected.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
-<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x</title>
-<h1>2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x</h1>
-<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
-
-<svg xmlns="http://www.w3.org/2000/svg"
-     width="100" height="100"
-     color-interpolation-filters="sRGB">
-  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
-    <feGaussianBlur stdDeviation="4 1" />
-  </filter>
-  <rect x="25" y="25" width="50" height="50"
-        fill="teal" filter="url(#blur)" />
-</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x.html
deleted file mode 100644
index 145cb32757..0000000000
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x.html
+++ /dev/null
@@ -1,20 +0,0 @@
-<!DOCTYPE html>
-<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
-<link rel="match" href="2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x-expected.html">
-<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x</title>
-<h1>2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-x</h1>
-<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
-<canvas id="canvas" width="100" height="100">
-  <p class="fallback">FAIL (fallback content)</p>
-</canvas>
-<script>
-  const canvas = document.getElementById("canvas");
-  const ctx = canvas.getContext('2d');
-
-  ctx.fillStyle = 'teal';
-  ctx.filter = new CanvasFilter({
-      name: 'gaussianBlur',
-      stdDeviation: [4, 1],
-  });
-  ctx.fillRect(25, 25, 50, 50);
-</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y-expected.html
deleted file mode 100644
index 0f214fca9f..0000000000
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y-expected.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
-<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y</title>
-<h1>2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y</h1>
-<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
-
-<svg xmlns="http://www.w3.org/2000/svg"
-     width="100" height="100"
-     color-interpolation-filters="sRGB">
-  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
-    <feGaussianBlur stdDeviation="1 4" />
-  </filter>
-  <rect x="25" y="25" width="50" height="50"
-        fill="teal" filter="url(#blur)" />
-</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y.html
deleted file mode 100644
index e921e0eaa6..0000000000
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y.html
+++ /dev/null
@@ -1,20 +0,0 @@
-<!DOCTYPE html>
-<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
-<link rel="match" href="2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y-expected.html">
-<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y</title>
-<h1>2d.filter.canvasFilterObject.gaussianBlur.tentative.mostly-y</h1>
-<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
-<canvas id="canvas" width="100" height="100">
-  <p class="fallback">FAIL (fallback content)</p>
-</canvas>
-<script>
-  const canvas = document.getElementById("canvas");
-  const ctx = canvas.getContext('2d');
-
-  ctx.fillStyle = 'teal';
-  ctx.filter = new CanvasFilter({
-      name: 'gaussianBlur',
-      stdDeviation: [1, 4],
-  });
-  ctx.fillRect(25, 25, 50, 50);
-</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only-expected.html
deleted file mode 100644
index 285a641726..0000000000
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only-expected.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
-<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only</title>
-<h1>2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only</h1>
-<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
-
-<svg xmlns="http://www.w3.org/2000/svg"
-     width="100" height="100"
-     color-interpolation-filters="sRGB">
-  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
-    <feGaussianBlur stdDeviation="4 0" />
-  </filter>
-  <rect x="25" y="25" width="50" height="50"
-        fill="teal" filter="url(#blur)" />
-</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only.html
deleted file mode 100644
index fd6ac687f9..0000000000
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only.html
+++ /dev/null
@@ -1,20 +0,0 @@
-<!DOCTYPE html>
-<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
-<link rel="match" href="2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only-expected.html">
-<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only</title>
-<h1>2d.filter.canvasFilterObject.gaussianBlur.tentative.x-only</h1>
-<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
-<canvas id="canvas" width="100" height="100">
-  <p class="fallback">FAIL (fallback content)</p>
-</canvas>
-<script>
-  const canvas = document.getElementById("canvas");
-  const ctx = canvas.getContext('2d');
-
-  ctx.fillStyle = 'teal';
-  ctx.filter = new CanvasFilter({
-      name: 'gaussianBlur',
-      stdDeviation: [4, 0],
-  });
-  ctx.fillRect(25, 25, 50, 50);
-</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only-expected.html
deleted file mode 100644
index d59945b5da..0000000000
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only-expected.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
-<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only</title>
-<h1>2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only</h1>
-<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
-
-<svg xmlns="http://www.w3.org/2000/svg"
-     width="100" height="100"
-     color-interpolation-filters="sRGB">
-  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
-    <feGaussianBlur stdDeviation="0 4" />
-  </filter>
-  <rect x="25" y="25" width="50" height="50"
-        fill="teal" filter="url(#blur)" />
-</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only.html
deleted file mode 100644
index 6442433e7c..0000000000
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only.html
+++ /dev/null
@@ -1,20 +0,0 @@
-<!DOCTYPE html>
-<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
-<link rel="match" href="2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only-expected.html">
-<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only</title>
-<h1>2d.filter.canvasFilterObject.gaussianBlur.tentative.y-only</h1>
-<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
-<canvas id="canvas" width="100" height="100">
-  <p class="fallback">FAIL (fallback content)</p>
-</canvas>
-<script>
-  const canvas = document.getElementById("canvas");
-  const ctx = canvas.getContext('2d');
-
-  ctx.fillStyle = 'teal';
-  ctx.filter = new CanvasFilter({
-      name: 'gaussianBlur',
-      stdDeviation: [0, 4],
-  });
-  ctx.fillRect(25, 25, 50, 50);
-</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative-expected.html
new file mode 100644
index 0000000000..e611113e42
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative-expected.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative</title>
+<h1>2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="100" height="100"
+     color-interpolation-filters="sRGB">
+  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
+    <feGaussianBlur stdDeviation="4 0" />
+  </filter>
+  <rect x="25" y="25" width="50" height="50"
+        fill="teal" filter="url(#blur)" />
+</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative.html
new file mode 100644
index 0000000000..4e8576fe74
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative-expected.html">
+<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative</title>
+<h1>2d.filter.canvasFilterObject.gaussianBlur.x-only.tentative</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  ctx.fillStyle = 'teal';
+  ctx.filter = new CanvasFilter({
+      name: 'gaussianBlur',
+      stdDeviation: [4, 0],
+  });
+  ctx.fillRect(25, 25, 50, 50);
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative-expected.html
new file mode 100644
index 0000000000..c6d915cb07
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative-expected.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative</title>
+<h1>2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="100" height="100"
+     color-interpolation-filters="sRGB">
+  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
+    <feGaussianBlur stdDeviation="0 4" />
+  </filter>
+  <rect x="25" y="25" width="50" height="50"
+        fill="teal" filter="url(#blur)" />
+</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative.html
new file mode 100644
index 0000000000..ec0a2353cf
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative-expected.html">
+<title>Canvas test: 2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative</title>
+<h1>2d.filter.canvasFilterObject.gaussianBlur.y-only.tentative</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  ctx.fillStyle = 'teal';
+  ctx.filter = new CanvasFilter({
+      name: 'gaussianBlur',
+      stdDeviation: [0, 4],
+  });
+  ctx.fillRect(25, 25, 50, 50);
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.turbulence.inputTypes.tentative.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.turbulence.inputTypes.tentative.html
index c24cfd2398..b85add4b66 100644
--- a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.turbulence.inputTypes.tentative.html
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.canvasFilterObject.turbulence.inputTypes.tentative.html
@@ -116,12 +116,12 @@ _addTest(function(canvas, ctx) {
 
   for (testCase of errorTestCases) {
     const filterOptions = {...{name: 'turbulence'}, ...testCase};
-    assert_throws_js(TypeError, function() { new CanvasFilter(filterOptions); });
+    assert_throws_js(TypeError, function() { ctx.filter = new CanvasFilter(filterOptions); });
   }
 
   for (testCase of workingTestCases) {
     const filterOptions = {...{name: 'turbulence'}, ...testCase};
-    _assert(new CanvasFilter(filterOptions) != null, "new CanvasFilter(filterOptions) != null");
+    ctx.filter = new CanvasFilter(filterOptions);
   }
 
 });
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.blur.exceptions.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.blur.exceptions.html
new file mode 100644
index 0000000000..7176a7d0a4
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.blur.exceptions.html
@@ -0,0 +1,37 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.blur.exceptions</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/html/canvas/resources/canvas-tests.js"></script>
+<link rel="stylesheet" href="/html/canvas/resources/canvas-tests.css">
+<body class="show_output">
+
+<h1>2d.filter.layers.blur.exceptions</h1>
+<p class="desc">Test exceptions on gaussianBlur filter</p>
+
+
+<p class="output">Actual output:</p>
+<canvas id="c" class="output" width="100" height="50"><p class="fallback">FAIL (fallback content)</p></canvas>
+
+<ul id="d"></ul>
+<script>
+var t = async_test("Test exceptions on gaussianBlur filter");
+_addTest(function(canvas, ctx) {
+
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'gaussianBlur'}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'gaussianBlur', stdDeviation: undefined}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'gaussianBlur', stdDeviation: 'foo'}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'gaussianBlur', stdDeviation: [1,2,3]}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'gaussianBlur', stdDeviation: NaN}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'gaussianBlur', stdDeviation: {}}}); });
+
+});
+</script>
+
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.colorMatrix.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.colorMatrix.html
new file mode 100644
index 0000000000..ef0ae0f949
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.colorMatrix.html
@@ -0,0 +1,104 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.colorMatrix</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/html/canvas/resources/canvas-tests.js"></script>
+<link rel="stylesheet" href="/html/canvas/resources/canvas-tests.css">
+<body class="show_output">
+
+<h1>2d.filter.layers.colorMatrix</h1>
+<p class="desc">Test the functionality of ColorMatrix filters</p>
+
+
+<p class="output">Actual output:</p>
+<canvas id="c" class="output" width="100" height="50"><p class="fallback">FAIL (fallback content)</p></canvas>
+
+<ul id="d"></ul>
+<script>
+var t = async_test("Test the functionality of ColorMatrix filters");
+_addTest(function(canvas, ctx) {
+
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'colorMatrix', values: undefined}}); });
+
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'colorMatrix', values: 'foo'}}); });
+
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'colorMatrix', values: null}}); });
+
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'colorMatrix', values: [1, 2, 3]}}); });
+
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'colorMatrix',
+     values: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+              19, 'a']}}); });
+
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'colorMatrix',
+     values: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+              19, Infinity]}}); });
+
+  ctx.fillStyle = '#f00';
+  ctx.beginLayer({filter:
+    {name: 'colorMatrix', type: 'hueRotate', values: 0}});
+  ctx.fillRect(0, 0, 100, 50);
+  ctx.endLayer();
+  _assertPixelApprox(canvas, 10,10, 255,0,0,255, 2);
+
+  ctx.beginLayer({filter:
+    {name: 'colorMatrix', type: 'hueRotate', values: 90}});
+  ctx.fillRect(0, 0, 100, 50);
+  ctx.endLayer();
+  _assertPixelApprox(canvas, 10,10, 0,91,0,255, 2);
+
+  ctx.beginLayer({filter:
+    {name: 'colorMatrix', type: 'hueRotate', values: 180}});
+  ctx.fillRect(0, 0, 100, 50);
+  ctx.endLayer();
+  _assertPixelApprox(canvas, 10,10, 0,109,109,255, 2);
+
+  ctx.beginLayer({filter:
+    {name: 'colorMatrix', type: 'hueRotate', values: 270}});
+  ctx.fillRect(0, 0, 100, 50);
+  ctx.endLayer();
+  _assertPixelApprox(canvas, 10,10, 109,18,255,255, 2);
+
+  ctx.beginLayer({filter:
+    {name: 'colorMatrix', type: 'saturate', values: 0.5}});
+  ctx.fillRect(0, 0, 100, 50);
+  ctx.endLayer();
+  _assertPixelApprox(canvas, 10,10, 155,27,27,255, 2);
+
+  ctx.clearRect(0, 0, 100, 50);
+  ctx.beginLayer({filter:
+    {name: 'colorMatrix', type: 'luminanceToAlpha'}});
+  ctx.fillRect(0, 0, 100, 50);
+  ctx.endLayer();
+  _assertPixelApprox(canvas, 10,10, 0,0,0,54, 2);
+
+  ctx.beginLayer({filter:
+    {name: 'colorMatrix', values: [
+      0, 0, 0, 0, 0,
+      1, 1, 1, 1, 0,
+      0, 0, 0, 0, 0,
+      0, 0, 0, 1, 0
+    ]}});
+  ctx.fillRect(0, 0, 50, 25);
+  ctx.fillStyle = '#0f0';
+  ctx.fillRect(50, 0, 50, 25);
+  ctx.fillStyle = '#00f';
+  ctx.fillRect(0, 25, 50, 25);
+  ctx.fillStyle = '#fff';
+  ctx.fillRect(50, 25, 50, 25);
+  ctx.endLayer();
+  _assertPixelApprox(canvas, 10,10, 0,255,0,255, 2);
+  _assertPixelApprox(canvas, 60,10, 0,255,0,255, 2);
+  _assertPixelApprox(canvas, 10,30, 0,255,0,255, 2);
+  _assertPixelApprox(canvas, 60,30, 0,255,0,255, 2);
+
+});
+</script>
+
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.discrete-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.discrete-expected.html
new file mode 100644
index 0000000000..8419953b3d
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.discrete-expected.html
@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.componentTransfer.discrete</title>
+<h1>2d.filter.layers.componentTransfer.discrete</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with discrete type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  // From https://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
+  function getTransformedValue(C, V) {
+      // Get the right interval
+      const n = V.length;
+      const k = C == 1 ? n - 1 : Math.floor(C * n);
+      return V[k];
+  }
+
+  function getColor(inputColor, tableValues) {
+      const result = [0, 0, 0];
+      for (const i in inputColor) {
+          const C = inputColor[i]/255;
+          const Cprime = getTransformedValue(C, tableValues[i]);
+          result[i] = Math.max(0, Math.min(1, Cprime)) * 255;
+      }
+      return result;
+  }
+
+  tableValuesR = [0, 0, 1, 1];
+  tableValuesG = [2, 0, 0.5, 3];
+  tableValuesB = [1, -1, 5, 0];
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      let outputColor = getColor(
+          color, [tableValuesR, tableValuesG, tableValuesB]);
+      ctx.fillStyle = `rgb(${outputColor[0]}, ${outputColor[1]},
+        ${outputColor[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.discrete.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.discrete.html
new file mode 100644
index 0000000000..ef9db79547
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.discrete.html
@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.layers.componentTransfer.discrete-expected.html">
+<meta name=fuzzy content="maxDifference=0-2; totalPixels=0-500">
+<title>Canvas test: 2d.filter.layers.componentTransfer.discrete</title>
+<h1>2d.filter.layers.componentTransfer.discrete</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with discrete type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  tableValuesR = [0, 0, 1, 1];
+  tableValuesG = [2, 0, 0.5, 3];
+  tableValuesB = [1, -1, 5, 0];
+  ctx.beginLayer({filter: {name: 'componentTransfer',
+      funcR: {type: 'discrete', tableValues: tableValuesR},
+      funcG: {type: 'discrete', tableValues: tableValuesG},
+      funcB: {type: 'discrete', tableValues: tableValuesB},
+  }});
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      ctx.fillStyle = `rgb(${color[0]}, ${color[1]}, ${color[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+  ctx.endLayer();
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.gamma-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.gamma-expected.html
new file mode 100644
index 0000000000..3e5d980896
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.gamma-expected.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.componentTransfer.gamma</title>
+<h1>2d.filter.layers.componentTransfer.gamma</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with gamma type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  // From https://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
+  function getColor(inputColor, amplitude, exponent, offset) {
+      return [
+          Math.max(0, Math.min(1, Math.pow(inputColor[0]/255,
+            exponent[0]) * amplitude[0] + offset[0])) * 255,
+          Math.max(0, Math.min(1, Math.pow(inputColor[1]/255,
+            exponent[1]) * amplitude[1] + offset[1])) * 255,
+          Math.max(0, Math.min(1, Math.pow(inputColor[2]/255,
+            exponent[2]) * amplitude[2] + offset[2])) * 255,
+      ];
+  }
+
+  const amplitudes = [2, 1.1, 0.5];
+  const exponents = [5, 3, 1];
+  const offsets = [0.25, 0, 0.5];
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      let outputColor = getColor(color, amplitudes, exponents, offsets);
+      ctx.fillStyle = `rgb(${outputColor[0]}, ${outputColor[1]},
+        ${outputColor[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.gamma.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.gamma.html
new file mode 100644
index 0000000000..cccd07e92b
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.gamma.html
@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.layers.componentTransfer.gamma-expected.html">
+<meta name=fuzzy content="maxDifference=0-2; totalPixels=0-500">
+<title>Canvas test: 2d.filter.layers.componentTransfer.gamma</title>
+<h1>2d.filter.layers.componentTransfer.gamma</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with gamma type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  const amplitudes = [2, 1.1, 0.5];
+  const exponents = [5, 3, 1];
+  const offsets = [0.25, 0, 0.5];
+  ctx.beginLayer({filter: {name: 'componentTransfer',
+      funcR: {type: 'gamma', amplitude: amplitudes[0],
+        exponent: exponents[0], offset: offsets[0]},
+      funcG: {type: 'gamma', amplitude: amplitudes[1],
+        exponent: exponents[1], offset: offsets[1]},
+      funcB: {type: 'gamma', amplitude: amplitudes[2],
+        exponent: exponents[2], offset: offsets[2]},
+  }});
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      ctx.fillStyle = `rgb(${color[0]}, ${color[1]}, ${color[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+  ctx.endLayer();
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.identity-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.identity-expected.html
new file mode 100644
index 0000000000..9f1439f37b
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.identity-expected.html
@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.componentTransfer.identity</title>
+<h1>2d.filter.layers.componentTransfer.identity</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with identity type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      let outputColor = inputColors[i];
+      ctx.fillStyle = `rgb(${outputColor[0]}, ${outputColor[1]},
+        ${outputColor[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.identity.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.identity.html
new file mode 100644
index 0000000000..3a06353849
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.identity.html
@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.layers.componentTransfer.identity-expected.html">
+<title>Canvas test: 2d.filter.layers.componentTransfer.identity</title>
+<h1>2d.filter.layers.componentTransfer.identity</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with identity type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  ctx.beginLayer({filter: {name: 'componentTransfer',
+      funcR: {type: 'identity'},
+      funcG: {type: 'identity'},
+      funcB: {type: 'identity'},
+  }});
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      ctx.fillStyle = `rgb(${color[0]}, ${color[1]}, ${color[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+  ctx.endLayer();
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.linear-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.linear-expected.html
new file mode 100644
index 0000000000..f922055ff2
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.linear-expected.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.componentTransfer.linear</title>
+<h1>2d.filter.layers.componentTransfer.linear</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with linear type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  // From https://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
+  function getColor(inputColor, slopes, intercepts) {
+      return [
+          Math.max(0, Math.min(1,
+            inputColor[0]/255 * slopes[0] + intercepts[0])) * 255,
+          Math.max(0, Math.min(1,
+            inputColor[1]/255 * slopes[1] + intercepts[1])) * 255,
+          Math.max(0, Math.min(1,
+            inputColor[2]/255 * slopes[2] + intercepts[2])) * 255,
+      ];
+  }
+
+  const slopes = [0.5, 1.2, -0.2];
+  const intercepts = [0.25, 0, 0.5];
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      let outputColor = getColor(color, slopes, intercepts);
+      ctx.fillStyle = `rgb(${outputColor[0]}, ${outputColor[1]},
+        ${outputColor[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+  ctx.endLayer();
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.linear.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.linear.html
new file mode 100644
index 0000000000..c9e744ebef
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.linear.html
@@ -0,0 +1,37 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.layers.componentTransfer.linear-expected.html">
+<meta name=fuzzy content="maxDifference=0-2; totalPixels=0-500">
+<title>Canvas test: 2d.filter.layers.componentTransfer.linear</title>
+<h1>2d.filter.layers.componentTransfer.linear</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with linear type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  const slopes = [0.5, 1.2, -0.2];
+  const intercepts = [0.25, 0, 0.5];
+  ctx.beginLayer({filter: {name: 'componentTransfer',
+      funcR: {type: 'linear', slope: slopes[0], intercept: intercepts[0]},
+      funcG: {type: 'linear', slope: slopes[1], intercept: intercepts[1]},
+      funcB: {type: 'linear', slope: slopes[2], intercept: intercepts[2]},
+  }});
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      ctx.fillStyle = `rgb(${color[0]}, ${color[1]}, ${color[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+  ctx.endLayer();
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.table-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.table-expected.html
new file mode 100644
index 0000000000..0f6736d87d
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.table-expected.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.componentTransfer.table</title>
+<h1>2d.filter.layers.componentTransfer.table</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with table type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  // From https://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
+  function getTransformedValue(C, V) {
+      // Get the right interval
+      const n = V.length - 1;
+      const k = C == 1 ? n - 1 : Math.floor(C * n);
+      return V[k] + (C - k/n) * n * (V[k + 1] - V[k]);
+  }
+
+  function getColor(inputColor, tableValues) {
+      const result = [0, 0, 0];
+      for (const i in inputColor) {
+          const C = inputColor[i]/255;
+          const Cprime = getTransformedValue(C, tableValues[i]);
+          result[i] = Math.max(0, Math.min(1, Cprime)) * 255;
+      }
+      return result;
+  }
+
+  tableValuesR = [0, 0, 1, 1];
+  tableValuesG = [2, 0, 0.5, 3];
+  tableValuesB = [1, -1, 5, 0];
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      let outputColor = getColor(
+          color, [tableValuesR, tableValuesG, tableValuesB]);
+      ctx.fillStyle = `rgb(${outputColor[0]}, ${outputColor[1]},
+        ${outputColor[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.table.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.table.html
new file mode 100644
index 0000000000..eae036b142
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.componentTransfer.table.html
@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.layers.componentTransfer.table-expected.html">
+<meta name=fuzzy content="maxDifference=0-2; totalPixels=0-500">
+<title>Canvas test: 2d.filter.layers.componentTransfer.table</title>
+<h1>2d.filter.layers.componentTransfer.table</h1>
+<p class="desc">Test pixels on CanvasFilter() componentTransfer with table type</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  tableValuesR = [0, 0, 1, 1];
+  tableValuesG = [2, 0, 0.5, 3];
+  tableValuesB = [1, -1, 5, 0];
+  ctx.beginLayer({filter: {name: 'componentTransfer',
+      funcR: {type: 'table', tableValues: tableValuesR},
+      funcG: {type: 'table', tableValues: tableValuesG},
+      funcB: {type: 'table', tableValues: tableValuesB},
+  }});
+
+  const inputColors = [
+      [255, 255, 255],
+      [0, 0, 0],
+      [127, 0, 34],
+      [252, 186, 3],
+      [50, 68, 87],
+  ];
+
+  for (let i = 0 ; i < inputColors.length ; ++i) {
+      const color = inputColors[i];
+      ctx.fillStyle = `rgb(${color[0]}, ${color[1]}, ${color[2]})`;
+      ctx.fillRect(i * 10, i * 10, 10, 10);
+  }
+  ctx.endLayer();
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.convolveMatrix.exceptions.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.convolveMatrix.exceptions.html
new file mode 100644
index 0000000000..ae45cb865c
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.convolveMatrix.exceptions.html
@@ -0,0 +1,60 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.convolveMatrix.exceptions</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/html/canvas/resources/canvas-tests.js"></script>
+<link rel="stylesheet" href="/html/canvas/resources/canvas-tests.css">
+<body class="show_output">
+
+<h1>2d.filter.layers.convolveMatrix.exceptions</h1>
+<p class="desc">Test exceptions on CanvasFilter() convolveMatrix</p>
+
+
+<p class="output">Actual output:</p>
+<canvas id="c" class="output" width="100" height="50"><p class="fallback">FAIL (fallback content)</p></canvas>
+
+<ul id="d"></ul>
+<script>
+var t = async_test("Test exceptions on CanvasFilter() convolveMatrix");
+_addTest(function(canvas, ctx) {
+
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix'}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', divisor: 2}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: null}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: 1}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: [[1, 0], [0]]}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: [[1, 'a'], [0]]}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: [[1, 0], 0]}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: [[1, 0], [0, Infinity]]}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: []}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: [1]}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: [1, 2, 3, 4]}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: [[], []]}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: [[1, 2], []]}}); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: [[], [1, 2]]}}); });
+  // This should not throw an error
+  ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: [[]]}});
+  ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'convolveMatrix', kernelMatrix: [[1]]}});
+  ctx.endLayer();
+
+});
+</script>
+
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.dropShadow-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.dropShadow-expected.html
new file mode 100644
index 0000000000..1719d99b4a
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.dropShadow-expected.html
@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.dropShadow</title>
+<h1>2d.filter.layers.dropShadow</h1>
+<p class="desc">Test CanvasFilter() dropShadow object.</p>
+
+<svg xmlns="http://www.w3.org/2000/svg"
+     width=520 height=420
+     color-interpolation-filters="sRGB">
+  <rect x=0 y=0 width=100% height=50 fill="teal" />
+  <rect x=0 y=100 width=100% height=50 fill="teal" />
+  <rect x=0 y=200 width=100% height=50 fill="teal" />
+  <rect x=0 y=300 width=100% height=50 fill="teal" />
+
+  <rect x=10 y=10 width=80 height=80 fill="crimson"
+        filter="drop-shadow(2px 2px 2px black)"/>
+  <rect x=110 y=10 width=80 height=80 fill="crimson"
+        filter="drop-shadow(9px 12px 5px rgba(128, 0, 128, 0.7))"/>
+
+  <rect x=10 y=110 width=80 height=80 fill="crimson"
+        filter="drop-shadow(9px 12px 3px purple)"/>
+  <rect x=110 y=110 width=80 height=80 fill="crimson"
+        filter="drop-shadow(9px 12px 3px LinkText)"/>
+  <rect x=210 y=110 width=80 height=80 fill="crimson"
+        filter="drop-shadow(9px 12px 3px rgba(20, 50, 130, 1))"/>
+  <rect x=310 y=110 width=80 height=80 fill="crimson"
+        filter="drop-shadow(9px 12px 3px rgba(20, 50, 130, 0.7))"/>
+  <rect x=410 y=110 width=80 height=80 fill="crimson"
+        filter="drop-shadow(9px 12px 3px rgba(20, 50, 130, 0.49))"/>
+
+  <rect x=10 y=210 width=80 height=80 fill="crimson"
+        filter="drop-shadow(9px 12px 0px purple)"/>
+  <rect x=110 y=210 width=80 height=80 fill="crimson"
+        filter="drop-shadow(9px 12px 5px purple)"/>
+  <rect x=210 y=210 width=80 height=80 fill="crimson"
+        filter="drop-shadow(9px 12px 0px purple)"/>
+  <filter id="separable-filter"
+          x="-100%" y="-100%" width="300%" height="300%">
+    <feDropShadow dx=9 dy=12 stdDeviation="3 5" flood-color="purple"/>
+  </filter>
+  <rect x=310 y=210 width=80 height=80 fill="crimson"
+        filter="url(#separable-filter)"/>
+  <rect x=410 y=210 width=80 height=80 fill="crimson"
+        filter="drop-shadow(9px 12px 0px purple)"/>
+
+  <rect x=10 y=310 width=80 height=80 fill="crimson"
+        filter="drop-shadow(-5px 0px 0px purple)"/>
+  <filter id="separable-filter-degenerate"
+          x="-100%" y="-100%" width="300%" height="300%">
+    <feDropShadow dx=0 dy=5 stdDeviation="0 3"
+        flood-color="rgba(128, 0, 128, 0.8)"/>
+  </filter>
+  <rect x=110 y=310 width=80 height=80 fill="crimson"
+        filter="url(#separable-filter-degenerate)"/>
+  <rect x=210 y=310 width=80 height=80 fill="crimson"
+        filter="drop-shadow(1px 10px 0px rgba(128, 0, 128, 0.4))"/>
+</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.dropShadow.exceptions.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.dropShadow.exceptions.html
new file mode 100644
index 0000000000..df5e0c7dc3
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.dropShadow.exceptions.html
@@ -0,0 +1,269 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.dropShadow.exceptions</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/html/canvas/resources/canvas-tests.js"></script>
+<link rel="stylesheet" href="/html/canvas/resources/canvas-tests.css">
+<body class="show_output">
+
+<h1>2d.filter.layers.dropShadow.exceptions</h1>
+<p class="desc">Test exceptions on CanvasFilter() dropShadow object</p>
+
+
+<p class="output">Actual output:</p>
+<canvas id="c" class="output" width="100" height="50"><p class="fallback">FAIL (fallback content)</p></canvas>
+
+<ul id="d"></ul>
+<script>
+var t = async_test("Test exceptions on CanvasFilter() dropShadow object");
+_addTest(function(canvas, ctx) {
+
+  // Should not throw an error.
+  // dx
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: 10}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: -1}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: 0.5}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: null}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: true}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: false}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: []}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: [20]}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: '30'}}); ctx.endLayer();
+  // dy
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: 10}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: -1}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: 0.5}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: null}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: true}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: false}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: []}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: [20]}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: '30'}}); ctx.endLayer();
+  // floodOpacity
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: 10}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: -1}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: 0.5}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: null}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: true}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: false}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: []}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: [20]}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: '30'}}); ctx.endLayer();
+  // dx
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: 10}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: -1}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: 0.5}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: null}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: true}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: false}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: []}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: [20]}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: '30'}}); ctx.endLayer();
+  // dy
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: 10}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: -1}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: 0.5}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: null}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: true}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: false}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: []}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: [20]}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: '30'}}); ctx.endLayer();
+  // floodOpacity
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: 10}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: -1}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: 0.5}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: null}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: true}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: false}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: []}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: [20]}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: '30'}}); ctx.endLayer();
+  // stdDeviation
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: 10}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: -1}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: 0.5}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: null}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: true}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: false}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: []}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [20]}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: '30'}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [10, -1]}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [0.5, null]}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [true, false]}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [[], [20]]}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: ['30', ['40']]}}); ctx.endLayer();
+  // floodColor
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodColor: 'red'}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodColor: 'canvas'}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodColor: 'rgba(4, -3, 0.5, 1)'}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodColor: '#aabbccdd'}}); ctx.endLayer();
+  ctx.beginLayer({filter:
+    {name: 'dropShadow', floodColor: '#abcd'}}); ctx.endLayer();
+
+  // Should throw a TypeError.
+  // dx
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: NaN}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: Infinity}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: -Infinity}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: undefined}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: 'test'}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: {}}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dx: [1, 2]}}); ctx.endLayer(); });
+  // dy
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: NaN}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: Infinity}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: -Infinity}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: undefined}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: 'test'}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: {}}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', dy: [1, 2]}}); ctx.endLayer(); });
+  // floodOpacity
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: NaN}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: Infinity}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: -Infinity}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: undefined}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: 'test'}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: {}}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodOpacity: [1, 2]}}); ctx.endLayer(); });
+  // stdDeviation
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: NaN}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: Infinity}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: -Infinity}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: undefined}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: 'test'}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: {}}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [1, 2, 3]}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [1, NaN]}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [1, Infinity]}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [1, -Infinity]}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [1, undefined]}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [1, 'test']}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [1, {}]}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', stdDeviation: [1, [2, 3]]}}); ctx.endLayer(); });
+  // floodColor
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodColor: 'test'}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodColor: 'rgba(NaN, 3, 2, 1)'}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodColor: 10}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodColor: undefined}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodColor: null}}); ctx.endLayer(); });
+  assert_throws_js(TypeError, function() { ctx.beginLayer({filter:
+    {name: 'dropShadow', floodColor: NaN}}); ctx.endLayer(); });
+
+});
+</script>
+
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.dropShadow.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.dropShadow.html
new file mode 100644
index 0000000000..ceb20bb9eb
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.dropShadow.html
@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.layers.dropShadow-expected.html">
+<title>Canvas test: 2d.filter.layers.dropShadow</title>
+<h1>2d.filter.layers.dropShadow</h1>
+<p class="desc">Test CanvasFilter() dropShadow object.</p>
+<canvas id="canvas" width="520" height="420">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  ctx.fillStyle = 'teal';
+  ctx.fillRect(0, 0, 520, 50);
+  ctx.fillRect(0, 100, 520, 50);
+  ctx.fillRect(0, 200, 520, 50);
+  ctx.fillRect(0, 300, 520, 50);
+
+  ctx.fillStyle = 'crimson';
+
+  // Parameter defaults.
+  ctx.beginLayer({filter: {name: 'dropShadow'}});
+  ctx.fillRect(10, 10, 80, 80);
+  ctx.endLayer();
+  // All parameters specified.
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 5,
+     floodColor: 'purple', floodOpacity: 0.7}});
+  ctx.fillRect(110, 10, 80, 80);
+  ctx.endLayer();
+  // Named color.
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
+     floodColor: 'purple'}});
+  ctx.fillRect(10, 110, 80, 80);
+  ctx.endLayer();
+  // System color.
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
+     floodColor: 'LinkText'}});
+  ctx.fillRect(110, 110, 80, 80);
+  ctx.endLayer();
+  // Numerical color.
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
+     floodColor: 'rgba(20, 50, 130, 1)'}});
+  ctx.fillRect(210, 110, 80, 80);
+  ctx.endLayer();
+  // Transparent floodColor.
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
+     floodColor: 'rgba(20, 50, 130, 0.7)'}});
+  ctx.fillRect(310, 110, 80, 80);
+  ctx.endLayer();
+  // Transparent floodColor and floodOpacity.
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 3,
+     floodColor: 'rgba(20, 50, 130, 0.7)', floodOpacity: 0.7}});
+  ctx.fillRect(410, 110, 80, 80);
+  ctx.endLayer();
+  // No blur.
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 0,
+     floodColor: 'purple'}});
+  ctx.fillRect(10, 210, 80, 80);
+  ctx.endLayer();
+  // Single float blur.
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: 5,
+     floodColor: 'purple'}});
+  ctx.fillRect(110, 210, 80, 80);
+  ctx.endLayer();
+  // Single negative float blur.
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: -5,
+     floodColor: 'purple'}});
+  ctx.fillRect(210, 210, 80, 80);
+  ctx.endLayer();
+  // Two floats (X&Y) blur.
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: [3, 5],
+     floodColor: 'purple'}});
+  ctx.fillRect(310, 210, 80, 80);
+  ctx.endLayer();
+  // Two negative floats (X&Y) blur.
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: 9, dy: 12, stdDeviation: [-3, -5],
+     floodColor: 'purple'}});
+  ctx.fillRect(410, 210, 80, 80);
+  ctx.endLayer();
+  // Degenerate parameter values.
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: [-5], dy: [], stdDeviation: null,
+     floodColor: 'purple', floodOpacity: [2]}});
+  ctx.fillRect(10, 310, 80, 80);
+  ctx.endLayer();
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: null, dy: '5', stdDeviation: [[-5], ['3']],
+     floodColor: 'purple', floodOpacity: '0.8'}});
+  ctx.fillRect(110, 310, 80, 80);
+  ctx.endLayer();
+  ctx.beginLayer({filter: {name: 'dropShadow', dx: true, dy: ['10'], stdDeviation: false,
+     floodColor: 'purple', floodOpacity: ['0.4']}});
+  ctx.fillRect(210, 310, 80, 80);
+  ctx.endLayer();
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.isotropic-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.isotropic-expected.html
new file mode 100644
index 0000000000..4f93754862
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.isotropic-expected.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.gaussianBlur.isotropic</title>
+<h1>2d.filter.layers.gaussianBlur.isotropic</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="100" height="100"
+     color-interpolation-filters="sRGB">
+  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
+    <feGaussianBlur stdDeviation="4 4" />
+  </filter>
+  <rect x="25" y="25" width="50" height="50"
+        fill="teal" filter="url(#blur)" />
+</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.isotropic.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.isotropic.html
new file mode 100644
index 0000000000..a2cc098896
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.isotropic.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.layers.gaussianBlur.isotropic-expected.html">
+<title>Canvas test: 2d.filter.layers.gaussianBlur.isotropic</title>
+<h1>2d.filter.layers.gaussianBlur.isotropic</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  ctx.fillStyle = 'teal';
+  ctx.beginLayer({filter: {
+      name: 'gaussianBlur',
+      stdDeviation: [4, 4],
+  }});
+  ctx.fillRect(25, 25, 50, 50);
+  ctx.endLayer();
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-x-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-x-expected.html
new file mode 100644
index 0000000000..255270c192
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-x-expected.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.gaussianBlur.mostly-x</title>
+<h1>2d.filter.layers.gaussianBlur.mostly-x</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="100" height="100"
+     color-interpolation-filters="sRGB">
+  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
+    <feGaussianBlur stdDeviation="4 1" />
+  </filter>
+  <rect x="25" y="25" width="50" height="50"
+        fill="teal" filter="url(#blur)" />
+</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-x.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-x.html
new file mode 100644
index 0000000000..0090e0e71e
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-x.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.layers.gaussianBlur.mostly-x-expected.html">
+<title>Canvas test: 2d.filter.layers.gaussianBlur.mostly-x</title>
+<h1>2d.filter.layers.gaussianBlur.mostly-x</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  ctx.fillStyle = 'teal';
+  ctx.beginLayer({filter: {
+      name: 'gaussianBlur',
+      stdDeviation: [4, 1],
+  }});
+  ctx.fillRect(25, 25, 50, 50);
+  ctx.endLayer();
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-y-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-y-expected.html
new file mode 100644
index 0000000000..76a46b1533
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-y-expected.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.gaussianBlur.mostly-y</title>
+<h1>2d.filter.layers.gaussianBlur.mostly-y</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="100" height="100"
+     color-interpolation-filters="sRGB">
+  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
+    <feGaussianBlur stdDeviation="1 4" />
+  </filter>
+  <rect x="25" y="25" width="50" height="50"
+        fill="teal" filter="url(#blur)" />
+</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-y.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-y.html
new file mode 100644
index 0000000000..5c481cbe25
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.mostly-y.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.layers.gaussianBlur.mostly-y-expected.html">
+<title>Canvas test: 2d.filter.layers.gaussianBlur.mostly-y</title>
+<h1>2d.filter.layers.gaussianBlur.mostly-y</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  ctx.fillStyle = 'teal';
+  ctx.beginLayer({filter: {
+      name: 'gaussianBlur',
+      stdDeviation: [1, 4],
+  }});
+  ctx.fillRect(25, 25, 50, 50);
+  ctx.endLayer();
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.x-only-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.x-only-expected.html
new file mode 100644
index 0000000000..26741f9847
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.x-only-expected.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.gaussianBlur.x-only</title>
+<h1>2d.filter.layers.gaussianBlur.x-only</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="100" height="100"
+     color-interpolation-filters="sRGB">
+  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
+    <feGaussianBlur stdDeviation="4 0" />
+  </filter>
+  <rect x="25" y="25" width="50" height="50"
+        fill="teal" filter="url(#blur)" />
+</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.x-only.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.x-only.html
new file mode 100644
index 0000000000..f7940eb921
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.x-only.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.layers.gaussianBlur.x-only-expected.html">
+<title>Canvas test: 2d.filter.layers.gaussianBlur.x-only</title>
+<h1>2d.filter.layers.gaussianBlur.x-only</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  ctx.fillStyle = 'teal';
+  ctx.beginLayer({filter: {
+      name: 'gaussianBlur',
+      stdDeviation: [4, 0],
+  }});
+  ctx.fillRect(25, 25, 50, 50);
+  ctx.endLayer();
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.y-only-expected.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.y-only-expected.html
new file mode 100644
index 0000000000..d00eec6b57
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.y-only-expected.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.gaussianBlur.y-only</title>
+<h1>2d.filter.layers.gaussianBlur.y-only</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="100" height="100"
+     color-interpolation-filters="sRGB">
+  <filter id="blur" x="-50%" y="-50%" width="200%" height="200%">
+    <feGaussianBlur stdDeviation="0 4" />
+  </filter>
+  <rect x="25" y="25" width="50" height="50"
+        fill="teal" filter="url(#blur)" />
+</svg>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.y-only.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.y-only.html
new file mode 100644
index 0000000000..59421a1ff3
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.gaussianBlur.y-only.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<link rel="match" href="2d.filter.layers.gaussianBlur.y-only-expected.html">
+<title>Canvas test: 2d.filter.layers.gaussianBlur.y-only</title>
+<h1>2d.filter.layers.gaussianBlur.y-only</h1>
+<p class="desc">Test CanvasFilter() with gaussianBlur.</p>
+<canvas id="canvas" width="100" height="100">
+  <p class="fallback">FAIL (fallback content)</p>
+</canvas>
+<script>
+  const canvas = document.getElementById("canvas");
+  const ctx = canvas.getContext('2d');
+
+  ctx.fillStyle = 'teal';
+  ctx.beginLayer({filter: {
+      name: 'gaussianBlur',
+      stdDeviation: [0, 4],
+  }});
+  ctx.fillRect(25, 25, 50, 50);
+  ctx.endLayer();
+</script>
diff --git a/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.turbulence.inputTypes.html b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.turbulence.inputTypes.html
new file mode 100644
index 0000000000..26dceaae16
--- /dev/null
+++ b/testing/web-platform/tests/html/canvas/element/filters/2d.filter.layers.turbulence.inputTypes.html
@@ -0,0 +1,130 @@
+<!DOCTYPE html>
+<!-- DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py. -->
+<title>Canvas test: 2d.filter.layers.turbulence.inputTypes</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/html/canvas/resources/canvas-tests.js"></script>
+<link rel="stylesheet" href="/html/canvas/resources/canvas-tests.css">
+<body class="show_output">
+
+<h1>2d.filter.layers.turbulence.inputTypes</h1>
+<p class="desc">Test exceptions on CanvasFilter() turbulence object</p>
+
+
+<p class="output">Actual output:</p>
+<canvas id="c" class="output" width="100" height="50"><p class="fallback">FAIL (fallback content)</p></canvas>
+
+<ul id="d"></ul>
+<script>
+var t = async_test("Test exceptions on CanvasFilter() turbulence object");
+_addTest(function(canvas, ctx) {
+
+  const errorTestCases = [
+    {baseFrequency: {}},
+    {baseFrequency: -1},
+    {baseFrequency: [0, -1]},
+    {baseFrequency: NaN},
+    {baseFrequency: Infinity},
+    {baseFrequency: undefined},
+    {baseFrequency: -Infinity},
+    {baseFrequency: 'test'},
+
+    {numOctaves: {}},
+    {numOctaves: -1},
+    {numOctaves: NaN},
+    {numOctaves: Infinity},
+    {numOctaves: undefined},
+    {numOctaves: -Infinity},
+    {numOctaves: [1, 1]},
+    {numOctaves: 'test'},
+
+    {seed: {}},
+    {seed: NaN},
+    {seed: Infinity},
+    {seed: undefined},
+    {seed: -Infinity},
+    {seed: [1, 1]},
+    {seed: 'test'},
+
+    {stitchTiles: {}},
+    {stitchTiles: NaN},
+    {stitchTiles: Infinity},
+    {stitchTiles: undefined},
+    {stitchTiles: -Infinity},
+    {stitchTiles: [1, 1]},
+    {stitchTiles: 'test'},
+    {stitchTiles: null},
+    {stitchTiles: []},
+    {stitchTiles: [10]},
+    {stitchTiles: 30},
+    {stitchTiles: false},
+    {stitchTiles: true},
+    {stitchTiles: '10'},
+    {stitchTiles: -1},
+
+    {type: {}},
+    {type: NaN},
+    {type: Infinity},
+    {type: undefined},
+    {type: -Infinity},
+    {type: [1, 1]},
+    {type: 'test'},
+    {type: null},
+    {type: []},
+    {type: [10]},
+    {type: 30},
+    {type: false},
+    {type: true},
+    {type: '10'},
+    {type: -1},
+  ]
+
+  // null and [] = 0 when parsed as number
+  const workingTestCases = [
+    {baseFrequency: null},
+    {baseFrequency: []},
+    {baseFrequency: [10]},
+    {baseFrequency: [10, 3]},
+    {baseFrequency: 30},
+    {baseFrequency: false},
+    {baseFrequency: true},
+    {baseFrequency: '10'},
+
+    {numOctaves: null},
+    {numOctaves: []},
+    {numOctaves: [10]},
+    {numOctaves: 30},
+    {numOctaves: false},
+    {numOctaves: true},
+    {numOctaves: '10'},
+
+    {seed: null},
+    {seed: []},
+    {seed: [10]},
+    {seed: 30},
+    {seed: false},
+    {seed: true},
+    {seed: '10'},
+    {seed: -1},
+
+    {stitchTiles: 'stitch'},
+    {stitchTiles: 'noStitch'},
+
+    {type: 'fractalNoise'},
+    {type: 'turbulence'},
+  ]
+
+  for (testCase of errorTestCases) {
+    const filterOptions = {...{name: 'turbulence'}, ...testCase};
+    assert_throws_js(TypeError, function() { ctx.beginLayer({filter: filterOptions}); });
+  }
+
+  for (testCase of workingTestCases) {
+    const filterOptions = {...{name: 'turbulence'}, ...testCase};
+    ctx.beginLayer({filter: filterOptions});
+    ctx.endLayer();
+  }
+
+});
+</script>
+
-- 
cgit v1.2.3