Enable interpolation of CSS property font-variation-settings

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

 /*
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 258 matching lines @@
   }
 
   function assertInterpolation(options, expectations) {
     interpolationTests.push({options, expectations});
   }
 
   function assertComposition(options, expectations) {
     compositionTests.push({options, expectations});
   }
 
+  function stringify(text) {
+    if (!text.includes("'")) {
+      return `'${text}'`;
+    }
+    return `"${text.replace('"', '\\"')}"`;
+  }
+
   function keyframeText(keyframe) {
     return isNeutralKeyframe(keyframe) ? 'neutral' : `[${keyframe}]`;
   }
 
   function keyframeCode(keyframe) {
-    return isNeutralKeyframe(keyframe) ? 'neutralKeyframe' : `'${keyframe}'`;
+    return isNeutralKeyframe(keyframe) ? 'neutralKeyframe' : `${stringify(keyframe)}`;
   }
 
   function createInterpolationTestTargets(interpolationMethod, interpolationMethodContainer, interpolationTest, rebaselineContainer) {
     var property = interpolationTest.options.property;
     var from = interpolationTest.options.from;
     var to = interpolationTest.options.to;
     if ((interpolationTest.options.method && interpolationTest.options.method != interpolationMethod.name)
       || !interpolationMethod.supportsProperty(property)
       || !interpolationMethod.supportsValue(from)
       || !interpolationMethod.supportsValue(to)) {
@@ skipping 28 matching lines @@
         interpolationMethod.interpolate(property, from, to, expectation.at, target);
       };
       target.measure = function() {
         var actualValue = getComputedStyle(target).getPropertyValue(property);
         test(function() {
           assert_equals(
             normalizeValue(actualValue),
             normalizeValue(getComputedStyle(expectedTargetContainer.target).getPropertyValue(property)));
         }, `${testText} at (${expectation.at}) is [${sanitizeUrls(actualValue)}]`);
         if (rebaselineExpectation) {
-          rebaselineExpectation.textContent += `  {at: ${expectation.at}, is: '${actualValue}'},\n`;
+          rebaselineExpectation.textContent += `  {at: ${expectation.at}, is: ${stringify(actualValue)}},\n`;
         }
       };
       return target;
     });
   }
 
   function createCompositionTestTargets(compositionContainer, compositionTest, rebaselineContainer) {
     var options = compositionTest.options;
     var property = options.property;
     var underlying = options.underlying;
     var from = options.addFrom || options.replaceFrom;
     var to = options.addTo || options.replaceTo;
     var fromComposite = 'addFrom' in options ? 'add' : 'replace';
     var toComposite = 'addTo' in options ? 'add' : 'replace';
     if ('addFrom' in options === 'replaceFrom' in options
       || 'addTo' in options === 'replaceTo' in options) {
       test(function() {
         assert_true('addFrom' in options !== 'replaceFrom' in options, 'addFrom xor replaceFrom must be specified');
         assert_true('addTo' in options !== 'replaceTo' in options, 'addTo xor replaceTo must be specified');
       }, `Composition tests must use addFrom xor replaceFrom, and addTo xor replaceTo`);
     }
     validateTestInputs(property, from, to, underlying);
 
     if (webAnimationsInterpolation.rebaseline) {
       var rebaseline = createElement(rebaselineContainer, 'pre');
       rebaseline.appendChild(document.createTextNode(`\
 assertComposition({
   property: '${property}',
-  underlying: '${underlying}',
-  ${fromComposite}From: '${from}',
-  ${toComposite}To: '${to}',
+  underlying: '${stringify(underlying)}',
+  ${fromComposite}From: '${stringify(from)}',
+  ${toComposite}To: '${stringify(to)}',
 }, [\n`));
       var rebaselineExpectation;
       rebaseline.appendChild(rebaselineExpectation = document.createTextNode(''));
       rebaseline.appendChild(document.createTextNode(']);\n\n'));
     }
     var testText = `Compositing: property <${property}> underlying [${underlying}] from ${fromComposite} [${from}] to ${toComposite} [${to}]`;
     var testContainer = createElement(compositionContainer, 'div', testText);
     createElement(testContainer, 'br');
     return compositionTest.expectations.map(function(expectation) {
       var actualTargetContainer = createTargetContainer(testContainer, 'actual');
       var expectedTargetContainer = createTargetContainer(testContainer, 'expected');
       expectedTargetContainer.target.style.setProperty(property, expectation.is);
       var target = actualTargetContainer.target;
       target.style.setProperty(property, underlying);
       target.interpolate = function() {
         webAnimationsInterpolation.interpolateComposite(property, from, fromComposite, to, toComposite, expectation.at, target);
       };
       target.measure = function() {
         var actualValue = getComputedStyle(target).getPropertyValue(property);
         test(function() {
           assert_equals(
             normalizeValue(actualValue),
             normalizeValue(getComputedStyle(expectedTargetContainer.target).getPropertyValue(property)));
         }, `${testText} at (${expectation.at}) is [${sanitizeUrls(actualValue)}]`);
         if (rebaselineExpectation) {
-          rebaselineExpectation.textContent += `  {at: ${expectation.at}, is: '${actualValue}'},\n`;
+          rebaselineExpectation.textContent += `  {at: ${expectation.at}, is: ${stringify(actualValue)}},\n`;
         }
       };
       return target;
     });
   }
 
   function validateTestInputs(property, from, to, underlying) {
     if (from && from !== neutralKeyframe && !CSS.supports(property, from)) {
         test(function() {
           assert_unreached('from value not supported');
@@ skipping 67 matching lines @@
       asyncHandle.done()
     });
   });
 
   window.assertInterpolation = assertInterpolation;
   window.assertNoInterpolation = assertNoInterpolation;
   window.assertComposition = assertComposition;
   window.afterTest = afterTest;
   window.neutralKeyframe = neutralKeyframe;
 })();