[css-align][css-grid] Overflow alignment value 'true' renamed to 'unsafe'
authorjfernandez@igalia.com <jfernandez@igalia.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 15 Dec 2015 12:11:56 +0000 (12:11 +0000)
committerjfernandez@igalia.com <jfernandez@igalia.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 15 Dec 2015 12:11:56 +0000 (12:11 +0000)
https://bugs.webkit.org/show_bug.cgi?id=152251

Source/WebCore:

Reviewed by Darin Adler.

The 'True' Overflow Alignment keyword is now defined in the Box Alignment
specification as 'Unsafe'.

This patch applies the required changes in the CSS parsing logic, as well
Grid Layout specific codebase, so it complies with the last version of the
spec.

No new tests, no change in functionality.

* css/CSSParser.cpp:
(WebCore::isAlignmentOverflowKeyword):
(WebCore::CSSParser::parseItemPositionOverflowPosition):
* css/CSSPrimitiveValueMappings.h:
(WebCore::CSSPrimitiveValue::CSSPrimitiveValue):
(WebCore::CSSPrimitiveValue::operator OverflowAlignment):
* css/CSSValueKeywords.in:
* rendering/RenderGrid.cpp:
(WebCore::computeOverflowAlignmentOffset):
* rendering/style/RenderStyleConstants.h:

LayoutTests:

The 'True' Overflow Alignment keyword is known now as 'Unsafe', so adapting
layout tests using such keyword.

Reviewed by Darin Adler.

* css3/overwrite-content-alignment-expected.txt:
* css3/overwrite-content-alignment.html:
* css3/overwrite-self-alignment-expected.txt:
* css3/overwrite-self-alignment.html:
* css3/parse-align-content-expected.txt:
* css3/parse-align-content.html:
* css3/parse-align-items-expected.txt:
* css3/parse-align-items.html:
* css3/parse-align-self-expected.txt:
* css3/parse-align-self.html:
* css3/parse-justify-content-expected.txt:
* css3/parse-justify-content.html:
* fast/css-grid-layout/grid-align-justify-overflow.html:
* fast/css-grid-layout/grid-content-alignment-overflow.html:
* fast/css/parse-justify-items-expected.txt:
* fast/css/parse-justify-items.html:
* fast/css/parse-justify-self-expected.txt:
* fast/css/parse-justify-self.html:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@194104 268f45cc-cd09-0410-ab3c-d52691b4dbfc

29 files changed:
LayoutTests/ChangeLog
LayoutTests/css3/overwrite-content-alignment-expected.txt
LayoutTests/css3/overwrite-content-alignment.html
LayoutTests/css3/overwrite-self-alignment-expected.txt
LayoutTests/css3/overwrite-self-alignment.html
LayoutTests/css3/parse-align-content-expected.txt
LayoutTests/css3/parse-align-content.html
LayoutTests/css3/parse-align-items-expected.txt
LayoutTests/css3/parse-align-items.html
LayoutTests/css3/parse-align-self-expected.txt
LayoutTests/css3/parse-align-self.html
LayoutTests/css3/parse-justify-content-expected.txt
LayoutTests/css3/parse-justify-content.html
LayoutTests/fast/css-grid-layout/grid-align-justify-overflow.html
LayoutTests/fast/css-grid-layout/grid-content-alignment-overflow.html
LayoutTests/fast/css/parse-justify-items-expected.txt
LayoutTests/fast/css/parse-justify-items.html
LayoutTests/fast/css/parse-justify-self-expected.txt
LayoutTests/fast/css/parse-justify-self.html
LayoutTests/fast/repaint/align-items-overflow-change.html
LayoutTests/fast/repaint/align-self-overflow-change.html
LayoutTests/fast/repaint/justify-items-overflow-change.html
LayoutTests/fast/repaint/justify-self-overflow-change.html
Source/WebCore/ChangeLog
Source/WebCore/css/CSSParser.cpp
Source/WebCore/css/CSSPrimitiveValueMappings.h
Source/WebCore/css/CSSValueKeywords.in
Source/WebCore/rendering/RenderGrid.cpp
Source/WebCore/rendering/style/RenderStyleConstants.h

index f9a1f81..9c43e85 100644 (file)
@@ -1,3 +1,32 @@
+2015-12-15  Javier Fernandez  <jfernandez@igalia.com>
+
+        [css-align][css-grid] Overflow alignment value 'true' renamed to 'unsafe'
+        https://bugs.webkit.org/show_bug.cgi?id=152251
+
+        The 'True' Overflow Alignment keyword is known now as 'Unsafe', so adapting
+        layout tests using such keyword.
+
+        Reviewed by Darin Adler.
+
+        * css3/overwrite-content-alignment-expected.txt:
+        * css3/overwrite-content-alignment.html:
+        * css3/overwrite-self-alignment-expected.txt:
+        * css3/overwrite-self-alignment.html:
+        * css3/parse-align-content-expected.txt:
+        * css3/parse-align-content.html:
+        * css3/parse-align-items-expected.txt:
+        * css3/parse-align-items.html:
+        * css3/parse-align-self-expected.txt:
+        * css3/parse-align-self.html:
+        * css3/parse-justify-content-expected.txt:
+        * css3/parse-justify-content.html:
+        * fast/css-grid-layout/grid-align-justify-overflow.html:
+        * fast/css-grid-layout/grid-content-alignment-overflow.html:
+        * fast/css/parse-justify-items-expected.txt:
+        * fast/css/parse-justify-items.html:
+        * fast/css/parse-justify-self-expected.txt:
+        * fast/css/parse-justify-self.html:
+
 2015-12-14  Ryan Haddad  <ryanhaddad@apple.com>
 
         Re-enabling passing test fast/viewport/ios/width-is-device-width.html, which was accidentally skipped with r194058.
index fdf77de..5c8d074 100644 (file)
@@ -3,7 +3,7 @@ Test overwriting justify-content and align-content works as expected
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
 
-PASS getComputedStyle(childOfDefaultParent, '').getPropertyValue('justify-content') is "flex-end true"
+PASS getComputedStyle(childOfDefaultParent, '').getPropertyValue('justify-content') is "flex-end unsafe"
 PASS getComputedStyle(childOfDefaultParent, '').getPropertyValue('align-content') is "center safe"
 PASS getComputedStyle(childOfParentId, '').getPropertyValue('justify-content') is "space-between"
 PASS getComputedStyle(childOfParentId, '').getPropertyValue('align-content') is "space-around"
index 3c33c2c..40f8743 100644 (file)
@@ -5,7 +5,7 @@
 }
 .parent .child {
    display: -webkit-flex;
-   justify-content: flex-end true;
+   justify-content: flex-end unsafe;
    align-content: center safe;
 }
 #parentId .child {
@@ -25,7 +25,7 @@
 description('Test overwriting justify-content and align-content works as expected');
 
 var childOfDefaultParent = document.getElementById("childOfDefaultParent");
-shouldBeEqualToString("getComputedStyle(childOfDefaultParent, '').getPropertyValue('justify-content')", "flex-end true");
+shouldBeEqualToString("getComputedStyle(childOfDefaultParent, '').getPropertyValue('justify-content')", "flex-end unsafe");
 shouldBeEqualToString("getComputedStyle(childOfDefaultParent, '').getPropertyValue('align-content')", "center safe");
 
 var childOfParentId = document.getElementById("childOfParentId");
index b10044b..afc5949 100644 (file)
@@ -5,7 +5,7 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 PASS getComputedStyle(parent, '').getPropertyValue('justify-items') is "center"
 PASS getComputedStyle(parent, '').getPropertyValue('align-items') is "stretch"
-PASS getComputedStyle(childOfDefaultParent, '').getPropertyValue('justify-self') is "flex-end true"
+PASS getComputedStyle(childOfDefaultParent, '').getPropertyValue('justify-self') is "flex-end unsafe"
 PASS getComputedStyle(childOfDefaultParent, '').getPropertyValue('align-self') is "flex-start safe"
 PASS getComputedStyle(childOfParentId, '').getPropertyValue('justify-self') is "center"
 PASS getComputedStyle(childOfParentId, '').getPropertyValue('align-self') is "stretch"
index 42f9ad8..a5baf3d 100644 (file)
@@ -2,12 +2,12 @@
 <style>
 .parent {
    display: -webkit-flex;
-   justify-items: flex-end true;
+   justify-items: flex-end unsafe;
    align-items: flex-start safe;
 }
 .parent .child {
    display: -webkit-flex;
-   justify-self: flex-end true;
+   justify-self: flex-end unsafe;
    align-self: flex-start safe;
 }
 #parentId {
@@ -35,7 +35,7 @@ shouldBeEqualToString("getComputedStyle(parent, '').getPropertyValue('justify-it
 shouldBeEqualToString("getComputedStyle(parent, '').getPropertyValue('align-items')", "stretch");
 
 var childOfDefaultParent = document.getElementById("childOfDefaultParent");
-shouldBeEqualToString("getComputedStyle(childOfDefaultParent, '').getPropertyValue('justify-self')", "flex-end true");
+shouldBeEqualToString("getComputedStyle(childOfDefaultParent, '').getPropertyValue('justify-self')", "flex-end unsafe");
 shouldBeEqualToString("getComputedStyle(childOfDefaultParent, '').getPropertyValue('align-self')", "flex-start safe");
 
 var childOfParentId = document.getElementById("childOfParentId");
index 6eeddbb..f33935b 100644 (file)
@@ -18,22 +18,22 @@ PASS getComputedStyle(alignContentLeft, '').getPropertyValue('align-content') is
 PASS getComputedStyle(alignContentRight, '').getPropertyValue('align-content') is "right"
 PASS getComputedStyle(alignContentFlexStart, '').getPropertyValue('align-content') is "flex-start"
 PASS getComputedStyle(alignContentFlexEnd, '').getPropertyValue('align-content') is "flex-end"
-PASS getComputedStyle(alignContentEndTrue, '').getPropertyValue('align-content') is "end true"
-PASS getComputedStyle(alignContentCenterTrue, '').getPropertyValue('align-content') is "center true"
+PASS getComputedStyle(alignContentEndUnsafe, '').getPropertyValue('align-content') is "end unsafe"
+PASS getComputedStyle(alignContentCenterUnsafe, '').getPropertyValue('align-content') is "center unsafe"
 PASS getComputedStyle(alignContentRightSafe, '').getPropertyValue('align-content') is "right safe"
-PASS getComputedStyle(alignContentLeftTrue, '').getPropertyValue('align-content') is "left true"
-PASS getComputedStyle(alignContentFlexStartTrue, '').getPropertyValue('align-content') is "flex-start true"
+PASS getComputedStyle(alignContentLeftUnsafe, '').getPropertyValue('align-content') is "left unsafe"
+PASS getComputedStyle(alignContentFlexStartUnsafe, '').getPropertyValue('align-content') is "flex-start unsafe"
 PASS getComputedStyle(alignContentFlexEndSafe, '').getPropertyValue('align-content') is "flex-end safe"
 PASS getComputedStyle(alignContentSpaceBetweenLeft, '').getPropertyValue('align-content') is "space-between left"
 PASS getComputedStyle(alignContentSpaceAroundCenter, '').getPropertyValue('align-content') is "space-around center"
 PASS getComputedStyle(alignContentSpaceEvenlyRight, '').getPropertyValue('align-content') is "space-evenly right"
 PASS getComputedStyle(alignContentStretchStartSafe, '').getPropertyValue('align-content') is "stretch start safe"
-PASS getComputedStyle(alignContentSpaceAroundEndTrue, '').getPropertyValue('align-content') is "space-around end true"
+PASS getComputedStyle(alignContentSpaceAroundEndUnsafe, '').getPropertyValue('align-content') is "space-around end unsafe"
 PASS getComputedStyle(alignContentSpaceEvenlyFlexStartSafe, '').getPropertyValue('align-content') is "space-evenly flex-start safe"
 PASS getComputedStyle(alignContentSpaceBetweenSafe, '').getPropertyValue('align-content') is "start"
 PASS getComputedStyle(alignContentSpaceBetweenStretch, '').getPropertyValue('align-content') is "start"
 PASS getComputedStyle(alignContentSafe, '').getPropertyValue('align-content') is "start"
-PASS getComputedStyle(alignContentRightSafeTrue, '').getPropertyValue('align-content') is "start"
+PASS getComputedStyle(alignContentRightSafeUnsafe, '').getPropertyValue('align-content') is "start"
 PASS getComputedStyle(alignContentCenterLeft, '').getPropertyValue('align-content') is "start"
 
 Test initial value of align-content through JS
@@ -42,16 +42,16 @@ PASS getComputedStyle(element, '').getPropertyValue('align-content') is "start"
 Test getting and setting align-content through JS
 PASS element.style.alignContent is "center"
 PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "center"
-PASS element.style.alignContent is "start true"
-PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "start true"
+PASS element.style.alignContent is "start unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "start unsafe"
 PASS element.style.alignContent is "flex-end safe"
 PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "flex-end safe"
 PASS element.style.alignContent is "space-between right safe"
 PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "space-between right safe"
 PASS element.style.alignContent is "stretch center"
 PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "stretch center"
-PASS element.style.alignContent is "right true"
-PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "right true"
+PASS element.style.alignContent is "right unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "right unsafe"
 PASS element.style.alignContent is "auto"
 PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "start"
 PASS element.style.alignContent is "auto"
@@ -118,8 +118,8 @@ PASS element.style.alignContent is "initial"
 PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "start"
 
 Test the value 'initial' for flex containers
-PASS element.style.alignContent is "right true"
-PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "right true"
+PASS element.style.alignContent is "right unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "right unsafe"
 PASS element.style.alignContent is "initial"
 PASS window.getComputedStyle(element, '').getPropertyValue('align-content') is "stretch"
 
index b06207c..ea7d24d 100644 (file)
     align-content: flex-end;
 }
 
-#alignContentEndTrue {
-    align-content: end true;
+#alignContentEndUnsafe {
+    align-content: end unsafe;
 }
 
-#alignContentCenterTrue {
-    align-content: center true;
+#alignContentCenterUnsafe {
+    align-content: center unsafe;
 }
 
 #alignContentRightSafe {
     align-content: right safe;
 }
 
-#alignContentLeftTrue {
-    align-content: left true;
+#alignContentLeftUnsafe {
+    align-content: left unsafe;
 }
 
-#alignContentFlexStartTrue {
-    align-content: flex-start true;
+#alignContentFlexStartUnsafe {
+    align-content: flex-start unsafe;
 }
 
 #alignContentFlexEndSafe {
@@ -98,8 +98,8 @@
     align-content: stretch start safe;
 }
 
-#alignContentSpaceAroundEndTrue {
-    align-content: space-around end true;
+#alignContentSpaceAroundEndUnsafe {
+    align-content: space-around end unsafe;
 }
 
 #alignContentSpaceEvenlyFlexStartSafe {
     align-content: safe;
 }
 
-#alignContentRightSafeTrue {
-    align-content: right safe true;
+#alignContentRightSafeUnsafe {
+    align-content: right safe unsafe;
 }
 
 #alignContentCenterLeft {
 <div id="alignContentSpaceEvenly"></div>
 <div id="alignContentStretch"></div>
 <div id="alignContentSpaceBetweenSafe"></div>
-<div id="alignContentSpaceAroundTrue"></div>
-<div id="alignContentStretchTrue"></div>
+<div id="alignContentSpaceAroundUnsafe"></div>
+<div id="alignContentStretchUnsafe"></div>
 <div id="alignContentStretchrue"></div>
 <div id="alignContentStart"></div>
 <div id="alignContentEnd"></div>
 <div id="alignContentRight"></div>
 <div id="alignContentFlexStart"></div>
 <div id="alignContentFlexEnd"></div>
-<div id="alignContentEndTrue"></div>
-<div id="alignContentCenterTrue"></div>
+<div id="alignContentEndUnsafe"></div>
+<div id="alignContentCenterUnsafe"></div>
 <div id="alignContentRightSafe"></div>
-<div id="alignContentLeftTrue"></div>
-<div id="alignContentFlexStartTrue"></div>
+<div id="alignContentLeftUnsafe"></div>
+<div id="alignContentFlexStartUnsafe"></div>
 <div id="alignContentFlexEndSafe"></div>
 <div id="alignContentSpaceBetweenLeft"></div>
 <div id="alignContentSpaceAroundCenter"></div>
 <div id="alignContentSpaceEvenlyRight"></div>
 <div id="alignContentStretchStartSafe"></div>
-<div id="alignContentSpaceAroundEndTrue"></div>
+<div id="alignContentSpaceAroundEndUnsafe"></div>
 <div id="alignContentSpaceEvenlyFlexStartSafe"></div>
 
 <div id="alignContentSpaceBetweenSafe"></div>
 <div id="alignContentSpaceBetweenStretch"></div>
 <div id="alignContentSafe"></div>
-<div id="alignContentRightSafeTrue"></div>
+<div id="alignContentRightSafeUnsafe"></div>
 <div id="alignContentCenterLeft"></div>
 
 <script src="resources/alignment-parsing-utils.js"></script>
@@ -214,20 +214,20 @@ shouldBeEqualToString("getComputedStyle(alignContentFlexStart, '').getPropertyVa
 var alignContentFlexEnd = document.getElementById("alignContentFlexEnd");
 shouldBeEqualToString("getComputedStyle(alignContentFlexEnd, '').getPropertyValue('align-content')", "flex-end");
 
-var alignContentEndTrue = document.getElementById("alignContentEndTrue");
-shouldBeEqualToString("getComputedStyle(alignContentEndTrue, '').getPropertyValue('align-content')", "end true");
+var alignContentEndUnsafe = document.getElementById("alignContentEndUnsafe");
+shouldBeEqualToString("getComputedStyle(alignContentEndUnsafe, '').getPropertyValue('align-content')", "end unsafe");
 
-var alignContentCenterTrue = document.getElementById("alignContentCenterTrue");
-shouldBeEqualToString("getComputedStyle(alignContentCenterTrue, '').getPropertyValue('align-content')", "center true");
+var alignContentCenterUnsafe = document.getElementById("alignContentCenterUnsafe");
+shouldBeEqualToString("getComputedStyle(alignContentCenterUnsafe, '').getPropertyValue('align-content')", "center unsafe");
 
 var alignContentRightSafe = document.getElementById("alignContentRightSafe");
 shouldBeEqualToString("getComputedStyle(alignContentRightSafe, '').getPropertyValue('align-content')", "right safe");
 
-var alignContentLeftTrue = document.getElementById("alignContentLeftTrue");
-shouldBeEqualToString("getComputedStyle(alignContentLeftTrue, '').getPropertyValue('align-content')", "left true");
+var alignContentLeftUnsafe = document.getElementById("alignContentLeftUnsafe");
+shouldBeEqualToString("getComputedStyle(alignContentLeftUnsafe, '').getPropertyValue('align-content')", "left unsafe");
 
-var alignContentFlexStartTrue = document.getElementById("alignContentFlexStartTrue");
-shouldBeEqualToString("getComputedStyle(alignContentFlexStartTrue, '').getPropertyValue('align-content')", "flex-start true");
+var alignContentFlexStartUnsafe = document.getElementById("alignContentFlexStartUnsafe");
+shouldBeEqualToString("getComputedStyle(alignContentFlexStartUnsafe, '').getPropertyValue('align-content')", "flex-start unsafe");
 
 var alignContentFlexEndSafe = document.getElementById("alignContentFlexEndSafe");
 shouldBeEqualToString("getComputedStyle(alignContentFlexEndSafe, '').getPropertyValue('align-content')", "flex-end safe");
@@ -244,8 +244,8 @@ shouldBeEqualToString("getComputedStyle(alignContentSpaceEvenlyRight, '').getPro
 var alignContentStretchStartSafe = document.getElementById("alignContentStretchStartSafe");
 shouldBeEqualToString("getComputedStyle(alignContentStretchStartSafe, '').getPropertyValue('align-content')", "stretch start safe");
 
-var alignContentSpaceAroundEndTrue = document.getElementById("alignContentSpaceAroundEndTrue");
-shouldBeEqualToString("getComputedStyle(alignContentSpaceAroundEndTrue, '').getPropertyValue('align-content')", "space-around end true");
+var alignContentSpaceAroundEndUnsafe = document.getElementById("alignContentSpaceAroundEndUnsafe");
+shouldBeEqualToString("getComputedStyle(alignContentSpaceAroundEndUnsafe, '').getPropertyValue('align-content')", "space-around end unsafe");
 
 var alignContentSpaceEvenlyFlexStartSafe = document.getElementById("alignContentSpaceEvenlyFlexStartSafe");
 shouldBeEqualToString("getComputedStyle(alignContentSpaceEvenlyFlexStartSafe, '').getPropertyValue('align-content')", "space-evenly flex-start safe");
@@ -253,16 +253,16 @@ shouldBeEqualToString("getComputedStyle(alignContentSpaceEvenlyFlexStartSafe, ''
 var alignContentSpaceBetweenSafe = document.getElementById("alignContentSpaceBetweenSafe");
 shouldBeEqualToString("getComputedStyle(alignContentSpaceBetweenSafe, '').getPropertyValue('align-content')", "start");
 
-var alignContentSpaceAroundTrue = document.getElementById("alignContentSpaceBetweenStretch");
+var alignContentSpaceAroundUnsafe = document.getElementById("alignContentSpaceBetweenStretch");
 shouldBeEqualToString("getComputedStyle(alignContentSpaceBetweenStretch, '').getPropertyValue('align-content')", "start");
 
-var alignContentSpaceAroundTrue = document.getElementById("alignContentSafe");
+var alignContentSpaceAroundUnsafe = document.getElementById("alignContentSafe");
 shouldBeEqualToString("getComputedStyle(alignContentSafe, '').getPropertyValue('align-content')", "start");
 
-var alignContentSpaceAroundTrue = document.getElementById("alignContentRightSafeTrue");
-shouldBeEqualToString("getComputedStyle(alignContentRightSafeTrue, '').getPropertyValue('align-content')", "start");
+var alignContentSpaceAroundUnsafe = document.getElementById("alignContentRightSafeUnsafe");
+shouldBeEqualToString("getComputedStyle(alignContentRightSafeUnsafe, '').getPropertyValue('align-content')", "start");
 
-var alignContentSpaceAroundTrue = document.getElementById("alignContentCenterLeft");
+var alignContentSpaceAroundUnsafe = document.getElementById("alignContentCenterLeft");
 shouldBeEqualToString("getComputedStyle(alignContentCenterLeft, '').getPropertyValue('align-content')", "start");
 
 debug("");
@@ -278,8 +278,8 @@ document.body.appendChild(element);
 element.style.alignContent = "center";
 checkValues(element, "alignContent", "align-content",  "center", "center");
 
-element.style.alignContent = "true start";
-checkValues(element, "alignContent", "align-content",  "start true", "start true");
+element.style.alignContent = "unsafe start";
+checkValues(element, "alignContent", "align-content",  "start unsafe", "start unsafe");
 
 element.style.alignContent = "flex-end safe";
 checkValues(element, "alignContent", "align-content",  "flex-end safe", "flex-end safe");
@@ -290,8 +290,8 @@ checkValues(element, "alignContent", "align-content",  "space-between right safe
 element.style.alignContent = "stretch center";
 checkValues(element, "alignContent", "align-content",  "stretch center", "stretch center");
 
-element.style.alignContent = "right true";
-checkValues(element, "alignContent", "align-content",  "right true", "right true");
+element.style.alignContent = "right unsafe";
+checkValues(element, "alignContent", "align-content",  "right unsafe", "right unsafe");
 
 element.style.alignContent = "auto";
 checkValues(element, "alignContent", "align-content",  "auto", "start");
@@ -313,25 +313,25 @@ element = document.createElement("div");
 document.body.appendChild(element);
 
 checkBadValues(element, "alignContent", "align-content",  "");
-checkBadValues(element, "alignContent", "align-content",  "true auto");
+checkBadValues(element, "alignContent", "align-content",  "unsafe auto");
 checkBadValues(element, "alignContent", "align-content",  "auto safe");
 checkBadValues(element, "alignContent", "align-content",  "auto left");
 checkBadValues(element, "alignContent", "align-content",  "baseline safe");
 checkBadValues(element, "alignContent", "align-content",  "last baseline center");
-checkBadValues(element, "alignContent", "align-content",  "true true");
-checkBadValues(element, "alignContent", "align-content",  "true safe");
+checkBadValues(element, "alignContent", "align-content",  "unsafe unsafe");
+checkBadValues(element, "alignContent", "align-content",  "unsafe safe");
 checkBadValues(element, "alignContent", "align-content",  "center start");
 checkBadValues(element, "alignContent", "align-content",  "baseline safe");
-checkBadValues(element, "alignContent", "align-content",  "true baseline");
-checkBadValues(element, "alignContent", "align-content",  "true safe left");
-checkBadValues(element, "alignContent", "align-content",  "true left safe");
-checkBadValues(element, "alignContent", "align-content",  "left safe true safe");
+checkBadValues(element, "alignContent", "align-content",  "unsafe baseline");
+checkBadValues(element, "alignContent", "align-content",  "unsafe safe left");
+checkBadValues(element, "alignContent", "align-content",  "unsafe left safe");
+checkBadValues(element, "alignContent", "align-content",  "left safe unsafe safe");
 checkBadValues(element, "alignContent", "align-content",  "start right space-between");
 checkBadValues(element, "alignContent", "align-content",  "safe stretch");
 checkBadValues(element, "alignContent", "align-content",  "space-around stretch");
 checkBadValues(element, "alignContent", "align-content",  "end space-between start");
 checkBadValues(element, "alignContent", "align-content",  "right safe left");
-checkBadValues(element, "alignContent", "align-content",  "true");
+checkBadValues(element, "alignContent", "align-content",  "unsafe");
 checkBadValues(element, "alignContent", "align-content",  "safe");
 
 debug("");
@@ -347,7 +347,7 @@ checkInitialValues(element, "alignContent", "align-content", "space-between left
 debug("");
 debug("Test the value 'initial' for flex containers");
 element.style.display = "-webkit-flex";
-checkInitialValues(element, "alignContent", "align-content", "right true", "stretch");
+checkInitialValues(element, "alignContent", "align-content", "right unsafe", "stretch");
 
 debug("");
 debug("Test the value 'inherit'");
index d5ed30e..27366f7 100644 (file)
@@ -16,13 +16,13 @@ PASS getComputedStyle(alignItemsLeft, '').getPropertyValue('-webkit-align-items'
 PASS getComputedStyle(alignItemsRight, '').getPropertyValue('-webkit-align-items') is 'right'
 PASS getComputedStyle(alignItemsFlexStart, '').getPropertyValue('-webkit-align-items') is 'flex-start'
 PASS getComputedStyle(alignItemsFlexEnd, '').getPropertyValue('-webkit-align-items') is 'flex-end'
-PASS getComputedStyle(alignItemsEndTrue, '').getPropertyValue('-webkit-align-items') is 'end true'
-PASS getComputedStyle(alignItemsCenterTrue, '').getPropertyValue('-webkit-align-items') is 'center true'
+PASS getComputedStyle(alignItemsEndUnsafe, '').getPropertyValue('-webkit-align-items') is 'end unsafe'
+PASS getComputedStyle(alignItemsCenterUnsafe, '').getPropertyValue('-webkit-align-items') is 'center unsafe'
 PASS getComputedStyle(alignItemsSelfEndSafe, '').getPropertyValue('-webkit-align-items') is 'self-end safe'
 PASS getComputedStyle(alignItemsSelfStartSafe, '').getPropertyValue('-webkit-align-items') is 'self-start safe'
 PASS getComputedStyle(alignItemsRightSafe, '').getPropertyValue('-webkit-align-items') is 'right safe'
-PASS getComputedStyle(alignItemsLeftTrue, '').getPropertyValue('-webkit-align-items') is 'left true'
-PASS getComputedStyle(alignItemsFlexStartTrue, '').getPropertyValue('-webkit-align-items') is 'flex-start true'
+PASS getComputedStyle(alignItemsLeftUnsafe, '').getPropertyValue('-webkit-align-items') is 'left unsafe'
+PASS getComputedStyle(alignItemsFlexStartUnsafe, '').getPropertyValue('-webkit-align-items') is 'flex-start unsafe'
 PASS getComputedStyle(alignItemsFlexEndSafe, '').getPropertyValue('-webkit-align-items') is 'flex-end safe'
 
 Test initial value of align-items through JS
@@ -31,8 +31,8 @@ PASS getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is 's
 Test getting and setting align-items through JS
 PASS element.style.webkitAlignItems is "center"
 PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center"
-PASS element.style.webkitAlignItems is "start true"
-PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start true"
+PASS element.style.webkitAlignItems is "start unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start unsafe"
 PASS element.style.webkitAlignItems is "flex-end safe"
 PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "flex-end safe"
 PASS element.style.webkitAlignItems is "right"
@@ -113,8 +113,8 @@ PASS element.style.webkitAlignItems is "initial"
 PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "stretch"
 
 Test the value 'initial' for flex containers
-PASS element.style.webkitAlignItems is "right true"
-PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "right true"
+PASS element.style.webkitAlignItems is "right unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "right unsafe"
 PASS element.style.webkitAlignItems is "initial"
 PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "stretch"
 
@@ -127,10 +127,10 @@ PASS element.style.webkitAlignItems is "left safe"
 PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "left safe"
 PASS element.style.webkitAlignItems is "inherit"
 PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "left safe"
-PASS element.style.webkitAlignItems is "center true"
-PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center true"
+PASS element.style.webkitAlignItems is "center unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center unsafe"
 PASS element.style.webkitAlignItems is "inherit"
-PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center true"
+PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center unsafe"
 PASS successfullyParsed is true
 
 TEST COMPLETE
index d6f1dab..ea8c7b1 100644 (file)
     -webkit-align-items: flex-end;
 }
 
-#alignItemsEndTrue {
-    -webkit-align-items: end true;
+#alignItemsEndUnsafe {
+    -webkit-align-items: end unsafe;
 }
 
-#alignItemsCenterTrue {
-    -webkit-align-items: center true;
+#alignItemsCenterUnsafe {
+    -webkit-align-items: center unsafe;
 }
 
 #alignItemsSelfEndSafe {
     -webkit-align-items: right safe;
 }
 
-#alignItemsLeftTrue {
-    -webkit-align-items: left true;
+#alignItemsLeftUnsafe {
+    -webkit-align-items: left unsafe;
 }
 
-#alignItemsFlexStartTrue {
-    -webkit-align-items: flex-start true;
+#alignItemsFlexStartUnsafe {
+    -webkit-align-items: flex-start unsafe;
 }
 
 #alignItemsFlexEndSafe {
 <div id="alignItemsFlexStart"></div>
 <div id="alignItemsFlexEnd"></div>
 
-<div id="alignItemsEndTrue"></div>
-<div id="alignItemsCenterTrue"></div>
+<div id="alignItemsEndUnsafe"></div>
+<div id="alignItemsCenterUnsafe"></div>
 <div id="alignItemsSelfEndSafe"></div>
 <div id="alignItemsSelfStartSafe"></div>
 <div id="alignItemsRightSafe"></div>
-<div id="alignItemsLeftTrue"></div>
-<div id="alignItemsFlexStartTrue"></div>
+<div id="alignItemsLeftUnsafe"></div>
+<div id="alignItemsFlexStartUnsafe"></div>
 <div id="alignItemsFlexEndSafe"></div>
 <script src="resources/alignment-parsing-utils.js"></script>
 <script>
@@ -148,11 +148,11 @@ shouldBe("getComputedStyle(alignItemsFlexStart, '').getPropertyValue('-webkit-al
 var alignItemsFlexEnd = document.getElementById("alignItemsFlexEnd");
 shouldBe("getComputedStyle(alignItemsFlexEnd, '').getPropertyValue('-webkit-align-items')", "'flex-end'");
 
-var alignItemsEndTrue = document.getElementById("alignItemsEndTrue");
-shouldBe("getComputedStyle(alignItemsEndTrue, '').getPropertyValue('-webkit-align-items')", "'end true'");
+var alignItemsEndUnsafe = document.getElementById("alignItemsEndUnsafe");
+shouldBe("getComputedStyle(alignItemsEndUnsafe, '').getPropertyValue('-webkit-align-items')", "'end unsafe'");
 
-var alignItemsCenterTrue = document.getElementById("alignItemsCenterTrue");
-shouldBe("getComputedStyle(alignItemsCenterTrue, '').getPropertyValue('-webkit-align-items')", "'center true'");
+var alignItemsCenterUnsafe = document.getElementById("alignItemsCenterUnsafe");
+shouldBe("getComputedStyle(alignItemsCenterUnsafe, '').getPropertyValue('-webkit-align-items')", "'center unsafe'");
 
 var alignItemsSelfEndSafe = document.getElementById("alignItemsSelfEndSafe");
 shouldBe("getComputedStyle(alignItemsSelfEndSafe, '').getPropertyValue('-webkit-align-items')", "'self-end safe'");
@@ -163,11 +163,11 @@ shouldBe("getComputedStyle(alignItemsSelfStartSafe, '').getPropertyValue('-webki
 var alignItemsRightSafe = document.getElementById("alignItemsRightSafe");
 shouldBe("getComputedStyle(alignItemsRightSafe, '').getPropertyValue('-webkit-align-items')", "'right safe'");
 
-var alignItemsLeftTrue = document.getElementById("alignItemsLeftTrue");
-shouldBe("getComputedStyle(alignItemsLeftTrue, '').getPropertyValue('-webkit-align-items')", "'left true'");
+var alignItemsLeftUnsafe = document.getElementById("alignItemsLeftUnsafe");
+shouldBe("getComputedStyle(alignItemsLeftUnsafe, '').getPropertyValue('-webkit-align-items')", "'left unsafe'");
 
-var alignItemsFlexStartTrue = document.getElementById("alignItemsFlexStartTrue");
-shouldBe("getComputedStyle(alignItemsFlexStartTrue, '').getPropertyValue('-webkit-align-items')", "'flex-start true'");
+var alignItemsFlexStartUnsafe = document.getElementById("alignItemsFlexStartUnsafe");
+shouldBe("getComputedStyle(alignItemsFlexStartUnsafe, '').getPropertyValue('-webkit-align-items')", "'flex-start unsafe'");
 
 var alignItemsFlexEndSafe = document.getElementById("alignItemsFlexEndSafe");
 shouldBe("getComputedStyle(alignItemsFlexEndSafe, '').getPropertyValue('-webkit-align-items')", "'flex-end safe'");
@@ -185,8 +185,8 @@ document.body.appendChild(element);
 element.style.webkitAlignItems = "center";
 checkValues(element, "webkitAlignItems", "-webkit-align-items",  "center", "center");
 
-element.style.webkitAlignItems = "true start";
-checkValues(element, "webkitAlignItems", "-webkit-align-items",  "start true", "start true");
+element.style.webkitAlignItems = "unsafe start";
+checkValues(element, "webkitAlignItems", "-webkit-align-items",  "start unsafe", "start unsafe");
 
 element.style.webkitAlignItems = "flex-end safe";
 checkValues(element, "webkitAlignItems", "-webkit-align-items",  "flex-end safe", "flex-end safe");
@@ -219,26 +219,26 @@ debug("Test bad combinations of align-items");
 element = document.createElement("div");
 document.body.appendChild(element);
 
-checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "true auto");
+checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "unsafe auto");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "auto safe");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "auto left");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "baseline safe");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "baseline center");
-checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "stretch true");
+checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "stretch unsafe");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "stretch right");
-checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "true true");
-checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "true safe");
+checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "unsafe unsafe");
+checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "unsafe safe");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "center start");
-checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "stretch true");
+checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "stretch unsafe");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "safe stretch");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "baseline safe");
-checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "true baseline");
-checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "true safe left");
-checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "true left safe");
-checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "left safe true safe");
+checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "unsafe baseline");
+checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "unsafe safe left");
+checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "unsafe left safe");
+checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "left safe unsafe safe");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy start");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy end");
-checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy right true");
+checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy right unsafe");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy auto");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy stretch");
 checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy");
@@ -257,13 +257,13 @@ checkInitialValues(element, "webkitAlignItems", "-webkit-align-items", "left saf
 debug("");
 debug("Test the value 'initial' for flex containers");
 element.style.display = "-webkit-flex";
-checkInitialValues(element, "webkitAlignItems", "-webkit-align-items", "right true", "stretch");
+checkInitialValues(element, "webkitAlignItems", "-webkit-align-items", "right unsafe", "stretch");
 
 debug("");
 debug("Test the value 'inherit'");
 checkInheritValues("webkitAlignItems", "-webkit-align-items", "end");
 checkInheritValues("webkitAlignItems", "-webkit-align-items", "left safe");
-checkInheritValues("webkitAlignItems", "-webkit-align-items", "center true");
+checkInheritValues("webkitAlignItems", "-webkit-align-items", "center unsafe");
 
 </script>
 </body>
index 5b98135..fd52471 100644 (file)
@@ -16,13 +16,13 @@ PASS getComputedStyle(alignSelfLeft, '').getPropertyValue('-webkit-align-self')
 PASS getComputedStyle(alignSelfRight, '').getPropertyValue('-webkit-align-self') is 'right'
 PASS getComputedStyle(alignSelfFlexStart, '').getPropertyValue('-webkit-align-self') is 'flex-start'
 PASS getComputedStyle(alignSelfFlexEnd, '').getPropertyValue('-webkit-align-self') is 'flex-end'
-PASS getComputedStyle(alignSelfEndTrue, '').getPropertyValue('-webkit-align-self') is 'end true'
-PASS getComputedStyle(alignSelfCenterTrue, '').getPropertyValue('-webkit-align-self') is 'center true'
+PASS getComputedStyle(alignSelfEndUnsafe, '').getPropertyValue('-webkit-align-self') is 'end unsafe'
+PASS getComputedStyle(alignSelfCenterUnsafe, '').getPropertyValue('-webkit-align-self') is 'center unsafe'
 PASS getComputedStyle(alignSelfSelfEndSafe, '').getPropertyValue('-webkit-align-self') is 'self-end safe'
 PASS getComputedStyle(alignSelfSelfStartSafe, '').getPropertyValue('-webkit-align-self') is 'self-start safe'
 PASS getComputedStyle(alignSelfRightSafe, '').getPropertyValue('-webkit-align-self') is 'right safe'
-PASS getComputedStyle(alignSelfLeftTrue, '').getPropertyValue('-webkit-align-self') is 'left true'
-PASS getComputedStyle(alignSelfFlexStartTrue, '').getPropertyValue('-webkit-align-self') is 'flex-start true'
+PASS getComputedStyle(alignSelfLeftUnsafe, '').getPropertyValue('-webkit-align-self') is 'left unsafe'
+PASS getComputedStyle(alignSelfFlexStartUnsafe, '').getPropertyValue('-webkit-align-self') is 'flex-start unsafe'
 PASS getComputedStyle(alignSelfFlexEndSafe, '').getPropertyValue('-webkit-align-self') is 'flex-end safe'
 
 Test initial value of align-self through JS
@@ -31,8 +31,8 @@ PASS getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is 'st
 Test getting and setting align-self through JS
 PASS element.style.webkitAlignSelf is "center"
 PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center"
-PASS element.style.webkitAlignSelf is "start true"
-PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start true"
+PASS element.style.webkitAlignSelf is "start unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start unsafe"
 PASS element.style.webkitAlignSelf is "flex-end safe"
 PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "flex-end safe"
 PASS element.style.webkitAlignSelf is "right"
@@ -113,8 +113,8 @@ PASS element.style.webkitAlignSelf is "initial"
 PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"
 
 Test the value 'initial' for flex containers
-PASS element.style.webkitAlignSelf is "right true"
-PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "right true"
+PASS element.style.webkitAlignSelf is "right unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "right unsafe"
 PASS element.style.webkitAlignSelf is "initial"
 PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"
 
@@ -145,10 +145,10 @@ PASS element.style.webkitAlignSelf is "left safe"
 PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "left safe"
 PASS element.style.webkitAlignSelf is "inherit"
 PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "left safe"
-PASS element.style.webkitAlignSelf is "center true"
-PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center true"
+PASS element.style.webkitAlignSelf is "center unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center unsafe"
 PASS element.style.webkitAlignSelf is "inherit"
-PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center true"
+PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center unsafe"
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 6480a68..b06454d 100644 (file)
     -webkit-align-self: flex-end;
 }
 
-#alignSelfEndTrue {
-    -webkit-align-self: end true;
+#alignSelfEndUnsafe {
+    -webkit-align-self: end unsafe;
 }
 
-#alignSelfCenterTrue {
-    -webkit-align-self: center true;
+#alignSelfCenterUnsafe {
+    -webkit-align-self: center unsafe;
 }
 
 #alignSelfSelfEndSafe {
     -webkit-align-self: right safe;
 }
 
-#alignSelfLeftTrue {
-    -webkit-align-self: left true;
+#alignSelfLeftUnsafe {
+    -webkit-align-self: left unsafe;
 }
 
-#alignSelfFlexStartTrue {
-    -webkit-align-self: flex-start true;
+#alignSelfFlexStartUnsafe {
+    -webkit-align-self: flex-start unsafe;
 }
 
 #alignSelfFlexEndSafe {
 <div id="alignSelfFlexStart"></div>
 <div id="alignSelfFlexEnd"></div>
 
-<div id="alignSelfEndTrue"></div>
-<div id="alignSelfCenterTrue"></div>
+<div id="alignSelfEndUnsafe"></div>
+<div id="alignSelfCenterUnsafe"></div>
 <div id="alignSelfSelfEndSafe"></div>
 <div id="alignSelfSelfStartSafe"></div>
 <div id="alignSelfRightSafe"></div>
-<div id="alignSelfLeftTrue"></div>
-<div id="alignSelfFlexStartTrue"></div>
+<div id="alignSelfLeftUnsafe"></div>
+<div id="alignSelfFlexStartUnsafe"></div>
 <div id="alignSelfFlexEndSafe"></div>
 <script src="resources/alignment-parsing-utils.js"></script>
 <script>
@@ -147,11 +147,11 @@ shouldBe("getComputedStyle(alignSelfFlexStart, '').getPropertyValue('-webkit-ali
 var alignSelfFlexEnd = document.getElementById("alignSelfFlexEnd");
 shouldBe("getComputedStyle(alignSelfFlexEnd, '').getPropertyValue('-webkit-align-self')", "'flex-end'");
 
-var alignSelfEndTrue = document.getElementById("alignSelfEndTrue");
-shouldBe("getComputedStyle(alignSelfEndTrue, '').getPropertyValue('-webkit-align-self')", "'end true'");
+var alignSelfEndUnsafe = document.getElementById("alignSelfEndUnsafe");
+shouldBe("getComputedStyle(alignSelfEndUnsafe, '').getPropertyValue('-webkit-align-self')", "'end unsafe'");
 
-var alignSelfCenterTrue = document.getElementById("alignSelfCenterTrue");
-shouldBe("getComputedStyle(alignSelfCenterTrue, '').getPropertyValue('-webkit-align-self')", "'center true'");
+var alignSelfCenterUnsafe = document.getElementById("alignSelfCenterUnsafe");
+shouldBe("getComputedStyle(alignSelfCenterUnsafe, '').getPropertyValue('-webkit-align-self')", "'center unsafe'");
 
 var alignSelfSelfEndSafe = document.getElementById("alignSelfSelfEndSafe");
 shouldBe("getComputedStyle(alignSelfSelfEndSafe, '').getPropertyValue('-webkit-align-self')", "'self-end safe'");
@@ -162,11 +162,11 @@ shouldBe("getComputedStyle(alignSelfSelfStartSafe, '').getPropertyValue('-webkit
 var alignSelfRightSafe = document.getElementById("alignSelfRightSafe");
 shouldBe("getComputedStyle(alignSelfRightSafe, '').getPropertyValue('-webkit-align-self')", "'right safe'");
 
-var alignSelfLeftTrue = document.getElementById("alignSelfLeftTrue");
-shouldBe("getComputedStyle(alignSelfLeftTrue, '').getPropertyValue('-webkit-align-self')", "'left true'");
+var alignSelfLeftUnsafe = document.getElementById("alignSelfLeftUnsafe");
+shouldBe("getComputedStyle(alignSelfLeftUnsafe, '').getPropertyValue('-webkit-align-self')", "'left unsafe'");
 
-var alignSelfFlexStartTrue = document.getElementById("alignSelfFlexStartTrue");
-shouldBe("getComputedStyle(alignSelfFlexStartTrue, '').getPropertyValue('-webkit-align-self')", "'flex-start true'");
+var alignSelfFlexStartUnsafe = document.getElementById("alignSelfFlexStartUnsafe");
+shouldBe("getComputedStyle(alignSelfFlexStartUnsafe, '').getPropertyValue('-webkit-align-self')", "'flex-start unsafe'");
 
 var alignSelfFlexEndSafe = document.getElementById("alignSelfFlexEndSafe");
 shouldBe("getComputedStyle(alignSelfFlexEndSafe, '').getPropertyValue('-webkit-align-self')", "'flex-end safe'");
@@ -186,8 +186,8 @@ document.body.appendChild(container);
 element.style.webkitAlignSelf = "center";
 checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "center", "center");
 
-element.style.webkitAlignSelf = "true start";
-checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "start true", "start true");
+element.style.webkitAlignSelf = "unsafe start";
+checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "start unsafe", "start unsafe");
 
 element.style.webkitAlignSelf = "flex-end safe";
 checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "flex-end safe", "flex-end safe");
@@ -222,26 +222,26 @@ element = document.createElement("div");
 container.appendChild(element);
 document.body.appendChild(container);
 
-checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "true auto");
+checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "unsafe auto");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "auto safe");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "auto left");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "baseline safe");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "baseline center");
-checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "stretch true");
+checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "stretch unsafe");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "stretch right");
-checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "true true");
-checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "true safe");
+checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "unsafe unsafe");
+checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "unsafe safe");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "center start");
-checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "stretch true");
+checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "stretch unsafe");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "safe stretch");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "baseline safe");
-checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "true baseline");
-checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "true safe left");
-checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "true left safe");
-checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "left safe true safe");
+checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "unsafe baseline");
+checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "unsafe safe left");
+checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "unsafe left safe");
+checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "left safe unsafe safe");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy start");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy end");
-checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy right true");
+checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy right unsafe");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy auto");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy stretch");
 checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy");
@@ -260,7 +260,7 @@ checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "left safe"
 debug("");
 debug("Test the value 'initial' for flex containers");
 container.style.display = "-webkit-flex";
-checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "right true", "stretch");
+checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "right unsafe", "stretch");
 
 debug("");
 debug("Test the value 'initial' for positioned elements");
@@ -284,7 +284,7 @@ debug("");
 debug("Test the value 'inherit'");
 checkInheritValues("webkitAlignSelf", "-webkit-align-self", "end");
 checkInheritValues("webkitAlignSelf", "-webkit-align-self", "left safe");
-checkInheritValues("webkitAlignSelf", "-webkit-align-self", "center true");
+checkInheritValues("webkitAlignSelf", "-webkit-align-self", "center unsafe");
 
 </script>
 </body>
index ea6f435..da849fc 100644 (file)
@@ -18,22 +18,22 @@ PASS getComputedStyle(justifyContentLeft, '').getPropertyValue('justify-content'
 PASS getComputedStyle(justifyContentRight, '').getPropertyValue('justify-content') is "right"
 PASS getComputedStyle(justifyContentFlexStart, '').getPropertyValue('justify-content') is "flex-start"
 PASS getComputedStyle(justifyContentFlexEnd, '').getPropertyValue('justify-content') is "flex-end"
-PASS getComputedStyle(justifyContentEndTrue, '').getPropertyValue('justify-content') is "end true"
-PASS getComputedStyle(justifyContentCenterTrue, '').getPropertyValue('justify-content') is "center true"
+PASS getComputedStyle(justifyContentEndUnsafe, '').getPropertyValue('justify-content') is "end unsafe"
+PASS getComputedStyle(justifyContentCenterUnsafe, '').getPropertyValue('justify-content') is "center unsafe"
 PASS getComputedStyle(justifyContentRightSafe, '').getPropertyValue('justify-content') is "right safe"
-PASS getComputedStyle(justifyContentLeftTrue, '').getPropertyValue('justify-content') is "left true"
-PASS getComputedStyle(justifyContentFlexStartTrue, '').getPropertyValue('justify-content') is "flex-start true"
+PASS getComputedStyle(justifyContentLeftUnsafe, '').getPropertyValue('justify-content') is "left unsafe"
+PASS getComputedStyle(justifyContentFlexStartUnsafe, '').getPropertyValue('justify-content') is "flex-start unsafe"
 PASS getComputedStyle(justifyContentFlexEndSafe, '').getPropertyValue('justify-content') is "flex-end safe"
 PASS getComputedStyle(justifyContentSpaceBetweenLeft, '').getPropertyValue('justify-content') is "space-between left"
 PASS getComputedStyle(justifyContentSpaceAroundCenter, '').getPropertyValue('justify-content') is "space-around center"
 PASS getComputedStyle(justifyContentSpaceEvenlyRight, '').getPropertyValue('justify-content') is "space-evenly right"
 PASS getComputedStyle(justifyContentStretchStartSafe, '').getPropertyValue('justify-content') is "stretch start safe"
-PASS getComputedStyle(justifyContentSpaceAroundEndTrue, '').getPropertyValue('justify-content') is "space-around end true"
+PASS getComputedStyle(justifyContentSpaceAroundEndUnsafe, '').getPropertyValue('justify-content') is "space-around end unsafe"
 PASS getComputedStyle(justifyContentSpaceEvenlyFlexStartSafe, '').getPropertyValue('justify-content') is "space-evenly flex-start safe"
 PASS getComputedStyle(justifyContentSpaceBetweenSafe, '').getPropertyValue('justify-content') is "start"
 PASS getComputedStyle(justifyContentSpaceBetweenStretch, '').getPropertyValue('justify-content') is "start"
 PASS getComputedStyle(justifyContentSafe, '').getPropertyValue('justify-content') is "start"
-PASS getComputedStyle(justifyContentRightSafeTrue, '').getPropertyValue('justify-content') is "start"
+PASS getComputedStyle(justifyContentRightSafeUnsafe, '').getPropertyValue('justify-content') is "start"
 PASS getComputedStyle(justifyContentCenterLeft, '').getPropertyValue('justify-content') is "start"
 
 Test initial value of justify-content through JS
@@ -42,16 +42,16 @@ PASS getComputedStyle(element, '').getPropertyValue('justify-content') is "start
 Test getting and setting justify-content through JS
 PASS element.style.justifyContent is "center"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "center"
-PASS element.style.justifyContent is "start true"
-PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "start true"
+PASS element.style.justifyContent is "start unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "start unsafe"
 PASS element.style.justifyContent is "flex-end safe"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "flex-end safe"
 PASS element.style.justifyContent is "space-between right safe"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "space-between right safe"
 PASS element.style.justifyContent is "stretch center"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "stretch center"
-PASS element.style.justifyContent is "right true"
-PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "right true"
+PASS element.style.justifyContent is "right unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "right unsafe"
 PASS element.style.justifyContent is "auto"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "start"
 PASS element.style.justifyContent is "auto"
@@ -118,8 +118,8 @@ PASS element.style.justifyContent is "initial"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "start"
 
 Test the value 'initial' for flex containers
-PASS element.style.justifyContent is "right true"
-PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "right true"
+PASS element.style.justifyContent is "right unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "right unsafe"
 PASS element.style.justifyContent is "initial"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-content') is "stretch"
 
index 4c938c2..1ba5a2b 100644 (file)
     justify-content: flex-end;
 }
 
-#justifyContentEndTrue {
-    justify-content: end true;
+#justifyContentEndUnsafe {
+    justify-content: end unsafe;
 }
 
-#justifyContentCenterTrue {
-    justify-content: center true;
+#justifyContentCenterUnsafe {
+    justify-content: center unsafe;
 }
 
 #justifyContentRightSafe {
     justify-content: right safe;
 }
 
-#justifyContentLeftTrue {
-    justify-content: left true;
+#justifyContentLeftUnsafe {
+    justify-content: left unsafe;
 }
 
-#justifyContentFlexStartTrue {
-    justify-content: flex-start true;
+#justifyContentFlexStartUnsafe {
+    justify-content: flex-start unsafe;
 }
 
 #justifyContentFlexEndSafe {
@@ -98,8 +98,8 @@
     justify-content: stretch start safe;
 }
 
-#justifyContentSpaceAroundEndTrue {
-    justify-content: space-around end true;
+#justifyContentSpaceAroundEndUnsafe {
+    justify-content: space-around end unsafe;
 }
 
 #justifyContentSpaceEvenlyFlexStartSafe {
     justify-content: safe;
 }
 
-#justifyContentRightSafeTrue {
-    justify-content: right safe true;
+#justifyContentRightSafeUnsafe {
+    justify-content: right safe unsafe;
 }
 
 #justifyContentCenterLeft {
 <div id="justifyContentRight"></div>
 <div id="justifyContentFlexStart"></div>
 <div id="justifyContentFlexEnd"></div>
-<div id="justifyContentEndTrue"></div>
-<div id="justifyContentCenterTrue"></div>
+<div id="justifyContentEndUnsafe"></div>
+<div id="justifyContentCenterUnsafe"></div>
 <div id="justifyContentRightSafe"></div>
-<div id="justifyContentLeftTrue"></div>
-<div id="justifyContentFlexStartTrue"></div>
+<div id="justifyContentLeftUnsafe"></div>
+<div id="justifyContentFlexStartUnsafe"></div>
 <div id="justifyContentFlexEndSafe"></div>
 <div id="justifyContentSpaceBetweenLeft"></div>
 <div id="justifyContentSpaceAroundCenter"></div>
 <div id="justifyContentSpaceEvenlyRight"></div>
 <div id="justifyContentStretchStartSafe"></div>
-<div id="justifyContentSpaceAroundEndTrue"></div>
+<div id="justifyContentSpaceAroundEndUnsafe"></div>
 <div id="justifyContentSpaceEvenlyFlexStartSafe"></div>
 
 <div id="justifyContentSpaceBetweenSafe"></div>
 <div id="justifyContentSpaceBetweenStretch"></div>
 <div id="justifyContentSafe"></div>
-<div id="justifyContentRightSafeTrue"></div>
+<div id="justifyContentRightSafeUnsafe"></div>
 <div id="justifyContentCenterLeft"></div>
 
 <script src="resources/alignment-parsing-utils.js"></script>
@@ -210,20 +210,20 @@ shouldBeEqualToString("getComputedStyle(justifyContentFlexStart, '').getProperty
 var justifyContentFlexEnd = document.getElementById("justifyContentFlexEnd");
 shouldBeEqualToString("getComputedStyle(justifyContentFlexEnd, '').getPropertyValue('justify-content')", "flex-end");
 
-var justifyContentEndTrue = document.getElementById("justifyContentEndTrue");
-shouldBeEqualToString("getComputedStyle(justifyContentEndTrue, '').getPropertyValue('justify-content')", "end true");
+var justifyContentEndUnsafe = document.getElementById("justifyContentEndUnsafe");
+shouldBeEqualToString("getComputedStyle(justifyContentEndUnsafe, '').getPropertyValue('justify-content')", "end unsafe");
 
-var justifyContentCenterTrue = document.getElementById("justifyContentCenterTrue");
-shouldBeEqualToString("getComputedStyle(justifyContentCenterTrue, '').getPropertyValue('justify-content')", "center true");
+var justifyContentCenterUnsafe = document.getElementById("justifyContentCenterUnsafe");
+shouldBeEqualToString("getComputedStyle(justifyContentCenterUnsafe, '').getPropertyValue('justify-content')", "center unsafe");
 
 var justifyContentRightSafe = document.getElementById("justifyContentRightSafe");
 shouldBeEqualToString("getComputedStyle(justifyContentRightSafe, '').getPropertyValue('justify-content')", "right safe");
 
-var justifyContentLeftTrue = document.getElementById("justifyContentLeftTrue");
-shouldBeEqualToString("getComputedStyle(justifyContentLeftTrue, '').getPropertyValue('justify-content')", "left true");
+var justifyContentLeftUnsafe = document.getElementById("justifyContentLeftUnsafe");
+shouldBeEqualToString("getComputedStyle(justifyContentLeftUnsafe, '').getPropertyValue('justify-content')", "left unsafe");
 
-var justifyContentFlexStartTrue = document.getElementById("justifyContentFlexStartTrue");
-shouldBeEqualToString("getComputedStyle(justifyContentFlexStartTrue, '').getPropertyValue('justify-content')", "flex-start true");
+var justifyContentFlexStartUnsafe = document.getElementById("justifyContentFlexStartUnsafe");
+shouldBeEqualToString("getComputedStyle(justifyContentFlexStartUnsafe, '').getPropertyValue('justify-content')", "flex-start unsafe");
 
 var justifyContentFlexEndSafe = document.getElementById("justifyContentFlexEndSafe");
 shouldBeEqualToString("getComputedStyle(justifyContentFlexEndSafe, '').getPropertyValue('justify-content')", "flex-end safe");
@@ -240,8 +240,8 @@ shouldBeEqualToString("getComputedStyle(justifyContentSpaceEvenlyRight, '').getP
 var justifyContentStretchStartSafe = document.getElementById("justifyContentStretchStartSafe");
 shouldBeEqualToString("getComputedStyle(justifyContentStretchStartSafe, '').getPropertyValue('justify-content')", "stretch start safe");
 
-var justifyContentSpaceAroundEndTrue = document.getElementById("justifyContentSpaceAroundEndTrue");
-shouldBeEqualToString("getComputedStyle(justifyContentSpaceAroundEndTrue, '').getPropertyValue('justify-content')", "space-around end true");
+var justifyContentSpaceAroundEndUnsafe = document.getElementById("justifyContentSpaceAroundEndUnsafe");
+shouldBeEqualToString("getComputedStyle(justifyContentSpaceAroundEndUnsafe, '').getPropertyValue('justify-content')", "space-around end unsafe");
 
 var justifyContentSpaceEvenlyFlexStartSafe = document.getElementById("justifyContentSpaceEvenlyFlexStartSafe");
 shouldBeEqualToString("getComputedStyle(justifyContentSpaceEvenlyFlexStartSafe, '').getPropertyValue('justify-content')", "space-evenly flex-start safe");
@@ -249,16 +249,16 @@ shouldBeEqualToString("getComputedStyle(justifyContentSpaceEvenlyFlexStartSafe,
 var justifyContentSpaceBetweenSafe = document.getElementById("justifyContentSpaceBetweenSafe");
 shouldBeEqualToString("getComputedStyle(justifyContentSpaceBetweenSafe, '').getPropertyValue('justify-content')", "start");
 
-var justifyContentSpaceAroundTrue = document.getElementById("justifyContentSpaceBetweenStretch");
+var justifyContentSpaceAroundUnsafe = document.getElementById("justifyContentSpaceBetweenStretch");
 shouldBeEqualToString("getComputedStyle(justifyContentSpaceBetweenStretch, '').getPropertyValue('justify-content')", "start");
 
-var justifyContentSpaceAroundTrue = document.getElementById("justifyContentSafe");
+var justifyContentSpaceAroundUnsafe = document.getElementById("justifyContentSafe");
 shouldBeEqualToString("getComputedStyle(justifyContentSafe, '').getPropertyValue('justify-content')", "start");
 
-var justifyContentSpaceAroundTrue = document.getElementById("justifyContentRightSafeTrue");
-shouldBeEqualToString("getComputedStyle(justifyContentRightSafeTrue, '').getPropertyValue('justify-content')", "start");
+var justifyContentSpaceAroundUnsafe = document.getElementById("justifyContentRightSafeUnsafe");
+shouldBeEqualToString("getComputedStyle(justifyContentRightSafeUnsafe, '').getPropertyValue('justify-content')", "start");
 
-var justifyContentSpaceAroundTrue = document.getElementById("justifyContentCenterLeft");
+var justifyContentSpaceAroundUnsafe = document.getElementById("justifyContentCenterLeft");
 shouldBeEqualToString("getComputedStyle(justifyContentCenterLeft, '').getPropertyValue('justify-content')", "start");
 
 debug("");
@@ -274,8 +274,8 @@ document.body.appendChild(element);
 element.style.justifyContent = "center";
 checkValues(element, "justifyContent", "justify-content",  "center", "center");
 
-element.style.justifyContent = "true start";
-checkValues(element, "justifyContent", "justify-content",  "start true", "start true");
+element.style.justifyContent = "unsafe start";
+checkValues(element, "justifyContent", "justify-content",  "start unsafe", "start unsafe");
 
 element.style.justifyContent = "flex-end safe";
 checkValues(element, "justifyContent", "justify-content",  "flex-end safe", "flex-end safe");
@@ -286,8 +286,8 @@ checkValues(element, "justifyContent", "justify-content",  "space-between right
 element.style.justifyContent = "center stretch";
 checkValues(element, "justifyContent", "justify-content",  "stretch center", "stretch center");
 
-element.style.justifyContent = "right true";
-checkValues(element, "justifyContent", "justify-content",  "right true", "right true");
+element.style.justifyContent = "right unsafe";
+checkValues(element, "justifyContent", "justify-content",  "right unsafe", "right unsafe");
 
 element.style.justifyContent = "auto";
 checkValues(element, "justifyContent", "justify-content",  "auto", "start");
@@ -309,25 +309,25 @@ element = document.createElement("div");
 document.body.appendChild(element);
 
 checkBadValues(element, "justifyContent", "justify-content",  "");
-checkBadValues(element, "justifyContent", "justify-content",  "true auto");
+checkBadValues(element, "justifyContent", "justify-content",  "unsafe auto");
 checkBadValues(element, "justifyContent", "justify-content",  "auto safe");
 checkBadValues(element, "justifyContent", "justify-content",  "auto left");
 checkBadValues(element, "justifyContent", "justify-content",  "baseline safe");
 checkBadValues(element, "justifyContent", "justify-content",  "last baseline center");
-checkBadValues(element, "justifyContent", "justify-content",  "true true");
-checkBadValues(element, "justifyContent", "justify-content",  "true safe");
+checkBadValues(element, "justifyContent", "justify-content",  "unsafe unsafe");
+checkBadValues(element, "justifyContent", "justify-content",  "unsafe safe");
 checkBadValues(element, "justifyContent", "justify-content",  "center start");
 checkBadValues(element, "justifyContent", "justify-content",  "baseline safe");
-checkBadValues(element, "justifyContent", "justify-content",  "true baseline");
-checkBadValues(element, "justifyContent", "justify-content",  "true safe left");
-checkBadValues(element, "justifyContent", "justify-content",  "true left safe");
-checkBadValues(element, "justifyContent", "justify-content",  "left safe true safe");
+checkBadValues(element, "justifyContent", "justify-content",  "unsafe baseline");
+checkBadValues(element, "justifyContent", "justify-content",  "unsafe safe left");
+checkBadValues(element, "justifyContent", "justify-content",  "unsafe left safe");
+checkBadValues(element, "justifyContent", "justify-content",  "left safe unsafe safe");
 checkBadValues(element, "justifyContent", "justify-content",  "start right space-between");
 checkBadValues(element, "justifyContent", "justify-content",  "safe stretch");
 checkBadValues(element, "justifyContent", "justify-content",  "space-around stretch");
 checkBadValues(element, "justifyContent", "justify-content",  "end space-between start");
 checkBadValues(element, "justifyContent", "justify-content",  "right safe left");
-checkBadValues(element, "justifyContent", "justify-content",  "true");
+checkBadValues(element, "justifyContent", "justify-content",  "unsafe");
 checkBadValues(element, "justifyContent", "justify-content",  "safe");
 
 debug("");
@@ -343,7 +343,7 @@ checkInitialValues(element, "justifyContent", "justify-content", "space-between
 debug("");
 debug("Test the value 'initial' for flex containers");
 element.style.display = "-webkit-flex";
-checkInitialValues(element, "justifyContent", "justify-content", "right true", "stretch");
+checkInitialValues(element, "justifyContent", "justify-content", "right unsafe", "stretch");
 
 debug("");
 debug("Test the value 'inherit'");
index 755087e..3c15584 100644 (file)
@@ -27,25 +27,25 @@ body {
 }
 .alignItemsCenter { align-items: center; }
 .alignItemsCenterSafe { align-items: center safe; }
-.alignItemsCenterTrue { align-items: center true; }
+.alignItemsCenterUnsafe { align-items: center unsafe; }
 .alignItemsEnd { align-items: end; }
 .alignItemsEndSafe { align-items: end safe; }
-.alignItemsEndTrue { align-items: end true; }
+.alignItemsEndUnsafe { align-items: end unsafe; }
 .alignSelfCenter { align-self: center; }
 .alignSelfCenterSafe { align-self: center safe; }
-.alignSelfCenterTrue { align-self: center true; }
+.alignSelfCenterUnsafe { align-self: center unsafe; }
 .alignSelfEnd { align-self: end; }
 .alignSelfEndSafe { align-self: end safe; }
-.alignSelfEndTrue { align-self: end true; }
+.alignSelfEndUnsafe { align-self: end unsafe; }
 .justifyItemsCenter { justify-items: center; }
 .justifyItemsCenterSafe { justify-items: center safe; }
-.justifyItemsCenterTrue { justify-items: center true; }
+.justifyItemsCenterUnsafe { justify-items: center unsafe; }
 .justifyItemsEnd { justify-items: end; }
 .justifyItemsEndSafe { justify-items: end safe; }
-.justifyItemsEndTrue { justify-items: end true; }
+.justifyItemsEndUnsafe { justify-items: end unsafe; }
 .justifySelfCenter { justify-self: center; }
 .justifySelfCenterSafe { justify-self: center safe; }
-.justifySelfCenterTrue { justify-self: center true; }
+.justifySelfCenterUnsafe { justify-self: center unsafe; }
 .justifySelfEnd { justify-self: end; }
 .thirdRowFirstColumn {
     background-color: green;
@@ -70,7 +70,7 @@ body {
 </div>
 
 <div style="position: relative">
-    <div class="grid alignItemsCenterTrue justifyItemsCenterTrue" data-expected-width="300" data-expected-height="360">
+    <div class="grid alignItemsCenterUnsafe justifyItemsCenterUnsafe" data-expected-width="300" data-expected-height="360">
         <div class="cellOverflowHeight firstRowFirstColumn" data-offset-x="50" data-offset-y="-15" data-expected-width="50" data-expected-height="150"></div>
         <div class="cellWithNoOverflow secondRowFirstColumn" data-offset-x="50" data-offset-y="160" data-expected-width="50" data-expected-height="40"></div>
         <div class="cellWithNoOverflow thirdRowFirstColumn" data-offset-x="50" data-offset-y="280" data-expected-width="50" data-expected-height="40"></div>
@@ -114,7 +114,7 @@ body {
 </div>
 
 <div style="position: relative">
-    <div class="grid alignItemsEndTrue justifyItemsEndTrue" data-expected-width="300" data-expected-height="360">
+    <div class="grid alignItemsEndUnsafe justifyItemsEndUnsafe" data-expected-width="300" data-expected-height="360">
         <div class="cellOverflowHeight firstRowFirstColumn" data-offset-x="100" data-offset-y="-30" data-expected-width="50" data-expected-height="150"></div>
         <div class="cellWithNoOverflow secondRowFirstColumn" data-offset-x="100" data-offset-y="200" data-expected-width="50" data-expected-height="40"></div>
         <div class="cellWithNoOverflow thirdRowFirstColumn" data-offset-x="100" data-offset-y="320" data-expected-width="50" data-expected-height="40"></div>
@@ -127,7 +127,7 @@ body {
 <div style="position: relative">
     <div class="grid alignItemsEndSafe justifyItemsEndSafe" data-expected-width="300" data-expected-height="360">
         <div class="cellOverflowWidth  firstRowFirstColumn" data-offset-x="0" data-offset-y="80" data-expected-width="180" data-expected-height="40"></div>
-        <div class="cellWithNoOverflow secondRowFirstColumn justifySelfCenterTrue" data-offset-x="50" data-offset-y="200" data-expected-width="50" data-expected-height="40"></div>
+        <div class="cellWithNoOverflow secondRowFirstColumn justifySelfCenterUnsafe" data-offset-x="50" data-offset-y="200" data-expected-width="50" data-expected-height="40"></div>
         <div class="cellWithNoOverflow thirdRowFirstColumn" data-offset-x="100" data-offset-y="320" data-expected-width="50" data-expected-height="40"></div>
         <div class="cellWithNoOverflow firstRowSecondColumn" data-offset-x="250" data-offset-y="80" data-expected-width="50" data-expected-height="40"></div>
         <div class="cellOverflowWidth  secondRowSecondColumn" data-offset-x="150" data-offset-y="200" data-expected-width="180" data-expected-height="40"></div>
@@ -140,7 +140,7 @@ body {
         <div class="cellOverflowHeight firstRowFirstColumn" data-offset-x="100" data-offset-y="0" data-expected-width="50" data-expected-height="150"></div>
         <div class="cellWithNoOverflow secondRowFirstColumn" data-offset-x="100" data-offset-y="200" data-expected-width="50" data-expected-height="40"></div>
         <div class="cellWithNoOverflow thirdRowFirstColumn" data-offset-x="100" data-offset-y="320" data-expected-width="50" data-expected-height="40"></div>
-        <div class="cellWithNoOverflow firstRowSecondColumn alignSelfCenterTrue" data-offset-x="250" data-offset-y="40" data-expected-width="50" data-expected-height="40"></div>
+        <div class="cellWithNoOverflow firstRowSecondColumn alignSelfCenterUnsafe" data-offset-x="250" data-offset-y="40" data-expected-width="50" data-expected-height="40"></div>
         <div class="cellOverflowHeight secondRowSecondColumn" data-offset-x="250" data-offset-y="120" data-expected-width="50" data-expected-height="150"></div>
         <div class="cellWithNoOverflow thirdRowSecondColumn" data-offset-x="250" data-offset-y="320" data-expected-width="50" data-expected-height="40"></div>
     </div>
index e661eab..f9a8f21 100644 (file)
@@ -33,9 +33,9 @@ body {
     justify-content: center safe;
 }
 
-.centerTrue {
-    align-content: center true;
-    justify-content: center true;
+.centerUnsafe {
+    align-content: center unsafe;
+    justify-content: center unsafe;
 }
 
 .end {
@@ -48,9 +48,9 @@ body {
     justify-content: end safe;
 }
 
-.endTrue {
-    align-content: end true;
-    justify-content: end true;
+.endUnsafe {
+    align-content: end unsafe;
+    justify-content: end unsafe;
 }
 
 </style>
@@ -69,7 +69,7 @@ body {
 </div>
 
 <div style="position: relative">
-    <div class="grid overflowHeight centerTrue" data-expected-width="200" data-expected-height="150">
+    <div class="grid overflowHeight centerUnsafe" data-expected-width="200" data-expected-height="150">
         <div class="firstRowFirstColumn" data-offset-x="50" data-offset-y="-25" data-expected-width="50" data-expected-height="100"></div>
         <div class="secondRowFirstColumn" data-offset-x="50" data-offset-y="75" data-expected-width="50" data-expected-height="100"></div>
         <div class="firstRowSecondColumn" data-offset-x="100" data-offset-y="-25" data-expected-width="50" data-expected-height="100"></div>
@@ -105,7 +105,7 @@ body {
 </div>
 
 <div style="position: relative">
-    <div class="grid overflowHeight endTrue" data-expected-width="200" data-expected-height="150">
+    <div class="grid overflowHeight endUnsafe" data-expected-width="200" data-expected-height="150">
         <div class="firstRowFirstColumn" data-offset-x="100" data-offset-y="-50" data-expected-width="50" data-expected-height="100"></div>
         <div class="secondRowFirstColumn" data-offset-x="100" data-offset-y="50" data-expected-width="50" data-expected-height="100"></div>
         <div class="firstRowSecondColumn" data-offset-x="150" data-offset-y="-50" data-expected-width="50" data-expected-height="100"></div>
index 995425a..dc23cb6 100644 (file)
@@ -16,13 +16,13 @@ PASS getComputedStyle(justifyItemsLeft, '').getPropertyValue('justify-items') is
 PASS getComputedStyle(justifyItemsRight, '').getPropertyValue('justify-items') is 'right'
 PASS getComputedStyle(justifyItemsFlexStart, '').getPropertyValue('justify-items') is 'flex-start'
 PASS getComputedStyle(justifyItemsFlexEnd, '').getPropertyValue('justify-items') is 'flex-end'
-PASS getComputedStyle(justifyItemsEndTrue, '').getPropertyValue('justify-items') is 'end true'
-PASS getComputedStyle(justifyItemsCenterTrue, '').getPropertyValue('justify-items') is 'center true'
+PASS getComputedStyle(justifyItemsEndUnsafe, '').getPropertyValue('justify-items') is 'end unsafe'
+PASS getComputedStyle(justifyItemsCenterUnsafe, '').getPropertyValue('justify-items') is 'center unsafe'
 PASS getComputedStyle(justifyItemsSelfEndSafe, '').getPropertyValue('justify-items') is 'self-end safe'
 PASS getComputedStyle(justifyItemsSelfStartSafe, '').getPropertyValue('justify-items') is 'self-start safe'
 PASS getComputedStyle(justifyItemsRightSafe, '').getPropertyValue('justify-items') is 'right safe'
-PASS getComputedStyle(justifyItemsLeftTrue, '').getPropertyValue('justify-items') is 'left true'
-PASS getComputedStyle(justifyItemsFlexStartTrue, '').getPropertyValue('justify-items') is 'flex-start true'
+PASS getComputedStyle(justifyItemsLeftUnsafe, '').getPropertyValue('justify-items') is 'left unsafe'
+PASS getComputedStyle(justifyItemsFlexStartUnsafe, '').getPropertyValue('justify-items') is 'flex-start unsafe'
 PASS getComputedStyle(justifyItemsFlexEndSafe, '').getPropertyValue('justify-items') is 'flex-end safe'
 PASS getComputedStyle(justifyItemsLegacyLeft, '').getPropertyValue('justify-items') is 'legacy left'
 PASS getComputedStyle(justifyItemsLegacyCenter, '').getPropertyValue('justify-items') is 'legacy center'
@@ -37,8 +37,8 @@ PASS getComputedStyle(element, '').getPropertyValue('justify-items') is 'start'
 Test getting and setting justify-items through JS
 PASS element.style.justifyItems is "center"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "center"
-PASS element.style.justifyItems is "start true"
-PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "start true"
+PASS element.style.justifyItems is "start unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "start unsafe"
 PASS element.style.justifyItems is "flex-end safe"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "flex-end safe"
 PASS element.style.justifyItems is "legacy right"
@@ -121,8 +121,8 @@ PASS element.style.justifyItems is "initial"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "stretch"
 
 Test the value 'initial' for flex containers
-PASS element.style.justifyItems is "right true"
-PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "right true"
+PASS element.style.justifyItems is "right unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "right unsafe"
 PASS element.style.justifyItems is "initial"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "stretch"
 
@@ -135,10 +135,10 @@ PASS element.style.justifyItems is "left safe"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "left safe"
 PASS element.style.justifyItems is "inherit"
 PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "left safe"
-PASS element.style.justifyItems is "center true"
-PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "center true"
+PASS element.style.justifyItems is "center unsafe"
+PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "center unsafe"
 PASS element.style.justifyItems is "inherit"
-PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "center true"
+PASS window.getComputedStyle(element, '').getPropertyValue('justify-items') is "center unsafe"
 
 Test the value 'legacy'
 PASS element.style.justifyItems is "legacy left"
index a274e68..a6a86a1 100644 (file)
     justify-items: flex-end;
 }
 
-#justifyItemsEndTrue {
-    justify-items: end true;
+#justifyItemsEndUnsafe {
+    justify-items: end unsafe;
 }
 
-#justifyItemsCenterTrue {
-    justify-items: center true;
+#justifyItemsCenterUnsafe {
+    justify-items: center unsafe;
 }
 
 #justifyItemsSelfEndSafe {
     justify-items: right safe;
 }
 
-#justifyItemsLeftTrue {
-    justify-items: left true;
+#justifyItemsLeftUnsafe {
+    justify-items: left unsafe;
 }
 
-#justifyItemsFlexStartTrue {
-    justify-items: flex-start true;
+#justifyItemsFlexStartUnsafe {
+    justify-items: flex-start unsafe;
 }
 
 #justifyItemsFlexEndSafe {
 <div id="justifyItemsFlexStart"></div>
 <div id="justifyItemsFlexEnd"></div>
 
-<div id="justifyItemsEndTrue"></div>
-<div id="justifyItemsCenterTrue"></div>
+<div id="justifyItemsEndUnsafe"></div>
+<div id="justifyItemsCenterUnsafe"></div>
 <div id="justifyItemsSelfEndSafe"></div>
 <div id="justifyItemsSelfStartSafe"></div>
 <div id="justifyItemsRightSafe"></div>
-<div id="justifyItemsLeftTrue"></div>
-<div id="justifyItemsFlexStartTrue"></div>
+<div id="justifyItemsLeftUnsafe"></div>
+<div id="justifyItemsFlexStartUnsafe"></div>
 <div id="justifyItemsFlexEndSafe"></div>
 <div id="justifyItemsLegacyLeft"></div>
 <div id="justifyItemsLegacyCenter"></div>
@@ -177,11 +177,11 @@ shouldBe("getComputedStyle(justifyItemsFlexStart, '').getPropertyValue('justify-
 var justifyItemsFlexEnd = document.getElementById("justifyItemsFlexEnd");
 shouldBe("getComputedStyle(justifyItemsFlexEnd, '').getPropertyValue('justify-items')", "'flex-end'");
 
-var justifyItemsEndTrue = document.getElementById("justifyItemsEndTrue");
-shouldBe("getComputedStyle(justifyItemsEndTrue, '').getPropertyValue('justify-items')", "'end true'");
+var justifyItemsEndUnsafe = document.getElementById("justifyItemsEndUnsafe");
+shouldBe("getComputedStyle(justifyItemsEndUnsafe, '').getPropertyValue('justify-items')", "'end unsafe'");
 
-var justifyItemsCenterTrue = document.getElementById("justifyItemsCenterTrue");
-shouldBe("getComputedStyle(justifyItemsCenterTrue, '').getPropertyValue('justify-items')", "'center true'");
+var justifyItemsCenterUnsafe = document.getElementById("justifyItemsCenterUnsafe");
+shouldBe("getComputedStyle(justifyItemsCenterUnsafe, '').getPropertyValue('justify-items')", "'center unsafe'");
 
 var justifyItemsSelfEndSafe = document.getElementById("justifyItemsSelfEndSafe");
 shouldBe("getComputedStyle(justifyItemsSelfEndSafe, '').getPropertyValue('justify-items')", "'self-end safe'");
@@ -192,11 +192,11 @@ shouldBe("getComputedStyle(justifyItemsSelfStartSafe, '').getPropertyValue('just
 var justifyItemsRightSafe = document.getElementById("justifyItemsRightSafe");
 shouldBe("getComputedStyle(justifyItemsRightSafe, '').getPropertyValue('justify-items')", "'right safe'");
 
-var justifyItemsLeftTrue = document.getElementById("justifyItemsLeftTrue");
-shouldBe("getComputedStyle(justifyItemsLeftTrue, '').getPropertyValue('justify-items')", "'left true'");
+var justifyItemsLeftUnsafe = document.getElementById("justifyItemsLeftUnsafe");
+shouldBe("getComputedStyle(justifyItemsLeftUnsafe, '').getPropertyValue('justify-items')", "'left unsafe'");
 
-var justifyItemsFlexStartTrue = document.getElementById("justifyItemsFlexStartTrue");
-shouldBe("getComputedStyle(justifyItemsFlexStartTrue, '').getPropertyValue('justify-items')", "'flex-start true'");
+var justifyItemsFlexStartUnsafe = document.getElementById("justifyItemsFlexStartUnsafe");
+shouldBe("getComputedStyle(justifyItemsFlexStartUnsafe, '').getPropertyValue('justify-items')", "'flex-start unsafe'");
 
 var justifyItemsFlexEndSafe = document.getElementById("justifyItemsFlexEndSafe");
 shouldBe("getComputedStyle(justifyItemsFlexEndSafe, '').getPropertyValue('justify-items')", "'flex-end safe'");
@@ -232,8 +232,8 @@ document.body.appendChild(element);
 element.style.justifyItems = "center";
 checkValues(element, "justifyItems", "justify-items",  "center", "center");
 
-element.style.justifyItems = "true start";
-checkValues(element, "justifyItems", "justify-items",  "start true", "start true");
+element.style.justifyItems = "unsafe start";
+checkValues(element, "justifyItems", "justify-items",  "start unsafe", "start unsafe");
 
 element.style.justifyItems = "flex-end safe";
 checkValues(element, "justifyItems", "justify-items",  "flex-end safe", "flex-end safe");
@@ -268,26 +268,26 @@ debug("Test bad combinations of justify-items");
 element = document.createElement("div");
 document.body.appendChild(element);
 
-checkBadValues(element, "justifyItems", "justify-items",  "true auto");
+checkBadValues(element, "justifyItems", "justify-items",  "unsafe auto");
 checkBadValues(element, "justifyItems", "justify-items",  "auto safe");
 checkBadValues(element, "justifyItems", "justify-items",  "auto left");
 checkBadValues(element, "justifyItems", "justify-items",  "baseline safe");
 checkBadValues(element, "justifyItems", "justify-items",  "baseline center");
-checkBadValues(element, "justifyItems", "justify-items",  "stretch true");
+checkBadValues(element, "justifyItems", "justify-items",  "stretch unsafe");
 checkBadValues(element, "justifyItems", "justify-items",  "stretch right");
-checkBadValues(element, "justifyItems", "justify-items",  "true true");
-checkBadValues(element, "justifyItems", "justify-items",  "true safe");
+checkBadValues(element, "justifyItems", "justify-items",  "unsafe unsafe");
+checkBadValues(element, "justifyItems", "justify-items",  "unsafe safe");
 checkBadValues(element, "justifyItems", "justify-items",  "center start");
-checkBadValues(element, "justifyItems", "justify-items",  "stretch true");
+checkBadValues(element, "justifyItems", "justify-items",  "stretch unsafe");
 checkBadValues(element, "justifyItems", "justify-items",  "safe stretch");
 checkBadValues(element, "justifyItems", "justify-items",  "baseline safe");
-checkBadValues(element, "justifyItems", "justify-items",  "true baseline");
-checkBadValues(element, "justifyItems", "justify-items",  "true safe left");
-checkBadValues(element, "justifyItems", "justify-items",  "true left safe");
-checkBadValues(element, "justifyItems", "justify-items",  "left safe true safe");
+checkBadValues(element, "justifyItems", "justify-items",  "unsafe baseline");
+checkBadValues(element, "justifyItems", "justify-items",  "unsafe safe left");
+checkBadValues(element, "justifyItems", "justify-items",  "unsafe left safe");
+checkBadValues(element, "justifyItems", "justify-items",  "left safe unsafe safe");
 checkBadValues(element, "justifyItems", "justify-items",  "legacy start");
 checkBadValues(element, "justifyItems", "justify-items",  "legacy end");
-checkBadValues(element, "justifyItems", "justify-items",  "legacy right true");
+checkBadValues(element, "justifyItems", "justify-items",  "legacy right unsafe");
 checkBadValues(element, "justifyItems", "justify-items",  "legacy auto");
 checkBadValues(element, "justifyItems", "justify-items",  "legacy stretch");
 checkBadValues(element, "justifyItems", "justify-items",  "legacy");
@@ -306,14 +306,14 @@ checkInitialValues(element, "justifyItems", "justify-items", "left safe", "stret
 debug("");
 debug("Test the value 'initial' for flex containers");
 element.style.display = "-webkit-flex";
-checkInitialValues(element, "justifyItems", "justify-items", "right true", "stretch");
+checkInitialValues(element, "justifyItems", "justify-items", "right unsafe", "stretch");
 
 debug("");
 debug("Test the value 'inherit'");
 parentElement = document.createElement("div");
 checkInheritValues("justifyItems", "justify-items", "end");
 checkInheritValues("justifyItems", "justify-items", "left safe");
-checkInheritValues("justifyItems", "justify-items", "center true");
+checkInheritValues("justifyItems", "justify-items", "center unsafe");
 
 debug("");
 debug("Test the value 'legacy'");
index 9d7fa81..26a298a 100644 (file)
@@ -13,19 +13,19 @@ PASS getComputedStyle(justifySelfSelfEnd, '').getPropertyValue('justify-self') i
 PASS getComputedStyle(justifySelfSelfStart, '').getPropertyValue('justify-self') is 'self-start'
 PASS getComputedStyle(justifySelfLeft, '').getPropertyValue('justify-self') is 'left'
 PASS getComputedStyle(justifySelfRight, '').getPropertyValue('justify-self') is 'right'
-PASS getComputedStyle(justifySelfEndTrue, '').getPropertyValue('justify-self') is 'end true'
-PASS getComputedStyle(justifySelfCenterTrue, '').getPropertyValue('justify-self') is 'center true'
+PASS getComputedStyle(justifySelfEndUnsafe, '').getPropertyValue('justify-self') is 'end unsafe'
+PASS getComputedStyle(justifySelfCenterUnsafe, '').getPropertyValue('justify-self') is 'center unsafe'
 PASS getComputedStyle(justifySelfSelfEndSafe, '').getPropertyValue('justify-self') is 'self-end safe'
 PASS getComputedStyle(justifySelfSelfStartSafe, '').getPropertyValue('justify-self') is 'self-start safe'
 PASS getComputedStyle(justifySelfRightSafe, '').getPropertyValue('justify-self') is 'right safe'
-PASS getComputedStyle(justifySelfLeftTrue, '').getPropertyValue('justify-self') is 'left true'
+PASS getComputedStyle(justifySelfLeftUnsafe, '').getPropertyValue('justify-self') is 'left unsafe'
 
 Test initial value of justify-self through JS
 PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
 
 Test getting and setting justify-self through JS
 PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'center'
-PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start true'
+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start unsafe'
 PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
 
 Test bad combinations of justify-self
index e77c423..70ae924 100644 (file)
     justify-self: right;
 }
 
-#justifySelfEndTrue {
-    justify-self: end true;
+#justifySelfEndUnsafe {
+    justify-self: end unsafe;
 }
 
-#justifySelfCenterTrue {
-    justify-self: center true;
+#justifySelfCenterUnsafe {
+    justify-self: center unsafe;
 }
 
 #justifySelfSelfEndSafe {
@@ -58,8 +58,8 @@
     justify-self: right safe;
 }
 
-#justifySelfLeftTrue {
-    justify-self: left true;
+#justifySelfLeftUnsafe {
+    justify-self: left unsafe;
 }
 </style>
 <script src="../../resources/js-test.js"></script>
 <div id="justifySelfLeft"></div>
 <div id="justifySelfRight"></div>
 
-<div id="justifySelfEndTrue"></div>
-<div id="justifySelfCenterTrue"></div>
+<div id="justifySelfEndUnsafe"></div>
+<div id="justifySelfCenterUnsafe"></div>
 <div id="justifySelfSelfEndSafe"></div>
 <div id="justifySelfSelfStartSafe"></div>
 <div id="justifySelfRightSafe"></div>
-<div id="justifySelfLeftTrue"></div>
+<div id="justifySelfLeftUnsafe"></div>
 <script>
 description('Test that setting and getting justify-self works as expected');
 
@@ -112,11 +112,11 @@ shouldBe("getComputedStyle(justifySelfLeft, '').getPropertyValue('justify-self')
 var justifySelfRight = document.getElementById("justifySelfRight");
 shouldBe("getComputedStyle(justifySelfRight, '').getPropertyValue('justify-self')", "'right'");
 
-var justifySelfEndTrue = document.getElementById("justifySelfEndTrue");
-shouldBe("getComputedStyle(justifySelfEndTrue, '').getPropertyValue('justify-self')", "'end true'");
+var justifySelfEndUnsafe = document.getElementById("justifySelfEndUnsafe");
+shouldBe("getComputedStyle(justifySelfEndUnsafe, '').getPropertyValue('justify-self')", "'end unsafe'");
 
-var justifySelfCenterTrue = document.getElementById("justifySelfCenterTrue");
-shouldBe("getComputedStyle(justifySelfCenterTrue, '').getPropertyValue('justify-self')", "'center true'");
+var justifySelfCenterUnsafe = document.getElementById("justifySelfCenterUnsafe");
+shouldBe("getComputedStyle(justifySelfCenterUnsafe, '').getPropertyValue('justify-self')", "'center unsafe'");
 
 var justifySelfSelfEndSafe = document.getElementById("justifySelfSelfEndSafe");
 shouldBe("getComputedStyle(justifySelfSelfEndSafe, '').getPropertyValue('justify-self')", "'self-end safe'");
@@ -127,8 +127,8 @@ shouldBe("getComputedStyle(justifySelfSelfStartSafe, '').getPropertyValue('justi
 var justifySelfRightSafe = document.getElementById("justifySelfRightSafe");
 shouldBe("getComputedStyle(justifySelfRightSafe, '').getPropertyValue('justify-self')", "'right safe'");
 
-var justifySelfLeftTrue = document.getElementById("justifySelfLeftTrue");
-shouldBe("getComputedStyle(justifySelfLeftTrue, '').getPropertyValue('justify-self')", "'left true'");
+var justifySelfLeftUnsafe = document.getElementById("justifySelfLeftUnsafe");
+shouldBe("getComputedStyle(justifySelfLeftUnsafe, '').getPropertyValue('justify-self')", "'left unsafe'");
 
 debug("");
 debug("Test initial value of justify-self through JS");
@@ -145,8 +145,8 @@ shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'cen
 
 element = document.createElement("div");
 document.body.appendChild(element);
-element.style.justifySelf = "true start";
-shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start true'");
+element.style.justifySelf = "unsafe start";
+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start unsafe'");
 
 element.style.justifySelf = "start";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
@@ -164,25 +164,25 @@ shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'sta
 element.style.justifySelf = "baseline center";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
-element.style.justifySelf = "stretch true";
+element.style.justifySelf = "stretch unsafe";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
 element.style.justifySelf = "stretch right";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
-element.style.justifySelf = "true true";
+element.style.justifySelf = "unsafe unsafe";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
-element.style.justifySelf = "true";
+element.style.justifySelf = "unsafe";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
-element.style.justifySelf = "true safe";
+element.style.justifySelf = "unsafe safe";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
 element.style.justifySelf = "center start";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
-element.style.justifySelf = "stretch true";
+element.style.justifySelf = "stretch unsafe";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
 element.style.justifySelf = "safe stretch";
@@ -191,19 +191,19 @@ shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'sta
 element.style.justifySelf = "baseline safe";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
-element.style.justifySelf = "true baseline";
+element.style.justifySelf = "unsafe baseline";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
-element.style.justifySelf = "true safe";
+element.style.justifySelf = "unsafe safe";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
-element.style.justifySelf = "true safe left";
+element.style.justifySelf = "unsafe safe left";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
-element.style.justifySelf = "true left safe";
+element.style.justifySelf = "unsafe left safe";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
-element.style.justifySelf = "left safe true safe";
+element.style.justifySelf = "left safe unsafe safe";
 shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
 
 debug("");
index 4947e02..0061f97 100644 (file)
@@ -13,7 +13,7 @@ body {
 #container {
   display: -webkit-grid;
   -webkit-grid: 200px / 150px 150px;
-  align-items: end true;
+  align-items: end unsafe;
   width: 200px;
   height: 300px;
   background-color: red;
index 331dbcb..f16a842 100644 (file)
@@ -21,13 +21,13 @@ body {
 .item1 {
   -webkit-grid-row: 1;
   -webkit-grid-column: 1;
-  align-self: end true;
+  align-self: end unsafe;
   background-color: green;
 }
 .item2 {
   -webkit-grid-row: 2;
   -webkit-grid-column: 1;
-  align-self: end true;
+  align-self: end unsafe;
   background-color: green;
 </style>
 <p style="height: 20px">Tests invalidation on align-self style change (just overflow). Passes if there is no red.</p>
index 7dabcea..4e27929 100644 (file)
@@ -13,7 +13,7 @@ body {
 #container {
   display: -webkit-grid;
   -webkit-grid: 100px 100px / 300px;
-  justify-items: end true;
+  justify-items: end unsafe;
   width: 200px;
   height: 300px;
   background-color: red;
index c4792ea..18916af 100644 (file)
@@ -21,7 +21,7 @@ body {
 .item1 {
   -webkit-grid-row: 1;
   -webkit-grid-column: 1;
-  justify-self: end true;
+  justify-self: end unsafe;
   background-color: green;
   width: 150px;
 }
@@ -29,7 +29,7 @@ body {
   -webkit-grid-row: 1;
   -webkit-grid-column: 2;
   background-color: green;
-  justify-self: end true;
+  justify-self: end unsafe;
   width: 50px;
 </style>
 <p style="height: 20px">Tests invalidation on justify-self style change. Passes if there is no red.</p>
index b78938f..4ecddaf 100644 (file)
@@ -1,3 +1,30 @@
+2015-12-15  Javier Fernandez  <jfernandez@igalia.com>
+
+        [css-align][css-grid] Overflow alignment value 'true' renamed to 'unsafe'
+        https://bugs.webkit.org/show_bug.cgi?id=152251
+
+        Reviewed by Darin Adler.
+
+        The 'True' Overflow Alignment keyword is now defined in the Box Alignment
+        specification as 'Unsafe'.
+
+        This patch applies the required changes in the CSS parsing logic, as well
+        Grid Layout specific codebase, so it complies with the last version of the
+        spec.
+
+        No new tests, no change in functionality.
+
+        * css/CSSParser.cpp:
+        (WebCore::isAlignmentOverflowKeyword):
+        (WebCore::CSSParser::parseItemPositionOverflowPosition):
+        * css/CSSPrimitiveValueMappings.h:
+        (WebCore::CSSPrimitiveValue::CSSPrimitiveValue):
+        (WebCore::CSSPrimitiveValue::operator OverflowAlignment):
+        * css/CSSValueKeywords.in:
+        * rendering/RenderGrid.cpp:
+        (WebCore::computeOverflowAlignmentOffset):
+        * rendering/style/RenderStyleConstants.h:
+
 2015-12-15  Zan Dobersek  <zdobersek@igalia.com>
 
         [TexMap] Operate with a reference to the TextureMapper wherever possible
index 69a5da0..46a952e 100644 (file)
@@ -3375,7 +3375,7 @@ static inline bool isBaselinePositionKeyword(CSSValueID id)
 
 static bool isAlignmentOverflowKeyword(CSSValueID id)
 {
-    return id == CSSValueTrue || id == CSSValueSafe;
+    return id == CSSValueUnsafe || id == CSSValueSafe;
 }
 
 static bool isItemPositionKeyword(CSSValueID id)
@@ -3486,7 +3486,7 @@ bool CSSParser::parseItemPositionOverflowPosition(CSSPropertyID propId, bool imp
         position = CSSValuePool::singleton().createIdentifierValue(value->id);
         value = m_valueList->next();
         if (value) {
-            if (value->id != CSSValueTrue && value->id != CSSValueSafe)
+            if (value->id != CSSValueUnsafe && value->id != CSSValueSafe)
                 return false;
             overflowAlignmentKeyword = CSSValuePool::singleton().createIdentifierValue(value->id);
         }
index 5325280..e5315e4 100644 (file)
@@ -5085,8 +5085,8 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowAlignment overflo
     case OverflowAlignmentDefault:
         m_value.valueID = CSSValueDefault;
         break;
-    case OverflowAlignmentTrue:
-        m_value.valueID = CSSValueTrue;
+    case OverflowAlignmentUnsafe:
+        m_value.valueID = CSSValueUnsafe;
         break;
     case OverflowAlignmentSafe:
         m_value.valueID = CSSValueSafe;
@@ -5097,15 +5097,15 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowAlignment overflo
 template<> inline CSSPrimitiveValue::operator OverflowAlignment() const
 {
     switch (m_value.valueID) {
-    case CSSValueTrue:
-        return OverflowAlignmentTrue;
+    case CSSValueUnsafe:
+        return OverflowAlignmentUnsafe;
     case CSSValueSafe:
         return OverflowAlignmentSafe;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
-    return OverflowAlignmentTrue;
+    return OverflowAlignmentUnsafe;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentPosition contentPosition)
index bdc4259..860c474 100644 (file)
@@ -623,7 +623,7 @@ self-end
 // flex-end
 // left
 // right
-true
+unsafe
 safe
 legacy
 
index ea35656..538f256 100644 (file)
@@ -1590,7 +1590,7 @@ static inline LayoutUnit computeOverflowAlignmentOffset(OverflowAlignment overfl
         // If overflow is 'safe', we have to make sure we don't overflow the 'start'
         // edge (potentially cause some data loss as the overflow is unreachable).
         return std::max<LayoutUnit>(0, offset);
-    case OverflowAlignmentTrue:
+    case OverflowAlignmentUnsafe:
     case OverflowAlignmentDefault:
         // If we overflow our alignment container and overflow is 'true' (default), we
         // ignore the overflow and just return the value regardless (which may cause data
index 73b53db..a0e2f1d 100644 (file)
@@ -252,7 +252,7 @@ enum EAlignContent { AlignContentFlexStart, AlignContentFlexEnd, AlignContentCen
 enum EFlexDirection { FlowRow, FlowRowReverse, FlowColumn, FlowColumnReverse };
 enum EFlexWrap { FlexNoWrap, FlexWrap, FlexWrapReverse };
 enum ItemPosition {ItemPositionAuto, ItemPositionStretch, ItemPositionBaseline, ItemPositionLastBaseline, ItemPositionCenter, ItemPositionStart, ItemPositionEnd, ItemPositionSelfStart, ItemPositionSelfEnd, ItemPositionFlexStart, ItemPositionFlexEnd, ItemPositionLeft, ItemPositionRight};
-enum OverflowAlignment {OverflowAlignmentDefault, OverflowAlignmentTrue, OverflowAlignmentSafe};
+enum OverflowAlignment {OverflowAlignmentDefault, OverflowAlignmentUnsafe, OverflowAlignmentSafe};
 enum ItemPositionType {NonLegacyPosition, LegacyPosition};
 enum ContentPosition {ContentPositionAuto, ContentPositionBaseline, ContentPositionLastBaseline, ContentPositionCenter, ContentPositionStart, ContentPositionEnd, ContentPositionFlexStart, ContentPositionFlexEnd, ContentPositionLeft, ContentPositionRight};
 enum ContentDistributionType {ContentDistributionDefault, ContentDistributionSpaceBetween, ContentDistributionSpaceAround, ContentDistributionSpaceEvenly, ContentDistributionStretch};