Update CSS tests to revision 2baa72daab8bf37e3e910a9fd311a1eaa5b0f4a8

tests/wpt/css-tests/cssom-1_dev/html/support/README

@@ -0,0 +1,29 @@
+CSS Global Support Directory
+============================
+
+This directory contains common support files (such as images and external
+style sheets). These are sync'ed into the support directories of all our
+test suites. If you have test-suite-specific support files, please add
+them to the appropriate test-suite-specific support/ directory.
+
+If you add to a support/ directory, please run the tools/supportprop.py
+script from the top of the repository to cascade support files into the
+lower-level support directories.
+
+Description of the Common Support File Collection
+-------------------------------------------------
+
+The 1x1-* images are all exactly one pixel.
+
+The swatch-* images all use 15x15 cells.
+
+The square-* images all use 15x15 cells with one pixel borders.
+
+The pattern-* images use cells of various sizes:
+
+   pattern-gg-gr.png         20x20
+   pattern-grg-rgr-grg.png   20x20
+   pattern-rgr-grg-rgr.png   20x20
+   pattern-tr.png            15x15
+   pattern-grg-rrg-rgg.png   15x15
+

tests/wpt/css-tests/cssom-1_dev/html/support/a-green.css

@@ -0,0 +1 @@
+.a { color: green; }

tests/wpt/css-tests/cssom-1_dev/html/support/b-green.css

@@ -0,0 +1 @@
+.b { color: green; }

tests/wpt/css-tests/cssom-1_dev/html/support/c-red.css

@@ -0,0 +1 @@
+.c { color: red; }

tests/wpt/css-tests/cssom-1_dev/html/support/import-green.css

@@ -0,0 +1 @@
+.import { color: green; }

tests/wpt/css-tests/cssom-1_dev/html/support/import-red.css

@@ -0,0 +1 @@
+.import { color: red; }

tests/wpt/css-tests/cssom-1_dev/html/support/parsing-utils.js

@@ -0,0 +1,866 @@
+var ParsingUtils = (function() {
+function testInlineStyle(value, expected) {
+    var div = document.createElement('div');
+    div.style.setProperty('shape-outside', value);
+    var actual = div.style.getPropertyValue('shape-outside');
+    assert_equals(actual, expected);
+}
+
+function testComputedStyle(value, expected) {
+    var div = document.createElement('div');
+    div.style.setProperty('shape-outside', value);
+    document.body.appendChild(div);
+    var style = getComputedStyle(div);
+    var actual = style.getPropertyValue('shape-outside');
+    actual = roundResultStr(actual);
+    document.body.removeChild(div);
+
+    // Some of the tests in this suite have either/or expected results
+    // so this check allows for testing that at least one of them passes.
+    // Description of the 2 expecteds is below near calcTestValues.
+    if(Object.prototype.toString.call( expected ) === '[object Array]' && expected.length == 2) {
+        assert_true(expected[0] == actual || expected[1] == actual)
+    } else {
+        assert_equals(actual, typeof expected !== 'undefined' ? expected : value);
+    }
+}
+
+function testShapeMarginInlineStyle(value, expected) {
+    var div = document.createElement('div');
+    div.style.setProperty('shape-outside', "border-box inset(10px)");
+    div.style.setProperty('shape-margin', value);
+    var actual = div.style.getPropertyValue('shape-margin');
+    assert_equals(actual, expected);
+}
+
+function testShapeMarginComputedStyle(value, expected) {
+
+    var outerDiv = document.createElement('div');
+    outerDiv.style.setProperty('width', '100px');
+
+    var innerDiv = document.createElement('div');
+    innerDiv.style.setProperty('shape-outside', "border-box inset(10px)");
+    innerDiv.style.setProperty('shape-margin', value);
+
+    outerDiv.appendChild(innerDiv);
+    document.body.appendChild(outerDiv);
+
+    var style = getComputedStyle(innerDiv);
+    var actual = style.getPropertyValue('shape-margin');
+
+    assert_not_equals(actual, null);
+    if(actual.indexOf('calc') == -1 )
+        actual = roundResultStr(actual);
+    document.body.removeChild(outerDiv);
+
+    // See comment above about multiple expected results
+    if(Object.prototype.toString.call( expected ) === '[object Array]' && expected.length == 2) {
+        assert_true(expected[0] == actual || expected[1] == actual)
+    } else {
+        assert_equals(actual, !expected ? '0px' : expected);
+    }
+}
+
+function testShapeThresholdInlineStyle(value, expected) {
+    var div = document.createElement('div');
+    div.style.setProperty('shape-outside', 'url(someimage.png)');
+    div.style.setProperty('shape-image-threshold', value);
+    var actual = div.style.getPropertyValue('shape-image-threshold');
+    assert_equals(actual, expected);
+}
+
+function testShapeThresholdComputedStyle(value, expected) {
+
+    var div = document.createElement('div');
+    div.style.setProperty('shape-outside', 'url(someimage.png)');
+    div.style.setProperty('shape-image-threshold', value);
+    document.body.appendChild(div);
+
+    var style = getComputedStyle(div);
+    var actual = style.getPropertyValue('shape-image-threshold');
+
+    assert_not_equals(actual, null);
+    if(actual.indexOf('calc') == -1 )
+        actual = roundResultStr(actual);
+    document.body.removeChild(div);
+
+    // See comment above about multiple expected results
+    if(Object.prototype.toString.call( expected ) === '[object Array]' && expected.length == 2) {
+        assert_true(expected[0] == actual || expected[1] == actual)
+    } else {
+        assert_equals(actual, !expected ? '0' : expected);
+    }
+}
+
+// Builds an array of test cases to send to testharness.js where one test case is: [name, actual, expected]
+// These test cases will verify results from testInlineStyle() or testComputedStyle()
+function buildTestCases(testCases, testType) {
+    var results = [];
+
+    // If test_type isn't specified, test inline style
+    var type = typeof testType == 'undefined' ? 'invalid': testType;
+
+    testCases.forEach(function(test) {
+        oneTestCase = [];
+
+        // name - annotated by type (inline vs. computed)
+        if ( test.hasOwnProperty('name') ) {
+            oneTestCase.push(test['name'] +' - '+ type);
+        } else {
+            // If test_name isn't specified, use the actual
+            oneTestCase.push(test['actual'] +' - '+ type);
+        }
+
+        // actual
+        oneTestCase.push(test['actual'])
+
+        // expected
+        if( type.indexOf('invalid') != -1 ){
+            oneTestCase.push(null)
+        } else if( type == 'inline' ) {
+            oneTestCase.push(test['expected_inline']);
+        } else if( type == 'computed' ){
+            oneTestCase.push( convertToPx(test['expected_computed']) );
+        }
+        results.push(oneTestCase);
+    });
+    return results;
+}
+
+
+function buildPositionTests(shape, valid, type, units) {
+    var results = new Array();
+    var convert = type.indexOf('computed') != -1 ? true : false;
+
+    if(Object.prototype.toString.call( units ) === '[object Array]') {
+        units.forEach(function(unit) {
+            positionTests = buildPositionTests(shape, valid, type, unit);
+            results = results.concat(positionTests);
+        });
+    } else {
+        if (valid) {
+            validPositions.forEach(function(test) {
+                var testCase = [], testName, actual, expected;
+                // skip if this isn't explicitly testing length units
+                if( !(type.indexOf('lengthUnit') != -1 && test[0].indexOf("u1") == -1)) {
+                    // actual
+                    actual = shape + '(at ' + setUnit(test[0], false, units) +')';
+
+                    // expected
+                  //  if(convert && shape == 'circle')
+                  //      expected = shape + '(at ' + setUnit(test[1], convert, units) +')';
+                  //  else if(convert && shape == 'ellipse')
+                  //      expected = shape + '(at ' + setUnit(test[1], convert, units) +')';
+                  //  else
+                   expected = shape + '(at ' + setUnit(test[1], convert, units) +')';
+
+                    // name
+                    if (type == 'lengthUnit + inline')
+                        testName = 'test unit (inline): ' + units +' - '+ actual;
+                    else if (type == 'lengthUnit + computed')
+                         testName = 'test unit (computed): ' + units +' - '+ actual;
+                    else
+                        testName = (actual + ' serializes as ' + expected +' - '+ type);
+
+                    testCase.push(testName)
+                    testCase.push(actual);
+                    testCase.push(expected);
+                    results.push(testCase);
+                }
+            });
+        } else {
+            invalidPositions.forEach(function(test) {
+                var testValue = shape + '(at ' + setUnit(test, false, units) +')';
+                testCase = new Array();
+                testCase.push(testValue + ' is invalid');
+                testCase.push(testValue);
+                testCase.push(null);
+                results.push(testCase);
+            });
+        }
+    }
+    return unique(results);
+}
+
+function buildRadiiTests(shape, type, units) {
+    var results = new Array();
+    var testUnits = typeof units == 'undefined' ? 'px': units;
+    var convert = type.indexOf('computed') != -1 ? true : false;
+
+    if(Object.prototype.toString.call( testUnits ) === '[object Array]') {
+           testUnits.forEach(function(unit) {
+               radiiTests = buildRadiiTests(shape, type, unit);
+               results = results.concat(radiiTests);
+           });
+    } else {
+        var validRadii = shape == 'circle' ? validCircleRadii : validEllipseRadii;
+        validRadii.forEach(function(test) {
+            var testCase = [], name, actual, expected;
+
+            // skip if this isn't explicitly testing length units
+            if( !(type.indexOf('lengthUnit') != -1 && test[0].indexOf("u1") == -1) ) {
+                actual = shape + '(' + setUnit(test[0], false, testUnits) +')';
+                // name
+                if (type.indexOf('lengthUnit') != -1) {
+                    name = 'test unit: ' + units +' - '+ actual;
+                    if(type.indexOf('computed') != -1)
+                        name = name + ' - computed';
+                    else
+                        name = name + ' - inline';
+                }
+                else
+                    name = actual +' - '+ type;
+
+                testCase.push(name);
+
+                // actual
+                testCase.push(actual);
+
+                // expected
+                if(type.indexOf('computed') != -1 && test.length == 3) {
+                    expected = shape + '(' + setUnit(test[2], convert, testUnits) +')';
+                } else {
+                    expected = shape + '(' + setUnit(test[1], convert, testUnits) +')';
+                }
+                testCase.push(expected);
+                results.push(testCase);
+            }
+        });
+    }
+    return unique(results);
+}
+
+function buildInsetTests(unit1, unit2, type) {
+    var results = new Array();
+    var convert = type == 'computed' ? true : false;
+
+    if(Object.prototype.toString.call( unit1 ) === '[object Array]') {
+        unit1.forEach(function(unit) {
+            insetTests = buildInsetTests(unit, unit2, type);
+            results = results.concat(insetTests);
+        });
+    } else {
+        validInsets.forEach(function(test) {
+            var testCase = [], name, actual, expected;
+
+            name = setUnit(test[0], false, unit1, unit2) +' - '+ type;
+            actual = 'inset(' + setUnit(test[1], convert, unit1, unit2) +')';
+            expected = actual;
+
+            testCase.push(name);
+            testCase.push(actual);
+            testCase.push(expected);
+
+            results.push(testCase);
+        });
+    }
+    return unique(results);
+}
+
+function buildPolygonTests(unitSet, type) {
+    var results = new Array();
+    var convert = type == 'computed' ? true : false;
+
+    unitSet.forEach(function(set) {
+        validPolygons.forEach(function(test) {
+            var testCase = [];
+            // name
+            testCase.push(setUnit(test[0], false, set[0], set[1], set[2]) +' - '+ type);
+            // actual
+            testCase.push('polygon(' + setUnit(test[1], false, set[0], set[1], set[2]) +')');
+            // expected
+            testCase.push('polygon(' + setUnit(test[1], convert, set[0], set[1], set[2]) +')');
+            results.push(testCase);
+        });
+    });
+    return unique(results);
+}
+
+function buildCalcTests(testCases, type) {
+    var results = new Array();
+    testCases.forEach(function(test){
+        var testCase = [];
+        if(type == 'computed') {
+            testCase.push(test[0] + ' - computed style');
+            testCase.push(test[0]);
+            testCase.push(test[2]);
+        }
+        else {
+            testCase.push(test[0] + ' - inline style');
+            testCase.push(test[0]);
+            testCase.push(test[1]);
+        }
+        testCase.push(type);
+        results.push(testCase)
+    });
+    return unique(results);
+}
+
+function unique(tests) {
+    var list = tests.concat();
+    for(var i = 0; i< list.length; ++i) {
+        for(var j = i+1; j < list.length; ++j) {
+            if(list[i][0] === list[j][0])
+                list.splice(j--, 1);
+        }
+    }
+    return list;
+}
+
+function setUnit(str, convert, unit1, unit2, unit3) {
+    var retStr = str;
+    if(typeof unit1 !== 'undefined') {
+        retStr = retStr.replace(new RegExp('u1', 'g'), unit1);
+    }
+    if(typeof unit2 !== 'undefined') {
+        retStr = retStr.replace(new RegExp("u2", 'g'), unit2);
+    }
+    if(typeof unit3 !== 'undefined') {
+        retStr = retStr.replace(new RegExp("u3", 'g'), unit3);
+    }
+    retStr = convert ? convertToPx(retStr) : retStr;
+    return retStr;
+}
+
+function convertToPx(origValue) {
+
+    var valuesToConvert = origValue.match(/[0-9]+(\.[0-9]+)?([a-z]{2,4}|%)/g);
+    if(!valuesToConvert)
+        return origValue;
+
+    var retStr = origValue;
+    for(var i = 0; i < valuesToConvert.length; i++) {
+        var unit = valuesToConvert[i].match(/[a-z]{2,4}|%/).toString();
+        var numberStr = valuesToConvert[i].match(/[0-9]+(\.[0-9]+)?/)[0];
+
+        var number = parseFloat(numberStr);
+        var convertedUnit = 'px';
+        if( typeof number !== 'NaN' )
+        {
+             if (unit == 'in') {
+                 number = (96 * number);
+             } else if (unit == 'cm') {
+                 number = (37.795275591 * number);
+             } else if (unit == 'mm') {
+                 number = (3.779527559 * number);
+             } else if (unit == 'pt') {
+                 number = (1.333333333333 * number);
+             } else if (unit == 'pc') {
+                 number = (16 * number);
+             } else if (unit == 'em') {
+                 number = (16 * number);
+             } else if (unit == 'ex') {
+                 number = (7.1796875 * number);
+             } else if (unit == 'ch') {
+                 number = (8 * number);
+             } else if (unit == 'rem') {
+                 number = (16 * number);
+             } else if (unit == 'vw') {
+                 number = ((.01 * window.innerWidth) * number);
+             } else if (unit == 'vh') {
+                 number = ((.01 * window.innerHeight) * number);
+             } else if (unit == 'vmin') {
+                 number = Math.min( (.01 * window.innerWidth), (.01 * window.innerHeight) ) * number;
+             } else if (unit == 'vmax') {
+                number = Math.max( (.01 * window.innerWidth), (.01 * window.innerHeight) ) * number;
+             }
+             else {
+                 convertedUnit = unit;
+             }
+            number = Math.round(number * 1000) / 1000;
+            var find = valuesToConvert[i];
+            var replace = number.toString() + convertedUnit;
+            retStr = retStr.replace(valuesToConvert[i], number.toString() + convertedUnit);
+      }
+    }
+    return retStr.replace(',,', ',');
+}
+
+function roundResultStr(str) {
+    if(Object.prototype.toString.call( str ) !== '[object String]')
+        return str;
+
+    var numbersToRound = str.match(/[0-9]+\.[0-9]+/g);
+    if(!numbersToRound)
+        return str;
+
+    var retStr = str;
+    for(var i = 0; i < numbersToRound.length; i++) {
+        num = parseFloat(numbersToRound[i]);
+        if( !isNaN(num) ) {
+            roundedNum = Math.round(num*1000)/1000;
+            retStr = retStr.replace(numbersToRound[i].toString(), roundedNum.toString());
+        }
+    }
+
+    return retStr;
+}
+
+function generateInsetRoundCases(units, testType) {
+    var convert = testType.indexOf('computed') != -1 ? true : false;
+    var testUnit = units;
+    var sizes = [
+        '10' + units,
+        '20' + units,
+        '30' + units,
+        '40' + units
+    ];
+
+    function insetRound(value) {
+        return 'inset(10' +testUnit+ ' round ' + value + ')';
+    }
+
+    function serializedInsetRound(lhsValues, rhsValues, convert) {
+        var retStr = '';
+        if(!rhsValues)
+            retStr = 'inset(10' +testUnit+ ' round ' + lhsValues +')';
+        else
+            retStr = 'inset(10' +testUnit+ ' round ' + lhsValues +' / '+ rhsValues +')';
+
+        if(convert)
+            return convertToPx(retStr);
+
+        return retStr;
+    }
+
+    var results = [], left, lhs, right, rhs;
+    for (left = 1; left <= 4; left++) {
+        lhs = sizes.slice(0, left).join(' ');
+        results.push([insetRound(lhs) +' - '+ testType, insetRound(lhs), serializedInsetRound(lhs, null, convert)]);
+        for (right = 1; right <= 4; right++) {
+            rhs = sizes.slice(0, right).join(' ');
+            if(lhs == rhs)
+                results.push([insetRound(lhs + ' / ' + rhs) +' - '+ testType, insetRound(lhs + ' / ' + rhs), serializedInsetRound(lhs, null, convert)]);
+            else
+                results.push([insetRound(lhs + ' / ' + rhs) +' - '+ testType, insetRound(lhs + ' / ' + rhs), serializedInsetRound(lhs, rhs, convert)]);
+        }
+    }
+    return results;
+}
+
+var validUnits = [
+                    "cm","mm","in","pt","pc",  // Absolute length units (omitting px b/c we default to that in all tests)
+                    "em","ex","ch","rem",      // Font relative length units
+                    "vw","vh","vmin","vmax"    // Viewport percentage units
+                 ]
+
+/// [actual, expected]
+var validPositions = [
+
+/// [ percent ], [ length ], [ percent | percent ], [ percent | length ], [ length | percent ], [ length | length ]
+    ["50%", "50% 50%"],
+    ["50u1", "50u1 50%"],
+    ["50% 50%", "50% 50%"],
+    ["50% 50u1", "50% 50u1"],
+    ["50u1 50%", "50u1 50%"],
+    ["50u1 50u1", "50u1 50u1"],
+
+///// [ keyword ], [ keyword keyword ] x 5 keywords
+    ["left", "0% 50%"],
+    ["top", "50% 0%"],
+    ["right", "100% 50%"],
+    ["bottom", "50% 100%"],
+    ["center", "50% 50%"],
+
+    ["left top", "0% 0%"],
+    ["left bottom", "0% 100%"],
+    ["left center", "0% 50%"],
+
+    ["top left", "0% 0%"],
+    ["top right", "100% 0%"],
+    ["top center", "50% 0%"],
+
+    ["right top", "100% 0%"],
+    ["right bottom", "100% 100%"],
+    ["right center", "100% 50%"],
+
+    ["bottom left", "0% 100%"],
+    ["bottom right", "100% 100%"],
+    ["bottom center", "50% 100%"],
+
+    ["center top", "50% 0%"],
+    ["center left", "0% 50%"],
+    ["center right", "100% 50%"],
+    ["center bottom", "50% 100%"],
+    ["center center", "50% 50%"],
+
+////// [ keyword | percent ], [ keyword | length ], [ percent | keyword ], [ length | keyword ] x 5 keywords
+    ["left 50%", "0% 50%"],
+    ["left 50u1", "0% 50u1"],
+
+    ["50% top", "50% 0%"],
+    ["50u1 top", "50u1 0%"],
+
+    ["right 80%", "100% 80%"],
+    ["right 80u1", "100% 80u1"],
+
+    ["70% bottom", "70% 100%"],
+    ["70u1 bottom", "70u1 100%"],
+
+    ["center 60%", "50% 60%"],
+    ["center 60u1", "50% 60u1"],
+    ["60% center", "60% 50%"],
+    ["60u1 center", "60u1 50%"],
+
+////// [ keyword | keyword percent ], [ keyword | keyword length ] x 5 keywords
+    ["center top 50%", "50% 50%"],
+    ["center top 50u1", "50% 50u1"],
+    ["center left 50%", "50% 50%"],
+    ["center left 50u1", "50u1 50%"],
+    ["center right 70%", "30% 50%"],
+    ["center right 70u1", "right 70u1 top 50%"],
+    ["center bottom 70%", "50% 30%"],
+    ["center bottom 70u1", "left 50% bottom 70u1"],
+
+    ["left top 50%", "0% 50%"],
+    ["left top 50u1", "0% 50u1"],
+    ["left bottom 70%", "0% 30%"],
+    ["left bottom 70u1", "left 0% bottom 70u1"],
+
+    ["top left 50%", "50% 0%"],
+    ["top left 50u1", "50u1 0%"],
+    ["top right 70%", "30% 0%"],
+    ["top right 70u1", "right 70u1 top 0%"],
+
+    ["bottom left 50%", "50% 100%"],
+    ["bottom left 50u1", "50u1 100%"],
+    ["bottom right 70%", "30% 100%"],
+    ["bottom right 70u1", "right 70u1 top 100%"],
+
+    ["right bottom 70%", "100% 30%"],
+    ["right bottom 70u1", "left 100% bottom 70u1"],
+    ["right top 50%", "100% 50%"],
+    ["right top 50u1", "100% 50u1"],
+
+////// [ keyword percent | keyword], [ keyword length | keyword ] x 5 keywords
+    ["left 50% center", "50% 50%"],
+    ["left 50u1 center", "50u1 50%"],
+    ["left 50% top", "50% 0%"],
+    ["left 50u1 top", "50u1 0%"],
+    ["left 50% bottom", "50% 100%"],
+    ["left 50u1 bottom", "50u1 100%"],
+
+    ["top 50% center", "50% 50%"],
+    ["top 50u1 center", "50% 50u1"],
+    ["top 50% left", "0% 50%"],
+    ["top 50u1 left", "0% 50u1"],
+    ["top 50% right", "100% 50%"],
+    ["top 50u1 right", "100% 50u1"],
+
+    ["bottom 70% center", "50% 30%"],
+    ["bottom 70u1 center", "left 50% bottom 70u1"],
+    ["bottom 70% left", "0% 30%"],
+    ["bottom 70u1 left", "left 0% bottom 70u1"],
+    ["bottom 70% right", "100% 30%"],
+    ["bottom 70u1 right", "left 100% bottom 70u1"],
+
+    ["right 80% center", "20% 50%"],
+    ["right 80u1 center", "right 80u1 top 50%"],
+    ["right 80% bottom", "20% 100%"],
+    ["right 80u1 bottom", "right 80u1 top 100%"],
+    ["right 80% top", "20% 0%"],
+    ["right 80u1 top", "right 80u1 top 0%"],
+
+////// [ keyword percent |  keyword percent], [ keyword percent |  keyword length],
+////// [ keyword length | keyword length],  [ keyword length | keyword percent] x 5 keywords
+    ["left 50% top 50%", "50% 50%"],
+    ["left 50% top 50u1", "50% 50u1"],
+    ["left 50% bottom 70%", "50% 30%"],
+    ["left 50% bottom 70u1", "left 50% bottom 70u1"],
+    ["left 50u1 top 50%", "50u1 50%"],
+    ["left 50u1 top 50u1", "50u1 50u1"],
+    ["left 50u1 bottom 70%", "50u1 30%"],
+    ["left 50u1 bottom 70u1", "left 50u1 bottom 70u1"],
+
+    ["top 50% left 50%", "50% 50%"],
+    ["top 50% left 50u1", "50u1 50%"],
+    ["top 50% right 80%", "20% 50%"],
+    ["top 50% right 80u1", "right 80u1 top 50%"],
+    ["top 50u1 left 50%", "50% 50u1"],
+    ["top 50u1 left 50u1", "50u1 50u1"],
+    ["top 50u1 right 80%", "20% 50u1"],
+    ["top 50u1 right 80u1", "right 80u1 top 50u1"],
+
+    ["bottom 70% left 50%", "50% 30%"],
+    ["bottom 70% left 50u1", "50u1 30%"],
+    ["bottom 70% right 80%", "20% 30%"],
+    ["bottom 70% right 80u1", "right 80u1 top 30%"],
+    ["bottom 70u1 left 50%", "left 50% bottom 70u1"],
+    ["bottom 70u1 left 50u1", "left 50u1 bottom 70u1"],
+    ["bottom 70u1 right 80%", "left 20% bottom 70u1"],
+    ["bottom 70u1 right 80u1", "right 80u1 bottom 70u1"],
+
+    ["right 80% top 50%", "20% 50%"],
+    ["right 80% top 50u1", "20% 50u1"],
+    ["right 80% bottom 70%", "20% 30%"],
+    ["right 80% bottom 70u1", "left 20% bottom 70u1"],
+    ["right 80u1 top 50%", "right 80u1 top 50%"],
+    ["right 80u1 top 50u1", "right 80u1 top 50u1"],
+    ["right 80u1 bottom 70%", "right 80u1 top 30%"],
+    ["right 80u1 bottom 70u1", "right 80u1 bottom 70u1"],
+];
+
+var invalidPositions = [
+////// [ keyword | percent ], [ keyword | length ], [ percent | keyword ], [ length | keyword ] x 5 keywords
+    "50% left",
+    "50px left",
+    "top 50%",
+    "80% right",
+    "80px right",
+    "bottom 70%",
+    "bottom 70px",
+
+//////  [ keyword | keyword percent ], [ keyword | keyword length ] x 5 keywords
+    "center center 60%",
+    "center center 60px",
+
+    "left center 60%",
+    "left center 60px",
+    "left right 80%",
+    "left right 80px",
+    "left left 50%",
+    "left left 50px",
+
+    "top center 60%",
+    "top center 60px",
+    "top bottom 80%",
+    "top bottom 80px",
+    "top top 50%",
+    "top top 50px",
+
+    "bottom center 60%",
+    "bottom center 60px",
+    "bottom top 50%",
+    "bottom top 50px",
+    "bottom bottom 50%",
+    "bottom bottom 50px",
+
+    "right center 60%",
+    "right center 60px",
+    "right left 50%",
+    "right left 50px",
+    "right right 70%",
+    "right right 70px",
+
+////// [ keyword percent | keyword], [ keyword length | keyword ] x 5 keywords
+    "center 60% top",
+    "center 60px top",
+    "center 60% bottom",
+    "center 60px bottom",
+    "center 60% left",
+    "center 60px left",
+    "center 60% right",
+    "center 60px right",
+    "center 60% center",
+    "center 60px center",
+
+    "left 50% right",
+    "left 50px right",
+    "left 50% left",
+    "left 50px left",
+
+    "top 50% bottom",
+    "top 50px bottom",
+    "top 50% top",
+    "top 50px top",
+
+    "bottom 70% top",
+    "bottom 70px top",
+    "bottom 70% bottom",
+    "bottom 70px bottom",
+
+    "right 80% left",
+    "right 80px left",
+
+////// [ keyword percent |  keyword percent], [ keyword percent |  keyword length],
+////// [ keyword length | keyword length],  [ keyword length | keyword percent] x 5 keywords
+    "center 60% top 50%",
+    "center 60% top 50px",
+    "center 60% bottom 70%",
+    "center 60% bottom 70px",
+    "center 60% left 50%",
+    "center 60% left 50px",
+    "center 60% right 70%",
+    "center 60% right 70px",
+    "center 60% center 65%",
+    "center 60% center 65px",
+    "center 60px top 50%",
+    "center 60px top 50px",
+    "center 60px bottom 70%",
+    "center 60px bottom 70px",
+    "center 60px left 50%",
+    "center 60px left 50px",
+    "center 60px right 70%",
+    "center 60px right 70px",
+    "center 60px center 65%",
+    "center 60px center 65px",
+
+    "left 50% center 60%",
+    "left 50% center 60px",
+    "left 50% right 80%",
+    "left 50% right 80px",
+    "left 50% left 50%",
+    "left 50% left 50px",
+    "left 50px center 60%",
+    "left 50px center 60px",
+    "left 50px right 80%",
+    "left 50px right 80px",
+    "left 50px left 50%",
+    "left 50px left 50px",
+
+    "top 50% center 60%",
+    "top 50% center 60px",
+    "top 50% bottom 50%",
+    "top 50% bottom 50px",
+    "top 50% top 50%",
+    "top 50% top 50px",
+    "top 50px center 60%",
+    "top 50px center 60px",
+    "top 50px bottom 70%",
+    "top 50px bottom 70px",
+    "top 50px top 50%",
+    "top 50px top 50px",
+
+    "bottom 70% center 60%",
+    "bottom 70% center 60px",
+    "bottom 70% top 50%",
+    "bottom 70% top 50px",
+    "bottom 70% bottom 50%",
+    "bottom 70% bottom 50px",
+    "bottom 70px center 60%",
+    "bottom 70px center 60px",
+    "bottom 70px top 50%",
+    "bottom 70px top 50px",
+    "bottom 70px bottom 50%",
+    "bottom 70px bottom 50px",
+
+    "right 80% center 60%",
+    "right 80% center 60px",
+    "right 80% left 50%",
+    "right 80% left 50px",
+    "right 80% right 85%",
+    "right 80% right 85px",
+    "right 80px center 60%",
+    "right 80px center 60px",
+    "right 80px left 50%",
+    "right 80px left 50px",
+    "right 80px right 85%",
+    "right 80px right 85px"
+];
+
+// valid radii values for circle + ellipse
+// [value, expected_inline, [expected_computed?]]
+var validCircleRadii = [
+    ['', 'at 50% 50%', 'at 50% 50%'],
+    ['50u1', '50u1 at 50% 50%'],
+    ['50%', '50% at 50% 50%'],
+    ['closest-side', 'at 50% 50%'],
+    ['farthest-side', 'farthest-side at 50% 50%']
+]
+var validEllipseRadii = [
+    ['', 'at 50% 50%', 'at 50% 50%'],
+    ['50u1', '50u1 at 50% 50%', '50u1 at 50% 50%'],
+    ['50%', '50% at 50% 50%', '50% at 50% 50%'],
+    ['closest-side', 'at 50% 50%', 'at 50% 50%'],
+    ['farthest-side', 'farthest-side at 50% 50%', 'farthest-side at 50% 50%'],
+    ['50u1 100u1', '50u1 100u1 at 50% 50%'],
+    ['100u1 100px', '100u1 100px at 50% 50%'],
+    ['25% 50%', '25% 50% at 50% 50%'],
+    ['50u1 25%', '50u1 25% at 50% 50%'],
+    ['25% 50u1', '25% 50u1 at 50% 50%'],
+    ['25% closest-side', '25% at 50% 50%'],
+    ['25u1 closest-side', '25u1 at 50% 50%'],
+    ['closest-side 75%', 'closest-side 75% at 50% 50%'],
+    ['closest-side 75u1', 'closest-side 75u1 at 50% 50%'],
+    ['25% farthest-side', '25% farthest-side at 50% 50%'],
+    ['25u1 farthest-side', '25u1 farthest-side at 50% 50%'],
+    ['farthest-side 75%', 'farthest-side 75% at 50% 50%'],
+    ['farthest-side 75u1', 'farthest-side 75u1 at 50% 50%'],
+    ['closest-side closest-side', 'at 50% 50%'],
+    ['farthest-side farthest-side', 'farthest-side farthest-side at 50% 50%'],
+    ['closest-side farthest-side', 'closest-side farthest-side at 50% 50%'],
+    ['farthest-side closest-side', 'farthest-side at 50% 50%']
+]
+
+var validInsets = [
+    ["One arg - u1", "10u1"],
+    ["One arg - u2", "10u2"],
+    ["Two args - u1 u1", "10u1 20u1"],
+    ["Two args - u1 u2", "10u1 20u2"],
+    ["Two args - u2 u1", "10u2 20u1"],
+    ["Two args - u2 u2", "10u2 20u2"],
+    ["Three args - u1 u1 u1", "10u1 20u1 30u1"],
+    ["Three args - u1 u1 u2", "10u1 20u1 30u2"],
+    ["Three args - u1 u2 u1", "10u1 20u2 30u1"],
+    ["Three args - u1 u2 u2 ", "10u1 20u2 30u2"],
+    ["Three args - u2 u1 u1", "10u2 20u1 30u1"],
+    ["Three args - u2 u1 u2 ", "10u2 20u1 30u2"],
+    ["Three args - u2 u2 u1 ", "10u2 20u2 30u1"],
+    ["Three args - u2 u2 u2 ","10u2 20u2 30u2"],
+    ["Four args - u1 u1 u1 u1", "10u1 20u1 30u1 40u1"],
+    ["Four args - u1 u1 u1 u2", "10u1 20u1 30u1 40u2"],
+    ["Four args - u1 u1 u2 u1", "10u1 20u1 30u2 40u1"],
+    ["Four args - u1 u1 u2 u2", "10u1 20u1 30u2 40u2"],
+    ["Four args - u1 u2 u1 u1", "10u1 20u2 30u1 40u1"],
+    ["Four args - u1 u2 u1 u2", "10u1 20u2 30u1 40u2"],
+    ["Four args - u1 u2 u2 u1", "10u1 20u2 30u2 40u1"],
+    ["Four args - u1 u2 u2 u2", "10u1 20u2 30u2 40u2"],
+    ["Four args - u2 u1 u1 u1", "10u2 20u1 30u1 40u1"],
+    ["Four args - u2 u1 u1 u2", "10u2 20u1 30u1 40u2"],
+    ["Four args - u2 u1 u2 u1", "10u2 20u1 30u2 40u1"],
+    ["Four args - u2 u1 u2 u2", "10u2 20u1 30u2 40u2"],
+    ["Four args - u2 u2 u1 u1", "10u2 20u2 30u1 40u1"],
+    ["Four args - u2 u2 u1 u2", "10u2 20u2 30u1 40u2"],
+    ["Four args - u2 u2 u2 u1", "10u2 20u2 30u2 40u1"],
+    ["Four args - u2 u2 u2 u2", "10u2 20u2 30u2 40u2"]
+]
+
+var validPolygons = [
+    ["One vertex - u1 u1", "10u1 20u1"],
+    ["One vertex - u1 u2", "10u1 20u2"],
+    ["Two vertices - u1 u1, u1 u1", "10u1 20u1, 30u1 40u1"],
+    ["Two vertices - u1 u1, u2 u2", "10u1 20u1, 30u2 40u2"],
+    ["Two vertices - u2 u2, u1 u1", "10u2 20u2, 30u1 40u1"],
+    ["Two vertices - u1 u2, u2 u1", "10u1 20u2, 30u2 40u1"],
+    ["Three vertices - u1 u1, u1 u1, u1 u1", "10u1 20u1, 30u1 40u1, 50u1 60u1"],
+    ["Three vertices - u2 u2, u2 u2, u2 u2", "10u2 20u2, 30u2 40u2, 50u2 60u2"],
+    ["Three vertices - u3 u3, u3 u3, u3 u3", "10u3 20u3, 30u3 40u3, 50u3 60u3"],
+    ["Three vertices - u1 u1, u2 u2, u3 u3", "10u1 20u1, 30u2 40u2, 50u3 60u3"],
+    ["Three vertices - u3 u3, u1, u1, u2 u2", "10u3 20u3, 30u1 40u1, 50u2 60u2"],
+]
+
+// [test value, expected property value, expected computed style]
+var calcTestValues = [
+    ["calc(10in)", "calc(10in)", "960px"],
+    ["calc(10in + 20px)", "calc(980px)", "980px"],
+    ["calc(30%)", "calc(30%)", "30%"],
+    ["calc(100%/4)", "calc(25%)", "25%"],
+    ["calc(25%*3)", "calc(75%)", "75%"],
+    // These following two test cases represent an either/or situation in the spec
+    // computed value is always supposed to be, at most, a tuple of a length and a percentage.
+    // the computed value of a ‘calc()’ expression can be represented as either a number or a tuple
+    // of a dimension and a percentage.
+    // http://www.w3.org/TR/css3-values/#calc-notation
+    ["calc(25%*3 - 10in)", "calc(75% - 10in)", ["calc(75% - 960px)", "calc(-960px + 75%)"]],
+    ["calc((12.5%*6 + 10in) / 4)", "calc((75% + 10in) / 4)", ["calc((75% + 960px) / 4)", "calc(240px + 18.75%)"]]
+]
+
+return {
+    testInlineStyle: testInlineStyle,
+    testComputedStyle: testComputedStyle,
+    testShapeMarginInlineStyle: testShapeMarginInlineStyle,
+    testShapeMarginComputedStyle: testShapeMarginComputedStyle,
+    testShapeThresholdInlineStyle: testShapeThresholdInlineStyle,
+    testShapeThresholdComputedStyle: testShapeThresholdComputedStyle,
+    buildTestCases: buildTestCases,
+    buildRadiiTests: buildRadiiTests,
+    buildPositionTests: buildPositionTests,
+    buildInsetTests: buildInsetTests,
+    buildPolygonTests: buildPolygonTests,
+    generateInsetRoundCases: generateInsetRoundCases,
+    buildCalcTests: buildCalcTests,
+    validUnits: validUnits,
+    calcTestValues: calcTestValues,
+    roundResultStr: roundResultStr
+}
+})();