[Typed OM] Output correct types from CSSKeywordValue for css-wide keywords

third_party/WebKit/LayoutTests/typedcssom/inlinestyle/properties/property-suite.js

 /**
  * @fileoverview A standard set of tests for using a single property in an
  *     inline StylePropertyMap
  *     (https://www.w3.org/TR/css-typed-om-1/#the-stylepropertymap).
  *
  * Create a config object containing {
  *   validKeywords: array of strings,
  *   validObjects: array of CSSStyleValue instances that are valid for the
  *       property,
  *   validStringMappings: object containing a mapping of string to
@@ skipping 10 matching lines @@
  *
  * Note that CSS-wide keywords, and non-CSSStyleValue invalid types do not need
  * to be specified.
  *
  * If necessary, you can continue to define non-standard tests in your html
  * file as usual.
  */
 
 function runInlineStylePropertyMapTests(config) {
   let element = document.createElement('div');
+  document.documentElement.appendChild(element);
   let validKeywords = config.validKeywords.concat([
     // CSS-wide keywords
     'initial',
     'inherit',
     'unset'
   ]);
   let validObjects = config.validObjects;
   let validStringMappings = config.validStringMappings ?
       config.validStringMappings : {};
   let invalidObjects = config.invalidObjects.concat([
@@ skipping 30 matching lines @@
   }
 }
 
 function runSetterTests(
     propertyName, validKeywords, validObjects, invalidObjects, element) {
   for (let keyword of validKeywords) {
     test(function() {
       element.style = '';
       element.styleMap.set(propertyName, new CSSKeywordValue(keyword));
       assert_equals(element.style[propertyName], keyword);
+      // Force a style recalc to check for crashes in style recalculation.
+      getComputedStyle(element)[propertyName];
+      assert_equals(element.style[propertyName], keyword);
     }, 'Setting ' + propertyName + ' to ' + keyword);
   }
   for (let validObject of validObjects) {
     test(function() {
       element.style = '';
-
       element.styleMap.set(propertyName, validObject);
       assert_equals(element.style[propertyName], validObject.cssText);
+      // Force a style recalc to check for crashes in style recalculation.
+      getComputedStyle(element)[propertyName];
+      assert_equals(element.style[propertyName], validObject.cssText);
     }, 'Setting ' + propertyName + ' to ' + validObject.constructor.name +
         ' with value ' +  validObject.cssText);
   }
 
   // Negative tests
   for (let invalidObject of invalidObjects) {
     let name = invalidObject instanceof CSSStyleValue ?
         invalidObject.constructor.name : invalidObject;
     test(function() {
       assert_throws(new TypeError(), function() {
@@ skipping 37 matching lines @@
       assert_equals(result.cssText, validStringMappings[cssText].cssText);
     }, 'Getting ' + propertyName + ' when it is set to "' +
         cssText + '" via a string');
   }
 }
 
 function runSequenceSetterTests(
     propertyName, validObject, invalidObject, element) {
   test(function() {
     element.style = '';
-
     element.styleMap.set(propertyName, [validObject, validObject]);
     assert_equals(
         element.style[propertyName], validObject.cssText + ', ' +
         validObject.cssText);
+    // Force a style recalc to check for crashes in style recalculation.
+    getComputedStyle(element)[propertyName];
+    assert_equals(
+        element.style[propertyName], validObject.cssText + ', ' +
+        validObject.cssText);
   }, 'Set ' + propertyName + ' to a sequence');
 
   test(function() {
     let sequence = [validObject, invalidObject];
     assert_throws(new TypeError(), function() {
       element.styleMap.set(propertyName, sequence);
     });
   }, 'Set ' + propertyName + ' to a sequence containing an invalid type');
 }
 
 function runAppendTests(
     propertyName, validObject, invalidObject, element) {
   test(function() {
     element.style = '';
 
     element.styleMap.append(propertyName, validObject);
     assert_equals(element.style[propertyName], validObject.cssText);
 
     element.styleMap.append(propertyName, validObject);
     assert_equals(
         element.style[propertyName], validObject.cssText + ', ' +
         validObject.cssText);
+    // Force a style recalc to check for crashes in style recalculation.
+    getComputedStyle(element)[propertyName];
+    assert_equals(
+        element.style[propertyName], validObject.cssText + ', ' +
+        validObject.cssText);
   }, 'Appending a ' + validObject.constructor.name + ' to ' + propertyName);
 
   test(function() {
     element.style = '';
 
     element.styleMap.append(propertyName, [validObject, validObject]);
     assert_equals(
         element.style[propertyName], validObject.cssText + ', ' +
         validObject.cssText);
+    // Force a style recalc to check for crashes in style recalculation.
+    getComputedStyle(element)[propertyName];
+    assert_equals(
+        element.style[propertyName], validObject.cssText + ', ' +
+        validObject.cssText);
   }, 'Append a sequence to ' + propertyName);
 
   // Negative tests
   test(function() {
     assert_throws(new TypeError(), function() {
       element.styleMap.append(propertyName, invalidObject);
     });
   }, 'Appending an invalid value to ' + propertyName);
 
   test(function() {
@@ skipping 38 matching lines @@
 
 function runDeletionTests(propertyName, validObject, element) {
   test(function() {
     element.style[propertyName] = validObject.cssText;
 
     assert_not_equals(element.styleMap.get(propertyName), null);
 
     element.styleMap.delete(propertyName);
     assert_equals(element.style[propertyName], '');
     assert_equals(element.styleMap.get(propertyName), null);
+    // Force a style recalc to check for crashes in style recalculation.
+    getComputedStyle(element)[propertyName];
+    assert_equals(element.style[propertyName], '');
+    assert_equals(element.styleMap.get(propertyName), null);
   }, 'Delete ' + propertyName + ' removes the value from the styleMap');
 }
 
 function runGetPropertiesTests(propertyName, validObject, element) {
   test(function() {
     element.style = '';
     assert_array_equals(element.styleMap.getProperties(), []);
-
     element.styleMap.set(propertyName, validObject);
-
+    assert_array_equals(element.styleMap.getProperties(), [propertyName]);
+    // Force a style recalc to check for crashes in style recalculation.
+    getComputedStyle(element)[propertyName];
     assert_array_equals(element.styleMap.getProperties(), [propertyName]);
   }, propertyName + ' shows up in getProperties');
 }
 
 function runMultipleValuesNotSupportedTests(
     propertyName, validObject, element) {
   test(function() {
     element.style = '';
     assert_throws(new TypeError(), function() {
       element.styleMap.set(propertyName, [validObject, validObject]);
     });
   }, 'Setting ' + propertyName + ' to a sequence throws');
 
   test(function() {
     element.style = '';
     assert_throws(new TypeError(), function() {
       element.styleMap.append(propertyName, validObject);
     });
   }, 'Appending to ' + propertyName + ' throws');
 }