Extend SVG attribute interpolation test helper to test composition modes

third_party/WebKit/LayoutTests/animations/svg-attribute-interpolation/resources/interpolation-test.js

 /* Copyright 2015 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * Exported function:
- *  - assertAttributeInterpolation({property, from, to}, [{at: fraction, is: value}])
+ *  - assertAttributeInterpolation({property, from, to, [fromComposite], [toComposite], [underlying]}, [{at: fraction, is: value}])
  *        Constructs a test case for each fraction that asserts the expected value
- *        equals the value produced by interpolation between from and to using
+ *        equals the value produced by interpolation between from and to composited
+ *        onto underlying by fromComposite and toComposite respectively using
  *        SMIL and Web Animations.
+ *        SMIL will only be tested with equal fromComposite and toComposite values.
 */
 'use strict';
 (() => {
   var interpolationTests = [];
 
   function createElement(tagName, container) {
     var element = document.createElement(tagName);
     if (container) {
       container.appendChild(element);
     }
@@ skipping 156 matching lines @@
     if (attributeName === 'in')
       attributeName = 'in1';
 
     // The attribute 'orient' is exposed in IDL as 'orientType' and 'orientAngle'
     if (attributeName === 'orient') {
       if (element['orientType'] && element['orientType'].animVal === SVGMarkerElement.SVG_MARKER_ORIENT_AUTO)
         return 'auto';
       attributeName = 'orientAngle';
     }
 
-    var result;
+    var result = null;
     if (attributeName === 'd')
       result = element.getAttribute('d');
     else if (attributeName === 'points')
       result = element['animatedPoints'];
     else
       result = element[attributeName].animVal;
 
-    if (!result) {
+    if (result === null) {
       if (attributeName === 'pathLength')
         return '0';
       if (attributeName === 'preserveAlpha')
         return 'false';
 
       console.error('Unknown attribute, cannot get ' + attributeName);
       return null;
     }
 
     if (result instanceof SVGAngle || result instanceof SVGLength)
@@ skipping 33 matching lines @@
       var setElement = document.createElementNS(svgNamespace, 'set');
       setElement.setAttribute('attributeName', namespacedAttributeName(attributeName));
       setElement.setAttribute('attributeType', 'XML');
       setElement.setAttribute('to', expectation);
       element.appendChild(setElement);
     } else {
       element.setAttribute(attributeName, expectation);
     }
   }
 
-  function createAnimateElement(attributeName, from, to)
+  function createAnimateElement(attributeName, from, to, composite)
   {
     var animateElement;
     if (attributeName.toLowerCase().includes('transform')) {
       from = from.split(')');
       to = to.split(')');
       // Discard empty string at end.
       from.pop();
       to.pop();
 
       // SMIL requires separate animateTransform elements for each transform in the list.
@@ skipping 15 matching lines @@
       animateElement = document.createElementNS(svgNamespace, 'animate');
       animateElement.setAttribute('from', from);
       animateElement.setAttribute('to', to);
     }
 
     animateElement.setAttribute('attributeName', namespacedAttributeName(attributeName));
     animateElement.setAttribute('attributeType', 'XML');
     animateElement.setAttribute('begin', '0');
     animateElement.setAttribute('dur', '1');
     animateElement.setAttribute('fill', 'freeze');
+    animateElement.setAttribute('additive', composite === 'add' ? 'sum' : composite);
     return animateElement;
   }
 
   function createTestTarget(method, description, container, params, expectation) {
     var target = createTarget(container);
+    if (params.underlying) {
+      target.setAttribute(params.property, params.underlying);
+    }
+
     var expected = createTarget(container);
     setAttributeValue(expected, params.property, expectation.is);
 
     target.interpolate = function() {
       switch (method) {
       case 'SMIL':
-        var animateElement = createAnimateElement(params.property, params.from, params.to);
+        console.assert(params.fromComposite === params.toComposite);
+        var animateElement = createAnimateElement(params.property, params.from, params.to, params.fromComposite);
         if (animateElement) {
           target.appendChild(animateElement);
           target.container.pauseAnimations();
           target.container.setCurrentTime(expectation.at);
         } else {
           console.warn(`Unable to test SMIL from ${params.from} to ${params.to}`);
           target.container.remove();
           target.measure = function() {};
         }
         break;
       case 'Web Animations':
         // Replace 'transform' with 'svgTransform', etc. This avoids collisions with CSS properties or the Web Animations API (offset).
         var prefixedProperty = 'svg' + params.property[0].toUpperCase() + params.property.slice(1);
         target.animate([
-          {[prefixedProperty]: params.from},
-          {[prefixedProperty]: params.to},
+          {
+            [prefixedProperty]: params.from,
+            composite: params.fromComposite,
+          },
+          {
+            [prefixedProperty]: params.to,
+            composite: params.toComposite,
+          },
         ], {
           fill: 'forwards',
           duration: 1,
           easing: createEasing(expectation.at),
           delay: -0.5,
           iterations: 0.5,
         });
         break;
       default:
         console.error('Unknown test method: ' + method);
       }
     };
 
     target.measure = function() {
       test(function() {
         assert_equals(
           normalizeValue(getAttributeValue(target, params.property)),
           normalizeValue(getAttributeValue(expected, params.property)));
       }, `${method}: ${description} at (${expectation.at}) is [${expectation.is}]`);
     };
 
     return target;
   }
 
   function createTestTargets(interpolationTests, container) {
     var targets = [];
     for (var interpolationTest of interpolationTests) {
       var params = interpolationTest.params;
-      var description = `Interpolate attribute <${params.property}> from [${params.from}] to [${params.to}]`;
-      var expectations = interpolationTest.expectations;
+      params.fromComposite = params.fromComposite || 'replace';
+      params.toComposite = params.toComposite || 'replace';
+      var description = `Interpolate attribute <${params.property}> from ${params.fromComposite} [${params.from}] to ${params.toComposite} [${params.to}]`;
 
       for (var method of ['SMIL', 'Web Animations']) {
+        if (method === 'SMIL' && params.fromComposite !== params.toComposite) {
+          continue;
+        }
         createElement('pre', container).textContent = `${method}: ${description}`;
         var smilContainer = createElement('div', container);
-        for (var expectation of expectations) {
+        for (var expectation of interpolationTest.expectations) {
           if (method === 'SMIL' && (expectation.at < 0 || expectation.at > 1)) {
             continue;
           }
           targets.push(createTestTarget(method, description, smilContainer, params, expectation));
         }
       }
     }
     return targets;
   }
 
@@ skipping 34 matching lines @@
     return loadScript('../../resources/testharnessreport.js');
   }).then(() => {
     var asyncHandle = async_test('This test uses interpolation-test.js.')
     requestAnimationFrame(() => {
       runTests().then(() => asyncHandle.done());
     });
   });
 
   window.assertAttributeInterpolation = assertAttributeInterpolation;
 })();