gecko-dev/layout/style/test/test_value_storage.html

<!DOCTYPE HTML>
<html>
<!--
-->
<head>
  <title>Test for parsing, storage, and serialization of CSS values</title>
  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
  <script type="text/javascript" src="property_database.js"></script>
  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
  <style type="text/css" id="prereqsheet">
  #testnode {}
  </style>
</head>
<body>
<p id="display"></p>
<div id="content" style="display: none">

<div id="testnode"></div>

</div>
<pre id="test">
<script class="testbody" type="text/javascript">

/** Test for parsing, storage, and serialization of CSS values **/

/*
 * The idempotence tests here deserve a little bit of explanation.  What
 * we're testing here are the following operations:
 *   parse: string -> CSS rule
 *   serialize: CSS rule -> string (normalization 1)
 *     (this actually has two variants that go through partly different
 *     codepaths, which we exercise with getPropertyValue and cssText)
 *   compute: CSS rule -> computed style
 *   cserialize: computed style -> string (normalization 2)
 *
 * Both serialize and cserialize do some normalization, so we can't test
 * for pure round-tripping, and we also can't compare their output since
 * they could normalize differently.  (We might at some point in the
 * future want to guarantee that any output of cserialize is
 * untouched by going through parse+serialize, though.)
 *
 * So we test idempotence of parse + serialize by running the whole
 * operation twice.  Likewise for parse + compute + cserialize.
 *
 * Slightly more interestingly, we test that serialize + parse is the
 * identity transform by comparing the output of parse + compute +
 * cserialize to the output of parse + serialize + parse + compute +
 * cserialize.
 */

var gSystemFont = {
  "caption": true,
  "icon": true,
  "menu": true,
  "message-box": true,
  "small-caption": true,
  "status-bar": true,
  "-moz-window": true,
  "-moz-document": true,
  "-moz-desktop": true,
  "-moz-info": true,
  "-moz-dialog": true,
  "-moz-button": true,
  "-moz-pull-down-menu": true,
  "-moz-list": true,
  "-moz-field": true,
  "-moz-workspace": true,
};

var gBadCompute = {
  // output wrapped around to positive, in exponential notation
  "-moz-box-ordinal-group": [ "-1", "-1000" ],
};

function xfail_compute(property, value)
{
  if (property in gBadCompute &&
      gBadCompute[property].indexOf(value) != -1)
    return true;

  return false;
}

var gBadSerialize = {
  // Font-families which include quotes don't get those escaped when
  //serializing: see bug 660397
  "font-family": ["\\\"Times New Roman", "Times, \\\"Times New Roman"],
};

function xfail_serialize(property, value)
{
  if (property in gBadSerialize &&
      gBadSerialize[property].indexOf(value) != -1)
    return true;

  return false;
}

var gElement = document.getElementById("testnode");
var gDeclaration = gElement.style;
var gComputedStyle = window.getComputedStyle(gElement, "");

var gPrereqDeclaration =
  document.getElementById("prereqsheet").sheet.cssRules[0].style;

function test_property(property)
{
  var info = gCSSProperties[property];

  var test_computed = !("backend_only" in info);

  // can all properties be removed from the style?
  function test_remove_all_properties(property, value) {
    var i, p = [];
    for (i = 0; i < gDeclaration.length; i++) p.push(gDeclaration[i]);
    for (i = 0; i < p.length; i++) gDeclaration.removeProperty(p[i]);
    var errstr = "when setting property " + property + " to " + value;
    is(gDeclaration.length, 0, "unremovable properties " + errstr);
    is(gDeclaration.cssText, "", "non-empty serialization after removing all properties " + errstr);
  }

  function test_value(value) {
    gDeclaration.setProperty(property, value, "");

    var idx;

    var step1val = gDeclaration.getPropertyValue(property);
    var step1vals = [];
    var step1ser = gDeclaration.cssText;
    if ("subproperties" in info)
      for (idx in info.subproperties)
        step1vals.push(gDeclaration.getPropertyValue(info.subproperties[idx]));
    var step1comp;
    var step1comps = [];
    if (test_computed && info.type != CSS_TYPE_TRUE_SHORTHAND)
      step1comp = gComputedStyle.getPropertyValue(property);
    if (test_computed && "subproperties" in info)
      for (idx in info.subproperties)
        step1comps.push(gComputedStyle.getPropertyValue(info.subproperties[idx]));

    isnot(step1val, "", "setting '" + value + "' on '" + property + "'");
    if ("subproperties" in info)
      for (idx in info.subproperties) {
        var subprop = info.subproperties[idx];
        isnot(gDeclaration.getPropertyValue(subprop), "",
              "setting '" + value + "' on '" + property + "'");
      }

    // We don't care particularly about the whitespace or the placement of
    // semicolons, but for simplicity we'll test the current behavior.
    var expected_serialization = "";
    if (step1val != "") {
      if ("alias_for" in info) {
        expected_serialization = info.alias_for + ": " + step1val + ";";
      } else {
        expected_serialization = property + ": " + step1val + ";";
      }
    }
    is(step1ser, expected_serialization,
       "serialization should match property value");

    gDeclaration.removeProperty(property);
    gDeclaration.setProperty(property, step1val, "");

    var serialize_func = xfail_serialize(property, value) ? todo_is : is;

    serialize_func(gDeclaration.getPropertyValue(property), step1val,
       "parse+serialize should be idempotent for '" +
         property + ": " + value + "'");
    if (test_computed && info.type != CSS_TYPE_TRUE_SHORTHAND) {
      serialize_func(gComputedStyle.getPropertyValue(property), step1comp,
         "serialize+parse should be identity transform for '" +
         property + ": " + value + "'");
    }

    if ("subproperties" in info &&
        // Using setProperty over subproperties is not sufficient for
        // system fonts, since the shorthand does more than its parts.
        (property != "font" || !(value in gSystemFont)) &&
        // Likewise for special compatibility values of transform
        (property != "-moz-transform" || !value.match(/^matrix.*(px|em|%)/))) {
      gDeclaration.removeProperty(property);
      for (idx in info.subproperties) {
        var subprop = info.subproperties[idx];
        gDeclaration.setProperty(subprop, step1vals[idx], "");
      }

      // Now that all the subprops are set, check their values.  Note that we
      // need this in a separate loop, in case parts of the shorthand affect
      // the computed values of other parts.
      for (idx in info.subproperties) {
        var subprop = info.subproperties[idx];
        if (test_computed && !("backend_only" in gCSSProperties[subprop])) {
          is(gComputedStyle.getPropertyValue(subprop), step1comps[idx],
             "serialize(" + subprop + ")+parse should be the identity " +
             "transform for '" + property + ": " + value + "'");
        }
      }
      is(gDeclaration.getPropertyValue(property), step1val,
         "parse+split+serialize should be idempotent for '" +
         property + ": " + value + "'");
    }

    if (test_computed && info.type != CSS_TYPE_TRUE_SHORTHAND) {
      gDeclaration.removeProperty(property);
      gDeclaration.setProperty(property, step1comp, "");
      var func = (xfail_compute(property, value) ||
        xfail_serialize(property, value)) ? todo_is : is;
      func(gComputedStyle.getPropertyValue(property), step1comp,
           "parse+compute+serialize should be idempotent for '" +
           property + ": " + value + "'");
    }
    if (test_computed && "subproperties" in info) {
      gDeclaration.removeProperty(property);
      for (idx in info.subproperties) {
        var subprop = info.subproperties[idx];
        if ("backend_only" in gCSSProperties[subprop])
          continue;
        gDeclaration.setProperty(subprop, step1comps[idx], "");
      }

      // Now that all the subprops are set, check their values.  Note that we
      // need this in a separate loop, in case parts of the shorthand affect
      // the computed values of other parts.
      for (idx in info.subproperties) {
        var subprop = info.subproperties[idx];
        if ("backend_only" in gCSSProperties[subprop])
          continue;
        is(gComputedStyle.getPropertyValue(subprop), step1comps[idx],
           "parse+compute+serialize(" + subprop + ") should be idempotent for '" +
           property + ": " + value + "'");
      }
    }

    // sanity check shorthands to make sure disabled props aren't exposed
    if (info.type != CSS_TYPE_LONGHAND) {
      gDeclaration.setProperty(property, value, "");
      test_remove_all_properties(property, value);
    }

    gDeclaration.removeProperty(property);
  }

  if ("prerequisites" in info) {
    var prereqs = info.prerequisites;
    for (var prereq in prereqs) {
      gPrereqDeclaration.setProperty(prereq, prereqs[prereq], "");
    }
  }

  var idx;
  for (idx in info.initial_values)
    test_value(info.initial_values[idx]);
  for (idx in info.other_values)
    test_value(info.other_values[idx]);

  if ("prerequisites" in info) {
    for (var prereq in info.prerequisites) {
      gPrereqDeclaration.removeProperty(prereq);
    }
  }

}

// To avoid triggering the slow script dialog, we have to test one
// property at a time.
SimpleTest.waitForExplicitFinish();
SimpleTest.requestLongerTimeout(2);
var props = [];
for (var prop in gCSSProperties)
  props.push(prop);
props = props.reverse();
function do_one() {
  if (props.length == 0) {
    SimpleTest.finish();
    return;
  }
  test_property(props.pop());
  SimpleTest.executeSoon(do_one);
}
SimpleTest.executeSoon(do_one);

</script>
</pre>
</body>
</html>
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`<!DOCTYPE HTML>`
			`<html>`
			`<!--`
			`-->`
			`<head>`
			`<title>Test for parsing, storage, and serialization of CSS values</title>`
			`<script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>`
			`<script type="text/javascript" src="property_database.js"></script>`
			`<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />`
Add calc() support for the easiest cases: properties that take lengths but not percentages and take simple values only (-moz-column-rule-width, -moz-column-width, letter-spacing, word-spacing, marker-offset, outline-offset, border-spacing). (Bug 363249) r=bzbarsky 2010-05-11 19:49:43 +04:00			`<style type="text/css" id="prereqsheet">`
			`#testnode {}`
			`</style>`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`</head>`
			`<body>`
			`<p id="display"></p>`
			`<div id="content" style="display: none">`

			`<div id="testnode"></div>`
Bug 840402 - Add some more values to property_database.js. r=dbaron 2013-02-16 06:42:48 +04:00
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`</div>`
			`<pre id="test">`
			`<script class="testbody" type="text/javascript">`

			`/ Test for parsing, storage, and serialization of CSS values /`

Add comment explaining some of the test. 2007-04-17 22:57:35 +04:00			`/*`
			`* The idempotence tests here deserve a little bit of explanation. What`
			`* we're testing here are the following operations:`
			`* parse: string -> CSS rule`
			`* serialize: CSS rule -> string (normalization 1)`
			`* (this actually has two variants that go through partly different`
			`* codepaths, which we exercise with getPropertyValue and cssText)`
			`* compute: CSS rule -> computed style`
			`* cserialize: computed style -> string (normalization 2)`
			`*`
			`* Both serialize and cserialize do some normalization, so we can't test`
			`* for pure round-tripping, and we also can't compare their output since`
			`* they could normalize differently. (We might at some point in the`
			`* future want to guarantee that any output of cserialize is`
			`* untouched by going through parse+serialize, though.)`
			`*`
			`* So we test idempotence of parse + serialize by running the whole`
			`* operation twice. Likewise for parse + compute + cserialize.`
			`*`
Fix the description of the serialize+parse tests. 2007-05-05 21:06:49 +04:00			`* Slightly more interestingly, we test that serialize + parse is the`
			`* identity transform by comparing the output of parse + compute +`
			`* cserialize to the output of parse + serialize + parse + compute +`
			`* cserialize.`
Add comment explaining some of the test. 2007-04-17 22:57:35 +04:00			`*/`

Rewrite handling of CSS system fonts to fix bugs in cascading and serialization. b=377947 r+sr=bzbarsky 2007-06-12 22:28:56 +04:00			`var gSystemFont = {`
			`"caption": true,`
			`"icon": true,`
			`"menu": true,`
			`"message-box": true,`
			`"small-caption": true,`
			`"status-bar": true,`
Bug 840402 - Add some more values to property_database.js. r=dbaron 2013-02-16 06:42:48 +04:00			`"-moz-window": true,`
			`"-moz-document": true,`
			`"-moz-desktop": true,`
			`"-moz-info": true,`
			`"-moz-dialog": true,`
			`"-moz-button": true,`
			`"-moz-pull-down-menu": true,`
			`"-moz-list": true,`
			`"-moz-field": true,`
			`"-moz-workspace": true,`
Rewrite handling of CSS system fonts to fix bugs in cascading and serialization. b=377947 r+sr=bzbarsky 2007-06-12 22:28:56 +04:00			`};`
Add code to know which failures to expect in test_value_storage.html (whether to call todo_is or is), and turn on the test. 2007-04-17 21:06:23 +04:00
			`var gBadCompute = {`
			`// output wrapped around to positive, in exponential notation`
			`"-moz-box-ordinal-group": [ "-1", "-1000" ],`
			`};`

Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`function xfail_compute(property, value)`
			`{`
Add code to know which failures to expect in test_value_storage.html (whether to call todo_is or is), and turn on the test. 2007-04-17 21:06:23 +04:00			`if (property in gBadCompute &&`
			`gBadCompute[property].indexOf(value) != -1)`
			`return true;`

Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`return false;`
			`}`

Bug 660398. Speed up test_value_cloning. r=dbaron The fundamental change is that instead of using 3000+ separate documents to test this we use one big document with distinct IDs for all the tests. 2011-06-01 21:19:16 +04:00			`var gBadSerialize = {`
			`// Font-families which include quotes don't get those escaped when`
			`//serializing: see bug 660397`
			`"font-family": ["\\\"Times New Roman", "Times, \\\"Times New Roman"],`
			`};`

			`function xfail_serialize(property, value)`
			`{`
			`if (property in gBadSerialize &&`
			`gBadSerialize[property].indexOf(value) != -1)`
			`return true;`

			`return false;`
			`}`

Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`var gElement = document.getElementById("testnode");`
			`var gDeclaration = gElement.style;`
			`var gComputedStyle = window.getComputedStyle(gElement, "");`

Add calc() support for the easiest cases: properties that take lengths but not percentages and take simple values only (-moz-column-rule-width, -moz-column-width, letter-spacing, word-spacing, marker-offset, outline-offset, border-spacing). (Bug 363249) r=bzbarsky 2010-05-11 19:49:43 +04:00			`var gPrereqDeclaration =`
			`document.getElementById("prereqsheet").sheet.cssRules[0].style;`

Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`function test_property(property)`
			`{`
			`var info = gCSSProperties[property];`

			`var test_computed = !("backend_only" in info);`

Bug 904263 - add tests to assure all properties can be removed. r=dbaron 2013-08-15 04:38:01 +04:00			`// can all properties be removed from the style?`
			`function test_remove_all_properties(property, value) {`
			`var i, p = [];`
			`for (i = 0; i < gDeclaration.length; i++) p.push(gDeclaration[i]);`
			`for (i = 0; i < p.length; i++) gDeclaration.removeProperty(p[i]);`
			`var errstr = "when setting property " + property + " to " + value;`
			`is(gDeclaration.length, 0, "unremovable properties " + errstr);`
			`is(gDeclaration.cssText, "", "non-empty serialization after removing all properties " + errstr);`
			`}`

Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`function test_value(value) {`
			`gDeclaration.setProperty(property, value, "");`

Fix parsing of 'none' values in 'list-style' shorthand. (Bug 474135) r+sr=bzbarsky 2009-01-23 04:28:13 +03:00			`var idx;`
Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`var step1val = gDeclaration.getPropertyValue(property);`
			`var step1vals = [];`
			`var step1ser = gDeclaration.cssText;`
			`if ("subproperties" in info)`
			`for (idx in info.subproperties)`
			`step1vals.push(gDeclaration.getPropertyValue(info.subproperties[idx]));`
			`var step1comp;`
			`var step1comps = [];`
			`if (test_computed && info.type != CSS_TYPE_TRUE_SHORTHAND)`
			`step1comp = gComputedStyle.getPropertyValue(property);`
			`if (test_computed && "subproperties" in info)`
			`for (idx in info.subproperties)`
			`step1comps.push(gComputedStyle.getPropertyValue(info.subproperties[idx]));`

Fix parsing of 'none' values in 'list-style' shorthand. (Bug 474135) r+sr=bzbarsky 2009-01-23 04:28:13 +03:00			`isnot(step1val, "", "setting '" + value + "' on '" + property + "'");`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`if ("subproperties" in info)`
Add code to know which failures to expect in test_value_storage.html (whether to call todo_is or is), and turn on the test. 2007-04-17 21:06:23 +04:00			`for (idx in info.subproperties) {`
			`var subprop = info.subproperties[idx];`
Fix parsing of 'none' values in 'list-style' shorthand. (Bug 474135) r+sr=bzbarsky 2009-01-23 04:28:13 +03:00			`isnot(gDeclaration.getPropertyValue(subprop), "",`
			`"setting '" + value + "' on '" + property + "'");`
Add code to know which failures to expect in test_value_storage.html (whether to call todo_is or is), and turn on the test. 2007-04-17 21:06:23 +04:00			`}`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00
Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`// We don't care particularly about the whitespace or the placement of`
			`// semicolons, but for simplicity we'll test the current behavior.`
			`var expected_serialization = "";`
Bug 774169, patch 2: Add property_database.js entries for property aliases. r=bzbarsky This adds entries for property aliases as though they are shorthands. This fits with the CSS working group's recent resolution to describe aliases as shorthands, recorded in http://lists.w3.org/Archives/Public/www-style/2012Aug/0770.html . The property_database.js entries themselves are copied from the non-alias entries for the properties, with these changes: (1) The property name is changed to the prefixed form (2) The domProp entry is changed to the prefixed form (3) Adding alias_for entries for each property. (4) When type is CSS_TYPE_LONGHAND in the target of the alias, type for the alias is CSS_TYPE_SHORTHAND_AND_LONGHAND and a subproperties entry is added with the target of the alias. There are also some indentation fixes to the copied entries in property_database.js (made before they were copied, and thus affecting the original as well). 2012-09-18 22:37:14 +04:00			`if (step1val != "") {`
			`if ("alias_for" in info) {`
			`expected_serialization = info.alias_for + ": " + step1val + ";";`
			`} else {`
			`expected_serialization = property + ": " + step1val + ";";`
			`}`
			`}`
Rewrite the shorthand condensation code in nsCSSDeclaration::ToString. (Bug 376075) r+sr=bzbarsky 2008-12-23 17:06:57 +03:00			`is(step1ser, expected_serialization,`
			`"serialization should match property value");`
Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`gDeclaration.removeProperty(property);`
			`gDeclaration.setProperty(property, step1val, "");`

Bug 660398. Speed up test_value_cloning. r=dbaron The fundamental change is that instead of using 3000+ separate documents to test this we use one big document with distinct IDs for all the tests. 2011-06-01 21:19:16 +04:00			`var serialize_func = xfail_serialize(property, value) ? todo_is : is;`

			`serialize_func(gDeclaration.getPropertyValue(property), step1val,`
Fix parsing of 'none' values in 'list-style' shorthand. (Bug 474135) r+sr=bzbarsky 2009-01-23 04:28:13 +03:00			`"parse+serialize should be idempotent for '" +`
Add code to know which failures to expect in test_value_storage.html (whether to call todo_is or is), and turn on the test. 2007-04-17 21:06:23 +04:00			`property + ": " + value + "'");`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`if (test_computed && info.type != CSS_TYPE_TRUE_SHORTHAND) {`
Bug 660398. Speed up test_value_cloning. r=dbaron The fundamental change is that instead of using 3000+ separate documents to test this we use one big document with distinct IDs for all the tests. 2011-06-01 21:19:16 +04:00			`serialize_func(gComputedStyle.getPropertyValue(property), step1comp,`
Fix parsing of 'none' values in 'list-style' shorthand. (Bug 474135) r+sr=bzbarsky 2009-01-23 04:28:13 +03:00			`"serialize+parse should be identity transform for '" +`
			`property + ": " + value + "'");`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`}`

Rewrite handling of CSS system fonts to fix bugs in cascading and serialization. b=377947 r+sr=bzbarsky 2007-06-12 22:28:56 +04:00			`if ("subproperties" in info &&`
			`// Using setProperty over subproperties is not sufficient for`
			`// system fonts, since the shorthand does more than its parts.`
Bug 774169, patch 4: Revert bug 719054 for prefixed -moz-transform but leave it for unprefixed transform. r=bzbarsky 2012-09-18 22:37:14 +04:00			`(property != "font" \|\| !(value in gSystemFont)) &&`
			`// Likewise for special compatibility values of transform`
			`(property != "-moz-transform" \|\| !value.match(/^matrix.*(px\|em\|%)/))) {`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`gDeclaration.removeProperty(property);`
			`for (idx in info.subproperties) {`
Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`var subprop = info.subproperties[idx];`
			`gDeclaration.setProperty(subprop, step1vals[idx], "");`
Change round-trip testing for specified sub-properties of a shorthand to setthem all before looking at computed style, since, for example, the specifiedfont-family affects the computed line-height if the specified line-height is"normal". Bug 379809, r=dbaron 2007-05-16 07:03:34 +04:00			`}`

			`// Now that all the subprops are set, check their values. Note that we`
			`// need this in a separate loop, in case parts of the shorthand affect`
			`// the computed values of other parts.`
			`for (idx in info.subproperties) {`
			`var subprop = info.subproperties[idx];`
Better express that failures in one of the system font cases depend on what the system fonts actually are. 2007-04-17 22:01:17 +04:00			`if (test_computed && !("backend_only" in gCSSProperties[subprop])) {`
Fix parsing of 'none' values in 'list-style' shorthand. (Bug 474135) r+sr=bzbarsky 2009-01-23 04:28:13 +03:00			`is(gComputedStyle.getPropertyValue(subprop), step1comps[idx],`
			`"serialize(" + subprop + ")+parse should be the identity " +`
			`"transform for '" + property + ": " + value + "'");`
Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`}`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`}`
Fix parsing of 'none' values in 'list-style' shorthand. (Bug 474135) r+sr=bzbarsky 2009-01-23 04:28:13 +03:00			`is(gDeclaration.getPropertyValue(property), step1val,`
			`"parse+split+serialize should be idempotent for '" +`
			`property + ": " + value + "'");`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`}`

			`if (test_computed && info.type != CSS_TYPE_TRUE_SHORTHAND) {`
			`gDeclaration.removeProperty(property);`
			`gDeclaration.setProperty(property, step1comp, "");`
Bug 660398. Speed up test_value_cloning. r=dbaron The fundamental change is that instead of using 3000+ separate documents to test this we use one big document with distinct IDs for all the tests. 2011-06-01 21:19:16 +04:00			`var func = (xfail_compute(property, value) \|\|`
			`xfail_serialize(property, value)) ? todo_is : is;`
Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`func(gComputedStyle.getPropertyValue(property), step1comp,`
			`"parse+compute+serialize should be idempotent for '" +`
			`property + ": " + value + "'");`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`}`
			`if (test_computed && "subproperties" in info) {`
Back out part of the last change which is not actually correct 2007-05-16 07:39:36 +04:00			`gDeclaration.removeProperty(property);`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`for (idx in info.subproperties) {`
Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`var subprop = info.subproperties[idx];`
Better express that failures in one of the system font cases depend on what the system fonts actually are. 2007-04-17 22:01:17 +04:00			`if ("backend_only" in gCSSProperties[subprop])`
			`continue;`
Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`gDeclaration.setProperty(subprop, step1comps[idx], "");`
Followup tweak for bug 379809, r=dbaron 2007-05-16 20:03:05 +04:00			`}`

			`// Now that all the subprops are set, check their values. Note that we`
			`// need this in a separate loop, in case parts of the shorthand affect`
			`// the computed values of other parts.`
			`for (idx in info.subproperties) {`
			`var subprop = info.subproperties[idx];`
			`if ("backend_only" in gCSSProperties[subprop])`
			`continue;`
Fix parsing of 'none' values in 'list-style' shorthand. (Bug 474135) r+sr=bzbarsky 2009-01-23 04:28:13 +03:00			`is(gComputedStyle.getPropertyValue(subprop), step1comps[idx],`
			`"parse+compute+serialize(" + subprop + ") should be idempotent for '" +`
			`property + ": " + value + "'");`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`}`
			`}`

Bug 904263 - add tests to assure all properties can be removed. r=dbaron 2013-08-15 04:38:01 +04:00			`// sanity check shorthands to make sure disabled props aren't exposed`
			`if (info.type != CSS_TYPE_LONGHAND) {`
			`gDeclaration.setProperty(property, value, "");`
			`test_remove_all_properties(property, value);`
			`}`

Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`gDeclaration.removeProperty(property);`
			`}`

Add calc() support for the easiest cases: properties that take lengths but not percentages and take simple values only (-moz-column-rule-width, -moz-column-width, letter-spacing, word-spacing, marker-offset, outline-offset, border-spacing). (Bug 363249) r=bzbarsky 2010-05-11 19:49:43 +04:00			`if ("prerequisites" in info) {`
			`var prereqs = info.prerequisites;`
			`for (var prereq in prereqs) {`
			`gPrereqDeclaration.setProperty(prereq, prereqs[prereq], "");`
			`}`
			`}`

Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`var idx;`
			`for (idx in info.initial_values)`
			`test_value(info.initial_values[idx]);`
			`for (idx in info.other_values)`
			`test_value(info.other_values[idx]);`
Add calc() support for the easiest cases: properties that take lengths but not percentages and take simple values only (-moz-column-rule-width, -moz-column-width, letter-spacing, word-spacing, marker-offset, outline-offset, border-spacing). (Bug 363249) r=bzbarsky 2010-05-11 19:49:43 +04:00
			`if ("prerequisites" in info) {`
			`for (var prereq in info.prerequisites) {`
			`gPrereqDeclaration.removeProperty(prereq);`
			`}`
			`}`

Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`}`

Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`// To avoid triggering the slow script dialog, we have to test one`
			`// property at a time.`
			`SimpleTest.waitForExplicitFinish();`
Bug 915439 - Use longer timeouts for test_value_computation.html and test_value_storage.html. r=bzbarsky 2013-09-19 05:35:19 +04:00			`SimpleTest.requestLongerTimeout(2);`
Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`var props = [];`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00			`for (var prop in gCSSProperties)`
Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`props.push(prop);`
			`props = props.reverse();`
Use SimpleTest.executeSoon instead of setTimeout for iteration of properties/descriptors. 2009-03-31 23:37:40 +04:00			`function do_one() {`
			`if (props.length == 0) {`
Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`SimpleTest.finish();`
			`return;`
			`}`
Use SimpleTest.executeSoon instead of setTimeout for iteration of properties/descriptors. 2009-03-31 23:37:40 +04:00			`test_property(props.pop());`
			`SimpleTest.executeSoon(do_one);`
Work towards getting test_value_storage running. 2007-04-17 11:41:44 +04:00			`}`
Use SimpleTest.executeSoon instead of setTimeout for iteration of properties/descriptors. 2009-03-31 23:37:40 +04:00			`SimpleTest.executeSoon(do_one);`
Work in progress on a test for value storage and serialization. 2007-04-17 08:45:49 +04:00
			`</script>`
			`</pre>`
			`</body>`
			`</html>`