Align CSS hsl() -> rgb() color conversion with the spec
authorsimon.fraser@apple.com <simon.fraser@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 30 Oct 2019 00:55:27 +0000 (00:55 +0000)
committersimon.fraser@apple.com <simon.fraser@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 30 Oct 2019 00:55:27 +0000 (00:55 +0000)
https://bugs.webkit.org/show_bug.cgi?id=203592

Reviewed by Tim Horton.
LayoutTests/imported/w3c:

Fix lots of tests in css/css-color/color-resolving-hsl.html by matching the specified rounding
when converting between hsl() and rgb().

Remove some duplicated code, and call HSLToSRGB().

* web-platform-tests/css/css-color/color-resolving-expected.txt:
* web-platform-tests/css/css-color/color-resolving-hsl-expected.txt:
* web-platform-tests/css/css-color/parsing/color-computed-expected.txt:
* web-platform-tests/css/css-color/parsing/color-valid-expected.txt:

Source/WebCore:

Fix lots of tests in css/css-color/color-resolving-hsl.html by matching the specified rounding
when converting between hsl() and rgb().

Remove some duplicated code, and call HSLToSRGB().

Tested by WPT.

* css/parser/CSSPropertyParserHelpers.cpp:
(WebCore::CSSPropertyParserHelpers::parseHSLParameters):
* platform/graphics/Color.cpp:
(WebCore::makeRGBAFromHSLA):
(WebCore::calcHue): Deleted.
* platform/graphics/Color.h:

LayoutTests:

* platform/mac/fast/css/hsl-color-expected.txt:
* platform/mac/fast/css/hsla-color-expected.txt:

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

15 files changed:
LayoutTests/ChangeLog
LayoutTests/css3/calc/color-hsl-expected.txt
LayoutTests/fast/css3-text/css3-text-decoration/getComputedStyle/getComputedStyle-text-decoration-color-expected.txt
LayoutTests/imported/w3c/ChangeLog
LayoutTests/imported/w3c/web-platform-tests/css/css-color/color-resolving-expected.txt
LayoutTests/imported/w3c/web-platform-tests/css/css-color/color-resolving-hsl-expected.txt
LayoutTests/imported/w3c/web-platform-tests/css/css-color/parsing/color-computed-expected.txt
LayoutTests/imported/w3c/web-platform-tests/css/css-color/parsing/color-valid-expected.txt
LayoutTests/platform/mac/fast/css/hsl-color-expected.txt
LayoutTests/platform/mac/fast/css/hsla-color-expected.txt
LayoutTests/svg/custom/fill-opacity-hsl-expected.txt
Source/WebCore/ChangeLog
Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp
Source/WebCore/platform/graphics/Color.cpp
Source/WebCore/platform/graphics/Color.h

index e32afc7..cc5a67e 100644 (file)
 
         * fast/events/ios/autocorrect-with-range-selection.html:
 
+2019-10-29  Simon Fraser  <simon.fraser@apple.com>
+
+        Align CSS hsl() -> rgb() color conversion with the spec
+        https://bugs.webkit.org/show_bug.cgi?id=203592
+
+        Reviewed by Tim Horton.
+
+        * platform/mac/fast/css/hsl-color-expected.txt:
+        * platform/mac/fast/css/hsla-color-expected.txt:
+
 2019-10-07  Jer Noble  <jer.noble@apple.com>
 
         Implement the Remote Playback API.
index 920f1f3..dd519cc 100644 (file)
@@ -3,8 +3,8 @@ Tests that CSS3 calc() can be used with the hsl() and hsla() functions
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
 
-PASS getComputedStyle(document.getElementById("simple"), null).color is "rgb(31, 223, 31)"
-PASS getComputedStyle(document.getElementById("alpha"), null).color is "rgba(31, 223, 31, 0.701961)"
+PASS getComputedStyle(document.getElementById("simple"), null).color is "rgb(32, 223, 32)"
+PASS getComputedStyle(document.getElementById("alpha"), null).color is "rgba(32, 223, 32, 0.701961)"
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 6cb5c68..70ed70c 100644 (file)
@@ -61,12 +61,12 @@ PASS computedStyle.getPropertyCSSValue('-webkit-text-decoration-color').cssText
 PASS computedStyle.webkitTextDecorationColor is 'rgb(0, 0, 255)'
 
 Valid value 'hsla(240, 100%, 50%, 0.5)':
-PASS e.style.webkitTextDecorationColor is 'rgba(0, 0, 255, 0.498039)'
+FAIL e.style.webkitTextDecorationColor should be rgba(0, 0, 255, 0.498039). Was rgba(0, 0, 255, 0.501961).
 PASS e.style.getPropertyCSSValue('-webkit-text-decoration-color').toString() is '[object CSSPrimitiveValue]'
-PASS e.style.getPropertyCSSValue('-webkit-text-decoration-color').cssText is 'rgba(0, 0, 255, 0.498039)'
+FAIL e.style.getPropertyCSSValue('-webkit-text-decoration-color').cssText should be rgba(0, 0, 255, 0.498039). Was rgba(0, 0, 255, 0.501961).
 PASS computedStyle.getPropertyCSSValue('-webkit-text-decoration-color').toString() is '[object CSSPrimitiveValue]'
-PASS computedStyle.getPropertyCSSValue('-webkit-text-decoration-color').cssText is 'rgba(0, 0, 255, 0.498039)'
-PASS computedStyle.webkitTextDecorationColor is 'rgba(0, 0, 255, 0.498039)'
+FAIL computedStyle.getPropertyCSSValue('-webkit-text-decoration-color').cssText should be rgba(0, 0, 255, 0.498039). Was rgba(0, 0, 255, 0.501961).
+FAIL computedStyle.webkitTextDecorationColor should be rgba(0, 0, 255, 0.498039). Was rgba(0, 0, 255, 0.501961).
 
 Initial value:
 PASS e.style.webkitTextDecorationColor is 'initial'
index 24003da..213ee3a 100644 (file)
@@ -1,5 +1,22 @@
 2019-10-29  Simon Fraser  <simon.fraser@apple.com>
 
+        Align CSS hsl() -> rgb() color conversion with the spec
+        https://bugs.webkit.org/show_bug.cgi?id=203592
+
+        Reviewed by Tim Horton.
+        
+        Fix lots of tests in css/css-color/color-resolving-hsl.html by matching the specified rounding
+        when converting between hsl() and rgb().
+        
+        Remove some duplicated code, and call HSLToSRGB().
+
+        * web-platform-tests/css/css-color/color-resolving-expected.txt:
+        * web-platform-tests/css/css-color/color-resolving-hsl-expected.txt:
+        * web-platform-tests/css/css-color/parsing/color-computed-expected.txt:
+        * web-platform-tests/css/css-color/parsing/color-valid-expected.txt:
+
+2019-10-29  Simon Fraser  <simon.fraser@apple.com>
+
         Update css/css-color WPT
         https://bugs.webkit.org/show_bug.cgi?id=203585
 
index 388bfa5..64dd2ad 100644 (file)
@@ -103,7 +103,7 @@ PASS Capitalization should not affect parsing: hsL(0, 100%, 50%)
 PASS Valid numbers should be parsed: hsl(60, 100%, 37.5%) 
 PASS Angles are represented as a part of a circle and wrap around: hsl(780, 100%, 37.5%) 
 PASS Angles are represented as a part of a circle and wrap around: hsl(-300, 100%, 37.5%) 
-FAIL Valid numbers should be parsed: hsl(300, 50%, 50%) assert_equals: expected "rgb(191, 64, 191)" but got "rgb(191, 63, 191)"
+PASS Valid numbers should be parsed: hsl(300, 50%, 50%) 
 PASS Angles are accepted in HSL/HSLA: hsl(30deg, 100%, 100%) 
 PASS HSL and HSLA are synonyms: hsl(0, 0%, 0%, 0%) 
 PASS The second and third parameters of hsl/hsla must be a percent: hsl(10, 50%, 0) 
@@ -118,7 +118,7 @@ PASS Invalid alpha values should be clamped to 0 and 1 respectively: hsLA(-300,
 PASS Angles are represented as a part of a circle and wrap around: hsla(-300, 100%, 37.5%, 0.2) 
 PASS Angles are represented as a part of a circle and wrap around: hsla(-300, 100%, 37.5%, 0) 
 PASS Invalid alpha values should be clamped to 0 and 1 respectively: hsla(-300, 100%, 37.5%, -3) 
-FAIL Percent alpha values are accepted in hsl/hsla: hsla(0, 0%, 0%, 50%) assert_equals: expected "rgba(0, 0, 0, 0.5)" but got "rgba(0, 0, 0, 0.498039)"
+FAIL Percent alpha values are accepted in hsl/hsla: hsla(0, 0%, 0%, 50%) assert_equals: expected "rgba(0, 0, 0, 0.5)" but got "rgba(0, 0, 0, 0.501961)"
 PASS Angles are accepted in HSL/HSLA: hsla(30deg, 100%, 100%, 1) 
 PASS The second and third parameters of hsl/hsla must be a percent: hsla(10, 50%, 0, 1) 
 PASS The first parameter of hsl/hsla must be a number or angle: hsla(50%, 50%, 0%, 1) 
index c5ebd49..cac52b9 100644 (file)
@@ -3,22 +3,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 62.5%, 0.2) 
@@ -39,22 +39,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 12.5%) assert_equals: expected "rgb(36, 28, 28)" but got "rgb(35, 27, 27)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 12.5%, 0) assert_equals: expected "rgba(36, 28, 28, 0)" but got "rgba(35, 27, 27, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(36, 28, 28, 0.2)" but got "rgba(35, 27, 27, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 12.5%, 1) assert_equals: expected "rgb(36, 28, 28)" but got "rgb(35, 27, 27)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 25%) assert_equals: expected "rgb(72, 56, 56)" but got "rgb(71, 55, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 25%, 0) assert_equals: expected "rgba(72, 56, 56, 0)" but got "rgba(71, 55, 55, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 25%, 0.2) assert_equals: expected "rgba(72, 56, 56, 0.2)" but got "rgba(71, 55, 55, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 25%, 1) assert_equals: expected "rgb(72, 56, 56)" but got "rgb(71, 55, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 37.5%) assert_equals: expected "rgb(108, 84, 84)" but got "rgb(107, 83, 83)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 37.5%, 0) assert_equals: expected "rgba(108, 84, 84, 0)" but got "rgba(107, 83, 83, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(108, 84, 84, 0.2)" but got "rgba(107, 83, 83, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 37.5%, 1) assert_equals: expected "rgb(108, 84, 84)" but got "rgb(107, 83, 83)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 50%) assert_equals: expected "rgb(143, 112, 112)" but got "rgb(143, 111, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 50%, 0) assert_equals: expected "rgba(143, 112, 112, 0)" but got "rgba(143, 111, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 50%, 0.2) assert_equals: expected "rgba(143, 112, 112, 0.2)" but got "rgba(143, 111, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 50%, 1) assert_equals: expected "rgb(143, 112, 112)" but got "rgb(143, 111, 111)"
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 62.5%, 0.2) 
@@ -75,22 +75,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 25%, 12.5%) assert_equals: expected "rgb(40, 24, 24)" but got "rgb(39, 23, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 12.5%, 0) assert_equals: expected "rgba(40, 24, 24, 0)" but got "rgba(39, 23, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 12.5%, 0.2) assert_equals: expected "rgba(40, 24, 24, 0.2)" but got "rgba(39, 23, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 12.5%, 1) assert_equals: expected "rgb(40, 24, 24)" but got "rgb(39, 23, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 25%, 25%) assert_equals: expected "rgb(80, 48, 48)" but got "rgb(79, 47, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 25%, 0) assert_equals: expected "rgba(80, 48, 48, 0)" but got "rgba(79, 47, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 25%, 0.2) assert_equals: expected "rgba(80, 48, 48, 0.2)" but got "rgba(79, 47, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 25%, 1) assert_equals: expected "rgb(80, 48, 48)" but got "rgb(79, 47, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 25%, 37.5%) assert_equals: expected "rgb(120, 72, 72)" but got "rgb(119, 71, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 37.5%, 0) assert_equals: expected "rgba(120, 72, 72, 0)" but got "rgba(119, 71, 71, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 37.5%, 0.2) assert_equals: expected "rgba(120, 72, 72, 0.2)" but got "rgba(119, 71, 71, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 37.5%, 1) assert_equals: expected "rgb(120, 72, 72)" but got "rgb(119, 71, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 25%, 50%) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(159, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 50%, 0) assert_equals: expected "rgba(159, 96, 96, 0)" but got "rgba(159, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 50%, 0.2) assert_equals: expected "rgba(159, 96, 96, 0.2)" but got "rgba(159, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 50%, 1) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(159, 95, 95)"
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 62.5%, 0.2) 
@@ -111,26 +111,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 12.5%) assert_equals: expected "rgb(44, 20, 20)" but got "rgb(43, 19, 19)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 12.5%, 0) assert_equals: expected "rgba(44, 20, 20, 0)" but got "rgba(43, 19, 19, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(44, 20, 20, 0.2)" but got "rgba(43, 19, 19, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 12.5%, 1) assert_equals: expected "rgb(44, 20, 20)" but got "rgb(43, 19, 19)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 25%) assert_equals: expected "rgb(88, 40, 40)" but got "rgb(87, 39, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 25%, 0) assert_equals: expected "rgba(88, 40, 40, 0)" but got "rgba(87, 39, 39, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 25%, 0.2) assert_equals: expected "rgba(88, 40, 40, 0.2)" but got "rgba(87, 39, 39, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 25%, 1) assert_equals: expected "rgb(88, 40, 40)" but got "rgb(87, 39, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 37.5%) assert_equals: expected "rgb(131, 60, 60)" but got "rgb(131, 59, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 37.5%, 0) assert_equals: expected "rgba(131, 60, 60, 0)" but got "rgba(131, 59, 59, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(131, 60, 60, 0.2)" but got "rgba(131, 59, 59, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 37.5%, 1) assert_equals: expected "rgb(131, 60, 60)" but got "rgb(131, 59, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 50%) assert_equals: expected "rgb(175, 80, 80)" but got "rgb(175, 79, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 50%, 0) assert_equals: expected "rgba(175, 80, 80, 0)" but got "rgba(175, 79, 79, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 50%, 0.2) assert_equals: expected "rgba(175, 80, 80, 0.2)" but got "rgba(175, 79, 79, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 50%, 1) assert_equals: expected "rgb(175, 80, 80)" but got "rgb(175, 79, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 62.5%) assert_equals: expected "rgb(195, 124, 124)" but got "rgb(195, 123, 123)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 62.5%, 0) assert_equals: expected "rgba(195, 124, 124, 0)" but got "rgba(195, 123, 123, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(195, 124, 124, 0.2)" but got "rgba(195, 123, 123, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 62.5%, 1) assert_equals: expected "rgb(195, 124, 124)" but got "rgb(195, 123, 123)"
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 75%, 0.2) 
@@ -147,26 +147,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 50%, 12.5%) assert_equals: expected "rgb(48, 16, 16)" but got "rgb(47, 15, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 12.5%, 0) assert_equals: expected "rgba(48, 16, 16, 0)" but got "rgba(47, 15, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 12.5%, 0.2) assert_equals: expected "rgba(48, 16, 16, 0.2)" but got "rgba(47, 15, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 12.5%, 1) assert_equals: expected "rgb(48, 16, 16)" but got "rgb(47, 15, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 50%, 25%) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(95, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 25%, 0) assert_equals: expected "rgba(96, 32, 32, 0)" but got "rgba(95, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 25%, 0.2) assert_equals: expected "rgba(96, 32, 32, 0.2)" but got "rgba(95, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 25%, 1) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(95, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 50%, 37.5%) assert_equals: expected "rgb(143, 48, 48)" but got "rgb(143, 47, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 37.5%, 0) assert_equals: expected "rgba(143, 48, 48, 0)" but got "rgba(143, 47, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 37.5%, 0.2) assert_equals: expected "rgba(143, 48, 48, 0.2)" but got "rgba(143, 47, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 37.5%, 1) assert_equals: expected "rgb(143, 48, 48)" but got "rgb(143, 47, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 50%, 50%) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(191, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 50%, 0) assert_equals: expected "rgba(191, 64, 64, 0)" but got "rgba(191, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 50%, 0.2) assert_equals: expected "rgba(191, 64, 64, 0.2)" but got "rgba(191, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 50%, 1) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(191, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 50%, 62.5%) assert_equals: expected "rgb(207, 112, 112)" but got "rgb(207, 111, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 62.5%, 0) assert_equals: expected "rgba(207, 112, 112, 0)" but got "rgba(207, 111, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 62.5%, 0.2) assert_equals: expected "rgba(207, 112, 112, 0.2)" but got "rgba(207, 111, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 62.5%, 1) assert_equals: expected "rgb(207, 112, 112)" but got "rgb(207, 111, 111)"
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 75%, 0.2) 
@@ -183,26 +183,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 12.5%) assert_equals: expected "rgb(52, 12, 12)" but got "rgb(51, 11, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 12.5%, 0) assert_equals: expected "rgba(52, 12, 12, 0)" but got "rgba(51, 11, 11, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(52, 12, 12, 0.2)" but got "rgba(51, 11, 11, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 12.5%, 1) assert_equals: expected "rgb(52, 12, 12)" but got "rgb(51, 11, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 25%) assert_equals: expected "rgb(104, 24, 24)" but got "rgb(103, 23, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 25%, 0) assert_equals: expected "rgba(104, 24, 24, 0)" but got "rgba(103, 23, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 25%, 0.2) assert_equals: expected "rgba(104, 24, 24, 0.2)" but got "rgba(103, 23, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 25%, 1) assert_equals: expected "rgb(104, 24, 24)" but got "rgb(103, 23, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 37.5%) assert_equals: expected "rgb(155, 36, 36)" but got "rgb(155, 35, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 37.5%, 0) assert_equals: expected "rgba(155, 36, 36, 0)" but got "rgba(155, 35, 35, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(155, 36, 36, 0.2)" but got "rgba(155, 35, 35, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 37.5%, 1) assert_equals: expected "rgb(155, 36, 36)" but got "rgb(155, 35, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 50%) assert_equals: expected "rgb(207, 48, 48)" but got "rgb(207, 47, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 50%, 0) assert_equals: expected "rgba(207, 48, 48, 0)" but got "rgba(207, 47, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 50%, 0.2) assert_equals: expected "rgba(207, 48, 48, 0.2)" but got "rgba(207, 47, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 50%, 1) assert_equals: expected "rgb(207, 48, 48)" but got "rgb(207, 47, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 62.5%) assert_equals: expected "rgb(219, 100, 100)" but got "rgb(219, 99, 99)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 62.5%, 0) assert_equals: expected "rgba(219, 100, 100, 0)" but got "rgba(219, 99, 99, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(219, 100, 100, 0.2)" but got "rgba(219, 99, 99, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 62.5%, 1) assert_equals: expected "rgb(219, 100, 100)" but got "rgb(219, 99, 99)"
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 75%, 0.2) 
@@ -219,26 +219,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 75%, 12.5%) assert_equals: expected "rgb(56, 8, 8)" but got "rgb(55, 7, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 12.5%, 0) assert_equals: expected "rgba(56, 8, 8, 0)" but got "rgba(55, 7, 7, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 12.5%, 0.2) assert_equals: expected "rgba(56, 8, 8, 0.2)" but got "rgba(55, 7, 7, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 12.5%, 1) assert_equals: expected "rgb(56, 8, 8)" but got "rgb(55, 7, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 75%, 25%) assert_equals: expected "rgb(112, 16, 16)" but got "rgb(111, 15, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 25%, 0) assert_equals: expected "rgba(112, 16, 16, 0)" but got "rgba(111, 15, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 25%, 0.2) assert_equals: expected "rgba(112, 16, 16, 0.2)" but got "rgba(111, 15, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 25%, 1) assert_equals: expected "rgb(112, 16, 16)" but got "rgb(111, 15, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 75%, 37.5%) assert_equals: expected "rgb(167, 24, 24)" but got "rgb(167, 23, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 37.5%, 0) assert_equals: expected "rgba(167, 24, 24, 0)" but got "rgba(167, 23, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 37.5%, 0.2) assert_equals: expected "rgba(167, 24, 24, 0.2)" but got "rgba(167, 23, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 37.5%, 1) assert_equals: expected "rgb(167, 24, 24)" but got "rgb(167, 23, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 75%, 50%) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(223, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 50%, 0) assert_equals: expected "rgba(223, 32, 32, 0)" but got "rgba(223, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 50%, 0.2) assert_equals: expected "rgba(223, 32, 32, 0.2)" but got "rgba(223, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 50%, 1) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(223, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 75%, 62.5%) assert_equals: expected "rgb(231, 88, 88)" but got "rgb(231, 87, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 62.5%, 0) assert_equals: expected "rgba(231, 88, 88, 0)" but got "rgba(231, 87, 87, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 62.5%, 0.2) assert_equals: expected "rgba(231, 88, 88, 0.2)" but got "rgba(231, 87, 87, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 62.5%, 1) assert_equals: expected "rgb(231, 88, 88)" but got "rgb(231, 87, 87)"
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 75%, 0.2) 
@@ -255,26 +255,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 12.5%) assert_equals: expected "rgb(60, 4, 4)" but got "rgb(59, 3, 3)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 12.5%, 0) assert_equals: expected "rgba(60, 4, 4, 0)" but got "rgba(59, 3, 3, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(60, 4, 4, 0.2)" but got "rgba(59, 3, 3, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 12.5%, 1) assert_equals: expected "rgb(60, 4, 4)" but got "rgb(59, 3, 3)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 25%) assert_equals: expected "rgb(120, 8, 8)" but got "rgb(119, 7, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 25%, 0) assert_equals: expected "rgba(120, 8, 8, 0)" but got "rgba(119, 7, 7, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 25%, 0.2) assert_equals: expected "rgba(120, 8, 8, 0.2)" but got "rgba(119, 7, 7, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 25%, 1) assert_equals: expected "rgb(120, 8, 8)" but got "rgb(119, 7, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 37.5%) assert_equals: expected "rgb(179, 12, 12)" but got "rgb(179, 11, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 37.5%, 0) assert_equals: expected "rgba(179, 12, 12, 0)" but got "rgba(179, 11, 11, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(179, 12, 12, 0.2)" but got "rgba(179, 11, 11, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 37.5%, 1) assert_equals: expected "rgb(179, 12, 12)" but got "rgb(179, 11, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 50%) assert_equals: expected "rgb(239, 16, 16)" but got "rgb(239, 15, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 50%, 0) assert_equals: expected "rgba(239, 16, 16, 0)" but got "rgba(239, 15, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 50%, 0.2) assert_equals: expected "rgba(239, 16, 16, 0.2)" but got "rgba(239, 15, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 50%, 1) assert_equals: expected "rgb(239, 16, 16)" but got "rgb(239, 15, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 62.5%) assert_equals: expected "rgb(243, 76, 76)" but got "rgb(243, 75, 75)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 62.5%, 0) assert_equals: expected "rgba(243, 76, 76, 0)" but got "rgba(243, 75, 75, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(243, 76, 76, 0.2)" but got "rgba(243, 75, 75, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 62.5%, 1) assert_equals: expected "rgb(243, 76, 76)" but got "rgb(243, 75, 75)"
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 75%, 0.2) 
@@ -291,14 +291,14 @@ PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 100%, 12.5%) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(63, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 12.5%, 0) assert_equals: expected "rgba(64, 0, 0, 0)" but got "rgba(63, 0, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 12.5%, 0.2) assert_equals: expected "rgba(64, 0, 0, 0.2)" but got "rgba(63, 0, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 12.5%, 1) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(63, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 100%, 25%) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(127, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 25%, 0) assert_equals: expected "rgba(128, 0, 0, 0)" but got "rgba(127, 0, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 25%, 0.2) assert_equals: expected "rgba(128, 0, 0, 0.2)" but got "rgba(127, 0, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 25%, 1) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(127, 0, 0)"
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 25%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 37.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 37.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 37.5%, 0.2) 
@@ -307,14 +307,14 @@ PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 50%)
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 50%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 50%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 50%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 100%, 62.5%) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(255, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 62.5%, 0) assert_equals: expected "rgba(255, 64, 64, 0)" but got "rgba(255, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 62.5%, 0.2) assert_equals: expected "rgba(255, 64, 64, 0.2)" but got "rgba(255, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 62.5%, 1) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(255, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(0, 100%, 75%) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(255, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 75%, 0) assert_equals: expected "rgba(255, 128, 128, 0)" but got "rgba(255, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 75%, 0.2) assert_equals: expected "rgba(255, 128, 128, 0.2)" but got "rgba(255, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 75%, 1) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(255, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 62.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 75%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 75%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 75%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 75%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 87.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 87.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 87.5%, 0.2) 
@@ -327,22 +327,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 62.5%, 0.2) 
@@ -363,22 +363,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 12.5%) assert_equals: expected "rgb(36, 32, 28)" but got "rgb(35, 31, 27)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 12.5%, 0) assert_equals: expected "rgba(36, 32, 28, 0)" but got "rgba(35, 31, 27, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(36, 32, 28, 0.2)" but got "rgba(35, 31, 27, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 12.5%, 1) assert_equals: expected "rgb(36, 32, 28)" but got "rgb(35, 31, 27)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 25%) assert_equals: expected "rgb(72, 64, 56)" but got "rgb(71, 63, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 25%, 0) assert_equals: expected "rgba(72, 64, 56, 0)" but got "rgba(71, 63, 55, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 25%, 0.2) assert_equals: expected "rgba(72, 64, 56, 0.2)" but got "rgba(71, 63, 55, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 25%, 1) assert_equals: expected "rgb(72, 64, 56)" but got "rgb(71, 63, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 37.5%) assert_equals: expected "rgb(108, 96, 84)" but got "rgb(107, 95, 83)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 37.5%, 0) assert_equals: expected "rgba(108, 96, 84, 0)" but got "rgba(107, 95, 83, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(108, 96, 84, 0.2)" but got "rgba(107, 95, 83, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 37.5%, 1) assert_equals: expected "rgb(108, 96, 84)" but got "rgb(107, 95, 83)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 50%) assert_equals: expected "rgb(143, 128, 112)" but got "rgb(143, 127, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 50%, 0) assert_equals: expected "rgba(143, 128, 112, 0)" but got "rgba(143, 127, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 50%, 0.2) assert_equals: expected "rgba(143, 128, 112, 0.2)" but got "rgba(143, 127, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 50%, 1) assert_equals: expected "rgb(143, 128, 112)" but got "rgb(143, 127, 111)"
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 62.5%, 0.2) 
@@ -399,22 +399,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 25%, 12.5%) assert_equals: expected "rgb(40, 32, 24)" but got "rgb(39, 31, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 12.5%, 0) assert_equals: expected "rgba(40, 32, 24, 0)" but got "rgba(39, 31, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 12.5%, 0.2) assert_equals: expected "rgba(40, 32, 24, 0.2)" but got "rgba(39, 31, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 12.5%, 1) assert_equals: expected "rgb(40, 32, 24)" but got "rgb(39, 31, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 25%, 25%) assert_equals: expected "rgb(80, 64, 48)" but got "rgb(79, 63, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 25%, 0) assert_equals: expected "rgba(80, 64, 48, 0)" but got "rgba(79, 63, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 25%, 0.2) assert_equals: expected "rgba(80, 64, 48, 0.2)" but got "rgba(79, 63, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 25%, 1) assert_equals: expected "rgb(80, 64, 48)" but got "rgb(79, 63, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 25%, 37.5%) assert_equals: expected "rgb(120, 96, 72)" but got "rgb(119, 95, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 37.5%, 0) assert_equals: expected "rgba(120, 96, 72, 0)" but got "rgba(119, 95, 71, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 37.5%, 0.2) assert_equals: expected "rgba(120, 96, 72, 0.2)" but got "rgba(119, 95, 71, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 37.5%, 1) assert_equals: expected "rgb(120, 96, 72)" but got "rgb(119, 95, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 25%, 50%) assert_equals: expected "rgb(159, 128, 96)" but got "rgb(159, 127, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 50%, 0) assert_equals: expected "rgba(159, 128, 96, 0)" but got "rgba(159, 127, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 50%, 0.2) assert_equals: expected "rgba(159, 128, 96, 0.2)" but got "rgba(159, 127, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 50%, 1) assert_equals: expected "rgb(159, 128, 96)" but got "rgb(159, 127, 95)"
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 62.5%, 0.2) 
@@ -435,26 +435,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 12.5%) assert_equals: expected "rgb(44, 32, 20)" but got "rgb(43, 31, 19)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 12.5%, 0) assert_equals: expected "rgba(44, 32, 20, 0)" but got "rgba(43, 31, 19, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(44, 32, 20, 0.2)" but got "rgba(43, 31, 19, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 12.5%, 1) assert_equals: expected "rgb(44, 32, 20)" but got "rgb(43, 31, 19)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 25%) assert_equals: expected "rgb(88, 64, 40)" but got "rgb(87, 63, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 25%, 0) assert_equals: expected "rgba(88, 64, 40, 0)" but got "rgba(87, 63, 39, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 25%, 0.2) assert_equals: expected "rgba(88, 64, 40, 0.2)" but got "rgba(87, 63, 39, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 25%, 1) assert_equals: expected "rgb(88, 64, 40)" but got "rgb(87, 63, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 37.5%) assert_equals: expected "rgb(131, 96, 60)" but got "rgb(131, 95, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 37.5%, 0) assert_equals: expected "rgba(131, 96, 60, 0)" but got "rgba(131, 95, 59, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(131, 96, 60, 0.2)" but got "rgba(131, 95, 59, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 37.5%, 1) assert_equals: expected "rgb(131, 96, 60)" but got "rgb(131, 95, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 50%) assert_equals: expected "rgb(175, 128, 80)" but got "rgb(175, 127, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 50%, 0) assert_equals: expected "rgba(175, 128, 80, 0)" but got "rgba(175, 127, 79, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 50%, 0.2) assert_equals: expected "rgba(175, 128, 80, 0.2)" but got "rgba(175, 127, 79, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 50%, 1) assert_equals: expected "rgb(175, 128, 80)" but got "rgb(175, 127, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 62.5%) assert_equals: expected "rgb(195, 159, 124)" but got "rgb(195, 159, 123)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 62.5%, 0) assert_equals: expected "rgba(195, 159, 124, 0)" but got "rgba(195, 159, 123, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(195, 159, 124, 0.2)" but got "rgba(195, 159, 123, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 62.5%, 1) assert_equals: expected "rgb(195, 159, 124)" but got "rgb(195, 159, 123)"
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 75%, 0.2) 
@@ -471,26 +471,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 50%, 12.5%) assert_equals: expected "rgb(48, 32, 16)" but got "rgb(47, 31, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 12.5%, 0) assert_equals: expected "rgba(48, 32, 16, 0)" but got "rgba(47, 31, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 12.5%, 0.2) assert_equals: expected "rgba(48, 32, 16, 0.2)" but got "rgba(47, 31, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 12.5%, 1) assert_equals: expected "rgb(48, 32, 16)" but got "rgb(47, 31, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 50%, 25%) assert_equals: expected "rgb(96, 64, 32)" but got "rgb(95, 63, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 25%, 0) assert_equals: expected "rgba(96, 64, 32, 0)" but got "rgba(95, 63, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 25%, 0.2) assert_equals: expected "rgba(96, 64, 32, 0.2)" but got "rgba(95, 63, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 25%, 1) assert_equals: expected "rgb(96, 64, 32)" but got "rgb(95, 63, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 50%, 37.5%) assert_equals: expected "rgb(143, 96, 48)" but got "rgb(143, 95, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 37.5%, 0) assert_equals: expected "rgba(143, 96, 48, 0)" but got "rgba(143, 95, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 37.5%, 0.2) assert_equals: expected "rgba(143, 96, 48, 0.2)" but got "rgba(143, 95, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 37.5%, 1) assert_equals: expected "rgb(143, 96, 48)" but got "rgb(143, 95, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 50%, 50%) assert_equals: expected "rgb(191, 128, 64)" but got "rgb(191, 127, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 50%, 0) assert_equals: expected "rgba(191, 128, 64, 0)" but got "rgba(191, 127, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 50%, 0.2) assert_equals: expected "rgba(191, 128, 64, 0.2)" but got "rgba(191, 127, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 50%, 1) assert_equals: expected "rgb(191, 128, 64)" but got "rgb(191, 127, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 50%, 62.5%) assert_equals: expected "rgb(207, 159, 112)" but got "rgb(207, 159, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 62.5%, 0) assert_equals: expected "rgba(207, 159, 112, 0)" but got "rgba(207, 159, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 62.5%, 0.2) assert_equals: expected "rgba(207, 159, 112, 0.2)" but got "rgba(207, 159, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 62.5%, 1) assert_equals: expected "rgb(207, 159, 112)" but got "rgb(207, 159, 111)"
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 75%, 0.2) 
@@ -507,26 +507,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 12.5%) assert_equals: expected "rgb(52, 32, 12)" but got "rgb(51, 31, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 12.5%, 0) assert_equals: expected "rgba(52, 32, 12, 0)" but got "rgba(51, 31, 11, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(52, 32, 12, 0.2)" but got "rgba(51, 31, 11, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 12.5%, 1) assert_equals: expected "rgb(52, 32, 12)" but got "rgb(51, 31, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 25%) assert_equals: expected "rgb(104, 64, 24)" but got "rgb(103, 63, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 25%, 0) assert_equals: expected "rgba(104, 64, 24, 0)" but got "rgba(103, 63, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 25%, 0.2) assert_equals: expected "rgba(104, 64, 24, 0.2)" but got "rgba(103, 63, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 25%, 1) assert_equals: expected "rgb(104, 64, 24)" but got "rgb(103, 63, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 37.5%) assert_equals: expected "rgb(155, 96, 36)" but got "rgb(155, 95, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 37.5%, 0) assert_equals: expected "rgba(155, 96, 36, 0)" but got "rgba(155, 95, 35, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(155, 96, 36, 0.2)" but got "rgba(155, 95, 35, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 37.5%, 1) assert_equals: expected "rgb(155, 96, 36)" but got "rgb(155, 95, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 50%) assert_equals: expected "rgb(207, 128, 48)" but got "rgb(207, 127, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 50%, 0) assert_equals: expected "rgba(207, 128, 48, 0)" but got "rgba(207, 127, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 50%, 0.2) assert_equals: expected "rgba(207, 128, 48, 0.2)" but got "rgba(207, 127, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 50%, 1) assert_equals: expected "rgb(207, 128, 48)" but got "rgb(207, 127, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 62.5%) assert_equals: expected "rgb(219, 159, 100)" but got "rgb(219, 159, 99)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 62.5%, 0) assert_equals: expected "rgba(219, 159, 100, 0)" but got "rgba(219, 159, 99, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(219, 159, 100, 0.2)" but got "rgba(219, 159, 99, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 62.5%, 1) assert_equals: expected "rgb(219, 159, 100)" but got "rgb(219, 159, 99)"
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 75%, 0.2) 
@@ -543,26 +543,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 75%, 12.5%) assert_equals: expected "rgb(56, 32, 8)" but got "rgb(55, 31, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 12.5%, 0) assert_equals: expected "rgba(56, 32, 8, 0)" but got "rgba(55, 31, 7, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 12.5%, 0.2) assert_equals: expected "rgba(56, 32, 8, 0.2)" but got "rgba(55, 31, 7, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 12.5%, 1) assert_equals: expected "rgb(56, 32, 8)" but got "rgb(55, 31, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 75%, 25%) assert_equals: expected "rgb(112, 64, 16)" but got "rgb(111, 63, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 25%, 0) assert_equals: expected "rgba(112, 64, 16, 0)" but got "rgba(111, 63, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 25%, 0.2) assert_equals: expected "rgba(112, 64, 16, 0.2)" but got "rgba(111, 63, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 25%, 1) assert_equals: expected "rgb(112, 64, 16)" but got "rgb(111, 63, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 75%, 37.5%) assert_equals: expected "rgb(167, 96, 24)" but got "rgb(167, 95, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 37.5%, 0) assert_equals: expected "rgba(167, 96, 24, 0)" but got "rgba(167, 95, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 37.5%, 0.2) assert_equals: expected "rgba(167, 96, 24, 0.2)" but got "rgba(167, 95, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 37.5%, 1) assert_equals: expected "rgb(167, 96, 24)" but got "rgb(167, 95, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 75%, 50%) assert_equals: expected "rgb(223, 128, 32)" but got "rgb(223, 127, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 50%, 0) assert_equals: expected "rgba(223, 128, 32, 0)" but got "rgba(223, 127, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 50%, 0.2) assert_equals: expected "rgba(223, 128, 32, 0.2)" but got "rgba(223, 127, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 50%, 1) assert_equals: expected "rgb(223, 128, 32)" but got "rgb(223, 127, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 75%, 62.5%) assert_equals: expected "rgb(231, 159, 88)" but got "rgb(231, 159, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 62.5%, 0) assert_equals: expected "rgba(231, 159, 88, 0)" but got "rgba(231, 159, 87, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 62.5%, 0.2) assert_equals: expected "rgba(231, 159, 88, 0.2)" but got "rgba(231, 159, 87, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 62.5%, 1) assert_equals: expected "rgb(231, 159, 88)" but got "rgb(231, 159, 87)"
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 75%, 0.2) 
@@ -579,26 +579,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 12.5%) assert_equals: expected "rgb(60, 32, 4)" but got "rgb(59, 31, 3)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 12.5%, 0) assert_equals: expected "rgba(60, 32, 4, 0)" but got "rgba(59, 31, 3, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(60, 32, 4, 0.2)" but got "rgba(59, 31, 3, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 12.5%, 1) assert_equals: expected "rgb(60, 32, 4)" but got "rgb(59, 31, 3)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 25%) assert_equals: expected "rgb(120, 64, 8)" but got "rgb(119, 63, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 25%, 0) assert_equals: expected "rgba(120, 64, 8, 0)" but got "rgba(119, 63, 7, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 25%, 0.2) assert_equals: expected "rgba(120, 64, 8, 0.2)" but got "rgba(119, 63, 7, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 25%, 1) assert_equals: expected "rgb(120, 64, 8)" but got "rgb(119, 63, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 37.5%) assert_equals: expected "rgb(179, 96, 12)" but got "rgb(179, 95, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 37.5%, 0) assert_equals: expected "rgba(179, 96, 12, 0)" but got "rgba(179, 95, 11, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(179, 96, 12, 0.2)" but got "rgba(179, 95, 11, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 37.5%, 1) assert_equals: expected "rgb(179, 96, 12)" but got "rgb(179, 95, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 50%) assert_equals: expected "rgb(239, 128, 16)" but got "rgb(239, 127, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 50%, 0) assert_equals: expected "rgba(239, 128, 16, 0)" but got "rgba(239, 127, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 50%, 0.2) assert_equals: expected "rgba(239, 128, 16, 0.2)" but got "rgba(239, 127, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 50%, 1) assert_equals: expected "rgb(239, 128, 16)" but got "rgb(239, 127, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 62.5%) assert_equals: expected "rgb(243, 159, 76)" but got "rgb(243, 159, 75)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 62.5%, 0) assert_equals: expected "rgba(243, 159, 76, 0)" but got "rgba(243, 159, 75, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(243, 159, 76, 0.2)" but got "rgba(243, 159, 75, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 62.5%, 1) assert_equals: expected "rgb(243, 159, 76)" but got "rgb(243, 159, 75)"
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 75%, 0.2) 
@@ -615,30 +615,30 @@ PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 100%, 12.5%) assert_equals: expected "rgb(64, 32, 0)" but got "rgb(63, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 12.5%, 0) assert_equals: expected "rgba(64, 32, 0, 0)" but got "rgba(63, 31, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 12.5%, 0.2) assert_equals: expected "rgba(64, 32, 0, 0.2)" but got "rgba(63, 31, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 12.5%, 1) assert_equals: expected "rgb(64, 32, 0)" but got "rgb(63, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 100%, 25%) assert_equals: expected "rgb(128, 64, 0)" but got "rgb(127, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 25%, 0) assert_equals: expected "rgba(128, 64, 0, 0)" but got "rgba(127, 63, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 25%, 0.2) assert_equals: expected "rgba(128, 64, 0, 0.2)" but got "rgba(127, 63, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 25%, 1) assert_equals: expected "rgb(128, 64, 0)" but got "rgb(127, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 100%, 37.5%) assert_equals: expected "rgb(191, 96, 0)" but got "rgb(191, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 37.5%, 0) assert_equals: expected "rgba(191, 96, 0, 0)" but got "rgba(191, 95, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 37.5%, 0.2) assert_equals: expected "rgba(191, 96, 0, 0.2)" but got "rgba(191, 95, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 37.5%, 1) assert_equals: expected "rgb(191, 96, 0)" but got "rgb(191, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 100%, 50%) assert_equals: expected "rgb(255, 128, 0)" but got "rgb(255, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 50%, 0) assert_equals: expected "rgba(255, 128, 0, 0)" but got "rgba(255, 127, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 50%, 0.2) assert_equals: expected "rgba(255, 128, 0, 0.2)" but got "rgba(255, 127, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 50%, 1) assert_equals: expected "rgb(255, 128, 0)" but got "rgb(255, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 100%, 62.5%) assert_equals: expected "rgb(255, 159, 64)" but got "rgb(255, 159, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 62.5%, 0) assert_equals: expected "rgba(255, 159, 64, 0)" but got "rgba(255, 159, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 62.5%, 0.2) assert_equals: expected "rgba(255, 159, 64, 0.2)" but got "rgba(255, 159, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 62.5%, 1) assert_equals: expected "rgb(255, 159, 64)" but got "rgb(255, 159, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(30, 100%, 75%) assert_equals: expected "rgb(255, 191, 128)" but got "rgb(255, 191, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 75%, 0) assert_equals: expected "rgba(255, 191, 128, 0)" but got "rgba(255, 191, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 75%, 0.2) assert_equals: expected "rgba(255, 191, 128, 0.2)" but got "rgba(255, 191, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 75%, 1) assert_equals: expected "rgb(255, 191, 128)" but got "rgb(255, 191, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 62.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 75%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 75%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 75%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 75%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 87.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 87.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 87.5%, 0.2) 
@@ -651,22 +651,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 62.5%, 0.2) 
@@ -687,22 +687,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 12.5%) assert_equals: expected "rgb(36, 36, 28)" but got "rgb(35, 35, 27)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 12.5%, 0) assert_equals: expected "rgba(36, 36, 28, 0)" but got "rgba(35, 35, 27, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(36, 36, 28, 0.2)" but got "rgba(35, 35, 27, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 12.5%, 1) assert_equals: expected "rgb(36, 36, 28)" but got "rgb(35, 35, 27)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 25%) assert_equals: expected "rgb(72, 72, 56)" but got "rgb(71, 71, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 25%, 0) assert_equals: expected "rgba(72, 72, 56, 0)" but got "rgba(71, 71, 55, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 25%, 0.2) assert_equals: expected "rgba(72, 72, 56, 0.2)" but got "rgba(71, 71, 55, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 25%, 1) assert_equals: expected "rgb(72, 72, 56)" but got "rgb(71, 71, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 37.5%) assert_equals: expected "rgb(108, 108, 84)" but got "rgb(107, 107, 83)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 37.5%, 0) assert_equals: expected "rgba(108, 108, 84, 0)" but got "rgba(107, 107, 83, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(108, 108, 84, 0.2)" but got "rgba(107, 107, 83, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 37.5%, 1) assert_equals: expected "rgb(108, 108, 84)" but got "rgb(107, 107, 83)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 50%) assert_equals: expected "rgb(143, 143, 112)" but got "rgb(143, 143, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 50%, 0) assert_equals: expected "rgba(143, 143, 112, 0)" but got "rgba(143, 143, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 50%, 0.2) assert_equals: expected "rgba(143, 143, 112, 0.2)" but got "rgba(143, 143, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 50%, 1) assert_equals: expected "rgb(143, 143, 112)" but got "rgb(143, 143, 111)"
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 62.5%, 0.2) 
@@ -723,22 +723,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 25%, 12.5%) assert_equals: expected "rgb(40, 40, 24)" but got "rgb(39, 39, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 12.5%, 0) assert_equals: expected "rgba(40, 40, 24, 0)" but got "rgba(39, 39, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 12.5%, 0.2) assert_equals: expected "rgba(40, 40, 24, 0.2)" but got "rgba(39, 39, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 12.5%, 1) assert_equals: expected "rgb(40, 40, 24)" but got "rgb(39, 39, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 25%, 25%) assert_equals: expected "rgb(80, 80, 48)" but got "rgb(79, 79, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 25%, 0) assert_equals: expected "rgba(80, 80, 48, 0)" but got "rgba(79, 79, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 25%, 0.2) assert_equals: expected "rgba(80, 80, 48, 0.2)" but got "rgba(79, 79, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 25%, 1) assert_equals: expected "rgb(80, 80, 48)" but got "rgb(79, 79, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 25%, 37.5%) assert_equals: expected "rgb(120, 120, 72)" but got "rgb(119, 119, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 37.5%, 0) assert_equals: expected "rgba(120, 120, 72, 0)" but got "rgba(119, 119, 71, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 37.5%, 0.2) assert_equals: expected "rgba(120, 120, 72, 0.2)" but got "rgba(119, 119, 71, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 37.5%, 1) assert_equals: expected "rgb(120, 120, 72)" but got "rgb(119, 119, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 25%, 50%) assert_equals: expected "rgb(159, 159, 96)" but got "rgb(159, 159, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 50%, 0) assert_equals: expected "rgba(159, 159, 96, 0)" but got "rgba(159, 159, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 50%, 0.2) assert_equals: expected "rgba(159, 159, 96, 0.2)" but got "rgba(159, 159, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 50%, 1) assert_equals: expected "rgb(159, 159, 96)" but got "rgb(159, 159, 95)"
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 62.5%, 0.2) 
@@ -759,26 +759,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 12.5%) assert_equals: expected "rgb(44, 44, 20)" but got "rgb(43, 43, 19)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 12.5%, 0) assert_equals: expected "rgba(44, 44, 20, 0)" but got "rgba(43, 43, 19, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(44, 44, 20, 0.2)" but got "rgba(43, 43, 19, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 12.5%, 1) assert_equals: expected "rgb(44, 44, 20)" but got "rgb(43, 43, 19)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 25%) assert_equals: expected "rgb(88, 88, 40)" but got "rgb(87, 87, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 25%, 0) assert_equals: expected "rgba(88, 88, 40, 0)" but got "rgba(87, 87, 39, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 25%, 0.2) assert_equals: expected "rgba(88, 88, 40, 0.2)" but got "rgba(87, 87, 39, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 25%, 1) assert_equals: expected "rgb(88, 88, 40)" but got "rgb(87, 87, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 37.5%) assert_equals: expected "rgb(131, 131, 60)" but got "rgb(131, 131, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 37.5%, 0) assert_equals: expected "rgba(131, 131, 60, 0)" but got "rgba(131, 131, 59, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(131, 131, 60, 0.2)" but got "rgba(131, 131, 59, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 37.5%, 1) assert_equals: expected "rgb(131, 131, 60)" but got "rgb(131, 131, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 50%) assert_equals: expected "rgb(175, 175, 80)" but got "rgb(175, 175, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 50%, 0) assert_equals: expected "rgba(175, 175, 80, 0)" but got "rgba(175, 175, 79, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 50%, 0.2) assert_equals: expected "rgba(175, 175, 80, 0.2)" but got "rgba(175, 175, 79, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 50%, 1) assert_equals: expected "rgb(175, 175, 80)" but got "rgb(175, 175, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 62.5%) assert_equals: expected "rgb(195, 195, 124)" but got "rgb(195, 195, 123)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 62.5%, 0) assert_equals: expected "rgba(195, 195, 124, 0)" but got "rgba(195, 195, 123, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(195, 195, 124, 0.2)" but got "rgba(195, 195, 123, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 62.5%, 1) assert_equals: expected "rgb(195, 195, 124)" but got "rgb(195, 195, 123)"
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 75%, 0.2) 
@@ -795,26 +795,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 50%, 12.5%) assert_equals: expected "rgb(48, 48, 16)" but got "rgb(47, 47, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 12.5%, 0) assert_equals: expected "rgba(48, 48, 16, 0)" but got "rgba(47, 47, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 12.5%, 0.2) assert_equals: expected "rgba(48, 48, 16, 0.2)" but got "rgba(47, 47, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 12.5%, 1) assert_equals: expected "rgb(48, 48, 16)" but got "rgb(47, 47, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 50%, 25%) assert_equals: expected "rgb(96, 96, 32)" but got "rgb(95, 95, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 25%, 0) assert_equals: expected "rgba(96, 96, 32, 0)" but got "rgba(95, 95, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 25%, 0.2) assert_equals: expected "rgba(96, 96, 32, 0.2)" but got "rgba(95, 95, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 25%, 1) assert_equals: expected "rgb(96, 96, 32)" but got "rgb(95, 95, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 50%, 37.5%) assert_equals: expected "rgb(143, 143, 48)" but got "rgb(143, 143, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 37.5%, 0) assert_equals: expected "rgba(143, 143, 48, 0)" but got "rgba(143, 143, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 37.5%, 0.2) assert_equals: expected "rgba(143, 143, 48, 0.2)" but got "rgba(143, 143, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 37.5%, 1) assert_equals: expected "rgb(143, 143, 48)" but got "rgb(143, 143, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 50%, 50%) assert_equals: expected "rgb(191, 191, 64)" but got "rgb(191, 191, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 50%, 0) assert_equals: expected "rgba(191, 191, 64, 0)" but got "rgba(191, 191, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 50%, 0.2) assert_equals: expected "rgba(191, 191, 64, 0.2)" but got "rgba(191, 191, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 50%, 1) assert_equals: expected "rgb(191, 191, 64)" but got "rgb(191, 191, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 50%, 62.5%) assert_equals: expected "rgb(207, 207, 112)" but got "rgb(207, 207, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 62.5%, 0) assert_equals: expected "rgba(207, 207, 112, 0)" but got "rgba(207, 207, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 62.5%, 0.2) assert_equals: expected "rgba(207, 207, 112, 0.2)" but got "rgba(207, 207, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 62.5%, 1) assert_equals: expected "rgb(207, 207, 112)" but got "rgb(207, 207, 111)"
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 75%, 0.2) 
@@ -831,26 +831,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 12.5%) assert_equals: expected "rgb(52, 52, 12)" but got "rgb(51, 51, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 12.5%, 0) assert_equals: expected "rgba(52, 52, 12, 0)" but got "rgba(51, 51, 11, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(52, 52, 12, 0.2)" but got "rgba(51, 51, 11, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 12.5%, 1) assert_equals: expected "rgb(52, 52, 12)" but got "rgb(51, 51, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 25%) assert_equals: expected "rgb(104, 104, 24)" but got "rgb(103, 103, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 25%, 0) assert_equals: expected "rgba(104, 104, 24, 0)" but got "rgba(103, 103, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 25%, 0.2) assert_equals: expected "rgba(104, 104, 24, 0.2)" but got "rgba(103, 103, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 25%, 1) assert_equals: expected "rgb(104, 104, 24)" but got "rgb(103, 103, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 37.5%) assert_equals: expected "rgb(155, 155, 36)" but got "rgb(155, 155, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 37.5%, 0) assert_equals: expected "rgba(155, 155, 36, 0)" but got "rgba(155, 155, 35, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(155, 155, 36, 0.2)" but got "rgba(155, 155, 35, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 37.5%, 1) assert_equals: expected "rgb(155, 155, 36)" but got "rgb(155, 155, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 50%) assert_equals: expected "rgb(207, 207, 48)" but got "rgb(207, 207, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 50%, 0) assert_equals: expected "rgba(207, 207, 48, 0)" but got "rgba(207, 207, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 50%, 0.2) assert_equals: expected "rgba(207, 207, 48, 0.2)" but got "rgba(207, 207, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 50%, 1) assert_equals: expected "rgb(207, 207, 48)" but got "rgb(207, 207, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 62.5%) assert_equals: expected "rgb(219, 219, 100)" but got "rgb(219, 219, 99)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 62.5%, 0) assert_equals: expected "rgba(219, 219, 100, 0)" but got "rgba(219, 219, 99, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(219, 219, 100, 0.2)" but got "rgba(219, 219, 99, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 62.5%, 1) assert_equals: expected "rgb(219, 219, 100)" but got "rgb(219, 219, 99)"
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 75%, 0.2) 
@@ -867,26 +867,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 75%, 12.5%) assert_equals: expected "rgb(56, 56, 8)" but got "rgb(55, 55, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 12.5%, 0) assert_equals: expected "rgba(56, 56, 8, 0)" but got "rgba(55, 55, 7, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 12.5%, 0.2) assert_equals: expected "rgba(56, 56, 8, 0.2)" but got "rgba(55, 55, 7, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 12.5%, 1) assert_equals: expected "rgb(56, 56, 8)" but got "rgb(55, 55, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 75%, 25%) assert_equals: expected "rgb(112, 112, 16)" but got "rgb(111, 111, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 25%, 0) assert_equals: expected "rgba(112, 112, 16, 0)" but got "rgba(111, 111, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 25%, 0.2) assert_equals: expected "rgba(112, 112, 16, 0.2)" but got "rgba(111, 111, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 25%, 1) assert_equals: expected "rgb(112, 112, 16)" but got "rgb(111, 111, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 75%, 37.5%) assert_equals: expected "rgb(167, 167, 24)" but got "rgb(167, 167, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 37.5%, 0) assert_equals: expected "rgba(167, 167, 24, 0)" but got "rgba(167, 167, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 37.5%, 0.2) assert_equals: expected "rgba(167, 167, 24, 0.2)" but got "rgba(167, 167, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 37.5%, 1) assert_equals: expected "rgb(167, 167, 24)" but got "rgb(167, 167, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 75%, 50%) assert_equals: expected "rgb(223, 223, 32)" but got "rgb(223, 223, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 50%, 0) assert_equals: expected "rgba(223, 223, 32, 0)" but got "rgba(223, 223, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 50%, 0.2) assert_equals: expected "rgba(223, 223, 32, 0.2)" but got "rgba(223, 223, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 50%, 1) assert_equals: expected "rgb(223, 223, 32)" but got "rgb(223, 223, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 75%, 62.5%) assert_equals: expected "rgb(231, 231, 88)" but got "rgb(231, 231, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 62.5%, 0) assert_equals: expected "rgba(231, 231, 88, 0)" but got "rgba(231, 231, 87, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 62.5%, 0.2) assert_equals: expected "rgba(231, 231, 88, 0.2)" but got "rgba(231, 231, 87, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 62.5%, 1) assert_equals: expected "rgb(231, 231, 88)" but got "rgb(231, 231, 87)"
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 75%, 0.2) 
@@ -903,26 +903,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 12.5%) assert_equals: expected "rgb(60, 60, 4)" but got "rgb(59, 59, 3)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 12.5%, 0) assert_equals: expected "rgba(60, 60, 4, 0)" but got "rgba(59, 59, 3, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(60, 60, 4, 0.2)" but got "rgba(59, 59, 3, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 12.5%, 1) assert_equals: expected "rgb(60, 60, 4)" but got "rgb(59, 59, 3)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 25%) assert_equals: expected "rgb(120, 120, 8)" but got "rgb(119, 119, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 25%, 0) assert_equals: expected "rgba(120, 120, 8, 0)" but got "rgba(119, 119, 7, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 25%, 0.2) assert_equals: expected "rgba(120, 120, 8, 0.2)" but got "rgba(119, 119, 7, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 25%, 1) assert_equals: expected "rgb(120, 120, 8)" but got "rgb(119, 119, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 37.5%) assert_equals: expected "rgb(179, 179, 12)" but got "rgb(179, 179, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 37.5%, 0) assert_equals: expected "rgba(179, 179, 12, 0)" but got "rgba(179, 179, 11, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(179, 179, 12, 0.2)" but got "rgba(179, 179, 11, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 37.5%, 1) assert_equals: expected "rgb(179, 179, 12)" but got "rgb(179, 179, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 50%) assert_equals: expected "rgb(239, 239, 16)" but got "rgb(239, 239, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 50%, 0) assert_equals: expected "rgba(239, 239, 16, 0)" but got "rgba(239, 239, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 50%, 0.2) assert_equals: expected "rgba(239, 239, 16, 0.2)" but got "rgba(239, 239, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 50%, 1) assert_equals: expected "rgb(239, 239, 16)" but got "rgb(239, 239, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 62.5%) assert_equals: expected "rgb(243, 243, 76)" but got "rgb(243, 243, 75)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 62.5%, 0) assert_equals: expected "rgba(243, 243, 76, 0)" but got "rgba(243, 243, 75, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(243, 243, 76, 0.2)" but got "rgba(243, 243, 75, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 62.5%, 1) assert_equals: expected "rgb(243, 243, 76)" but got "rgb(243, 243, 75)"
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 75%, 0.2) 
@@ -939,14 +939,14 @@ PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 100%, 12.5%) assert_equals: expected "rgb(64, 64, 0)" but got "rgb(63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 12.5%, 0) assert_equals: expected "rgba(64, 64, 0, 0)" but got "rgba(63, 63, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 12.5%, 0.2) assert_equals: expected "rgba(64, 64, 0, 0.2)" but got "rgba(63, 63, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 12.5%, 1) assert_equals: expected "rgb(64, 64, 0)" but got "rgb(63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 100%, 25%) assert_equals: expected "rgb(128, 128, 0)" but got "rgb(127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 25%, 0) assert_equals: expected "rgba(128, 128, 0, 0)" but got "rgba(127, 127, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 25%, 0.2) assert_equals: expected "rgba(128, 128, 0, 0.2)" but got "rgba(127, 127, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 25%, 1) assert_equals: expected "rgb(128, 128, 0)" but got "rgb(127, 127, 0)"
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 25%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 37.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 37.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 37.5%, 0.2) 
@@ -955,14 +955,14 @@ PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 50%)
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 50%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 50%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 50%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 100%, 62.5%) assert_equals: expected "rgb(255, 255, 64)" but got "rgb(255, 255, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 62.5%, 0) assert_equals: expected "rgba(255, 255, 64, 0)" but got "rgba(255, 255, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 62.5%, 0.2) assert_equals: expected "rgba(255, 255, 64, 0.2)" but got "rgba(255, 255, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 62.5%, 1) assert_equals: expected "rgb(255, 255, 64)" but got "rgb(255, 255, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(60, 100%, 75%) assert_equals: expected "rgb(255, 255, 128)" but got "rgb(255, 255, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 75%, 0) assert_equals: expected "rgba(255, 255, 128, 0)" but got "rgba(255, 255, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 75%, 0.2) assert_equals: expected "rgba(255, 255, 128, 0.2)" but got "rgba(255, 255, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 75%, 1) assert_equals: expected "rgb(255, 255, 128)" but got "rgb(255, 255, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 62.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 75%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 75%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 75%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 75%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 87.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 87.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 87.5%, 0.2) 
@@ -975,22 +975,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 62.5%, 0.2) 
@@ -1011,22 +1011,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 12.5%) assert_equals: expected "rgb(32, 36, 28)" but got "rgb(31, 35, 27)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 12.5%, 0) assert_equals: expected "rgba(32, 36, 28, 0)" but got "rgba(31, 35, 27, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 36, 28, 0.2)" but got "rgba(31, 35, 27, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 12.5%, 1) assert_equals: expected "rgb(32, 36, 28)" but got "rgb(31, 35, 27)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 25%) assert_equals: expected "rgb(64, 72, 56)" but got "rgb(63, 71, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 25%, 0) assert_equals: expected "rgba(64, 72, 56, 0)" but got "rgba(63, 71, 55, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 25%, 0.2) assert_equals: expected "rgba(64, 72, 56, 0.2)" but got "rgba(63, 71, 55, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 25%, 1) assert_equals: expected "rgb(64, 72, 56)" but got "rgb(63, 71, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 37.5%) assert_equals: expected "rgb(96, 108, 84)" but got "rgb(95, 107, 83)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 37.5%, 0) assert_equals: expected "rgba(96, 108, 84, 0)" but got "rgba(95, 107, 83, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 108, 84, 0.2)" but got "rgba(95, 107, 83, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 37.5%, 1) assert_equals: expected "rgb(96, 108, 84)" but got "rgb(95, 107, 83)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 50%) assert_equals: expected "rgb(128, 143, 112)" but got "rgb(127, 143, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 50%, 0) assert_equals: expected "rgba(128, 143, 112, 0)" but got "rgba(127, 143, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 50%, 0.2) assert_equals: expected "rgba(128, 143, 112, 0.2)" but got "rgba(127, 143, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 50%, 1) assert_equals: expected "rgb(128, 143, 112)" but got "rgb(127, 143, 111)"
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 62.5%, 0.2) 
@@ -1047,22 +1047,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 25%, 12.5%) assert_equals: expected "rgb(32, 40, 24)" but got "rgb(31, 39, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 12.5%, 0) assert_equals: expected "rgba(32, 40, 24, 0)" but got "rgba(31, 39, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 12.5%, 0.2) assert_equals: expected "rgba(32, 40, 24, 0.2)" but got "rgba(31, 39, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 12.5%, 1) assert_equals: expected "rgb(32, 40, 24)" but got "rgb(31, 39, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 25%, 25%) assert_equals: expected "rgb(64, 80, 48)" but got "rgb(63, 79, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 25%, 0) assert_equals: expected "rgba(64, 80, 48, 0)" but got "rgba(63, 79, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 25%, 0.2) assert_equals: expected "rgba(64, 80, 48, 0.2)" but got "rgba(63, 79, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 25%, 1) assert_equals: expected "rgb(64, 80, 48)" but got "rgb(63, 79, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 25%, 37.5%) assert_equals: expected "rgb(96, 120, 72)" but got "rgb(95, 119, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 37.5%, 0) assert_equals: expected "rgba(96, 120, 72, 0)" but got "rgba(95, 119, 71, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 37.5%, 0.2) assert_equals: expected "rgba(96, 120, 72, 0.2)" but got "rgba(95, 119, 71, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 37.5%, 1) assert_equals: expected "rgb(96, 120, 72)" but got "rgb(95, 119, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 25%, 50%) assert_equals: expected "rgb(128, 159, 96)" but got "rgb(127, 159, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 50%, 0) assert_equals: expected "rgba(128, 159, 96, 0)" but got "rgba(127, 159, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 50%, 0.2) assert_equals: expected "rgba(128, 159, 96, 0.2)" but got "rgba(127, 159, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 50%, 1) assert_equals: expected "rgb(128, 159, 96)" but got "rgb(127, 159, 95)"
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 62.5%, 0.2) 
@@ -1083,26 +1083,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 12.5%) assert_equals: expected "rgb(32, 44, 20)" but got "rgb(31, 43, 19)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 12.5%, 0) assert_equals: expected "rgba(32, 44, 20, 0)" but got "rgba(31, 43, 19, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 44, 20, 0.2)" but got "rgba(31, 43, 19, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 12.5%, 1) assert_equals: expected "rgb(32, 44, 20)" but got "rgb(31, 43, 19)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 25%) assert_equals: expected "rgb(64, 88, 40)" but got "rgb(63, 87, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 25%, 0) assert_equals: expected "rgba(64, 88, 40, 0)" but got "rgba(63, 87, 39, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 25%, 0.2) assert_equals: expected "rgba(64, 88, 40, 0.2)" but got "rgba(63, 87, 39, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 25%, 1) assert_equals: expected "rgb(64, 88, 40)" but got "rgb(63, 87, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 37.5%) assert_equals: expected "rgb(96, 131, 60)" but got "rgb(95, 131, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 37.5%, 0) assert_equals: expected "rgba(96, 131, 60, 0)" but got "rgba(95, 131, 59, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 131, 60, 0.2)" but got "rgba(95, 131, 59, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 37.5%, 1) assert_equals: expected "rgb(96, 131, 60)" but got "rgb(95, 131, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 50%) assert_equals: expected "rgb(128, 175, 80)" but got "rgb(127, 175, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 50%, 0) assert_equals: expected "rgba(128, 175, 80, 0)" but got "rgba(127, 175, 79, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 50%, 0.2) assert_equals: expected "rgba(128, 175, 80, 0.2)" but got "rgba(127, 175, 79, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 50%, 1) assert_equals: expected "rgb(128, 175, 80)" but got "rgb(127, 175, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 62.5%) assert_equals: expected "rgb(159, 195, 124)" but got "rgb(159, 195, 123)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 62.5%, 0) assert_equals: expected "rgba(159, 195, 124, 0)" but got "rgba(159, 195, 123, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(159, 195, 124, 0.2)" but got "rgba(159, 195, 123, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 62.5%, 1) assert_equals: expected "rgb(159, 195, 124)" but got "rgb(159, 195, 123)"
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 75%, 0.2) 
@@ -1119,26 +1119,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 50%, 12.5%) assert_equals: expected "rgb(32, 48, 16)" but got "rgb(31, 47, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 12.5%, 0) assert_equals: expected "rgba(32, 48, 16, 0)" but got "rgba(31, 47, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 12.5%, 0.2) assert_equals: expected "rgba(32, 48, 16, 0.2)" but got "rgba(31, 47, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 12.5%, 1) assert_equals: expected "rgb(32, 48, 16)" but got "rgb(31, 47, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 50%, 25%) assert_equals: expected "rgb(64, 96, 32)" but got "rgb(63, 95, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 25%, 0) assert_equals: expected "rgba(64, 96, 32, 0)" but got "rgba(63, 95, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 25%, 0.2) assert_equals: expected "rgba(64, 96, 32, 0.2)" but got "rgba(63, 95, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 25%, 1) assert_equals: expected "rgb(64, 96, 32)" but got "rgb(63, 95, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 50%, 37.5%) assert_equals: expected "rgb(96, 143, 48)" but got "rgb(95, 143, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 37.5%, 0) assert_equals: expected "rgba(96, 143, 48, 0)" but got "rgba(95, 143, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 37.5%, 0.2) assert_equals: expected "rgba(96, 143, 48, 0.2)" but got "rgba(95, 143, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 37.5%, 1) assert_equals: expected "rgb(96, 143, 48)" but got "rgb(95, 143, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 50%, 50%) assert_equals: expected "rgb(128, 191, 64)" but got "rgb(127, 191, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 50%, 0) assert_equals: expected "rgba(128, 191, 64, 0)" but got "rgba(127, 191, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 50%, 0.2) assert_equals: expected "rgba(128, 191, 64, 0.2)" but got "rgba(127, 191, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 50%, 1) assert_equals: expected "rgb(128, 191, 64)" but got "rgb(127, 191, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 50%, 62.5%) assert_equals: expected "rgb(159, 207, 112)" but got "rgb(159, 207, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 62.5%, 0) assert_equals: expected "rgba(159, 207, 112, 0)" but got "rgba(159, 207, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 62.5%, 0.2) assert_equals: expected "rgba(159, 207, 112, 0.2)" but got "rgba(159, 207, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 62.5%, 1) assert_equals: expected "rgb(159, 207, 112)" but got "rgb(159, 207, 111)"
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 75%, 0.2) 
@@ -1155,26 +1155,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 12.5%) assert_equals: expected "rgb(32, 52, 12)" but got "rgb(31, 51, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 12.5%, 0) assert_equals: expected "rgba(32, 52, 12, 0)" but got "rgba(31, 51, 11, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 52, 12, 0.2)" but got "rgba(31, 51, 11, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 12.5%, 1) assert_equals: expected "rgb(32, 52, 12)" but got "rgb(31, 51, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 25%) assert_equals: expected "rgb(64, 104, 24)" but got "rgb(63, 103, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 25%, 0) assert_equals: expected "rgba(64, 104, 24, 0)" but got "rgba(63, 103, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 25%, 0.2) assert_equals: expected "rgba(64, 104, 24, 0.2)" but got "rgba(63, 103, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 25%, 1) assert_equals: expected "rgb(64, 104, 24)" but got "rgb(63, 103, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 37.5%) assert_equals: expected "rgb(96, 155, 36)" but got "rgb(95, 155, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 37.5%, 0) assert_equals: expected "rgba(96, 155, 36, 0)" but got "rgba(95, 155, 35, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 155, 36, 0.2)" but got "rgba(95, 155, 35, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 37.5%, 1) assert_equals: expected "rgb(96, 155, 36)" but got "rgb(95, 155, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 50%) assert_equals: expected "rgb(128, 207, 48)" but got "rgb(127, 207, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 50%, 0) assert_equals: expected "rgba(128, 207, 48, 0)" but got "rgba(127, 207, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 50%, 0.2) assert_equals: expected "rgba(128, 207, 48, 0.2)" but got "rgba(127, 207, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 50%, 1) assert_equals: expected "rgb(128, 207, 48)" but got "rgb(127, 207, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 62.5%) assert_equals: expected "rgb(159, 219, 100)" but got "rgb(159, 219, 99)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 62.5%, 0) assert_equals: expected "rgba(159, 219, 100, 0)" but got "rgba(159, 219, 99, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(159, 219, 100, 0.2)" but got "rgba(159, 219, 99, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 62.5%, 1) assert_equals: expected "rgb(159, 219, 100)" but got "rgb(159, 219, 99)"
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 75%, 0.2) 
@@ -1191,26 +1191,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 75%, 12.5%) assert_equals: expected "rgb(32, 56, 8)" but got "rgb(31, 55, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 12.5%, 0) assert_equals: expected "rgba(32, 56, 8, 0)" but got "rgba(31, 55, 7, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 12.5%, 0.2) assert_equals: expected "rgba(32, 56, 8, 0.2)" but got "rgba(31, 55, 7, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 12.5%, 1) assert_equals: expected "rgb(32, 56, 8)" but got "rgb(31, 55, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 75%, 25%) assert_equals: expected "rgb(64, 112, 16)" but got "rgb(63, 111, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 25%, 0) assert_equals: expected "rgba(64, 112, 16, 0)" but got "rgba(63, 111, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 25%, 0.2) assert_equals: expected "rgba(64, 112, 16, 0.2)" but got "rgba(63, 111, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 25%, 1) assert_equals: expected "rgb(64, 112, 16)" but got "rgb(63, 111, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 75%, 37.5%) assert_equals: expected "rgb(96, 167, 24)" but got "rgb(95, 167, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 37.5%, 0) assert_equals: expected "rgba(96, 167, 24, 0)" but got "rgba(95, 167, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 37.5%, 0.2) assert_equals: expected "rgba(96, 167, 24, 0.2)" but got "rgba(95, 167, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 37.5%, 1) assert_equals: expected "rgb(96, 167, 24)" but got "rgb(95, 167, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 75%, 50%) assert_equals: expected "rgb(128, 223, 32)" but got "rgb(127, 223, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 50%, 0) assert_equals: expected "rgba(128, 223, 32, 0)" but got "rgba(127, 223, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 50%, 0.2) assert_equals: expected "rgba(128, 223, 32, 0.2)" but got "rgba(127, 223, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 50%, 1) assert_equals: expected "rgb(128, 223, 32)" but got "rgb(127, 223, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 75%, 62.5%) assert_equals: expected "rgb(159, 231, 88)" but got "rgb(159, 231, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 62.5%, 0) assert_equals: expected "rgba(159, 231, 88, 0)" but got "rgba(159, 231, 87, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 62.5%, 0.2) assert_equals: expected "rgba(159, 231, 88, 0.2)" but got "rgba(159, 231, 87, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 62.5%, 1) assert_equals: expected "rgb(159, 231, 88)" but got "rgb(159, 231, 87)"
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 75%, 0.2) 
@@ -1227,26 +1227,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 12.5%) assert_equals: expected "rgb(32, 60, 4)" but got "rgb(31, 59, 3)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 12.5%, 0) assert_equals: expected "rgba(32, 60, 4, 0)" but got "rgba(31, 59, 3, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 60, 4, 0.2)" but got "rgba(31, 59, 3, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 12.5%, 1) assert_equals: expected "rgb(32, 60, 4)" but got "rgb(31, 59, 3)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 25%) assert_equals: expected "rgb(64, 120, 8)" but got "rgb(63, 119, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 25%, 0) assert_equals: expected "rgba(64, 120, 8, 0)" but got "rgba(63, 119, 7, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 25%, 0.2) assert_equals: expected "rgba(64, 120, 8, 0.2)" but got "rgba(63, 119, 7, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 25%, 1) assert_equals: expected "rgb(64, 120, 8)" but got "rgb(63, 119, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 37.5%) assert_equals: expected "rgb(96, 179, 12)" but got "rgb(95, 179, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 37.5%, 0) assert_equals: expected "rgba(96, 179, 12, 0)" but got "rgba(95, 179, 11, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 179, 12, 0.2)" but got "rgba(95, 179, 11, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 37.5%, 1) assert_equals: expected "rgb(96, 179, 12)" but got "rgb(95, 179, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 50%) assert_equals: expected "rgb(128, 239, 16)" but got "rgb(127, 239, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 50%, 0) assert_equals: expected "rgba(128, 239, 16, 0)" but got "rgba(127, 239, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 50%, 0.2) assert_equals: expected "rgba(128, 239, 16, 0.2)" but got "rgba(127, 239, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 50%, 1) assert_equals: expected "rgb(128, 239, 16)" but got "rgb(127, 239, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 62.5%) assert_equals: expected "rgb(159, 243, 76)" but got "rgb(159, 243, 75)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 62.5%, 0) assert_equals: expected "rgba(159, 243, 76, 0)" but got "rgba(159, 243, 75, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(159, 243, 76, 0.2)" but got "rgba(159, 243, 75, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 62.5%, 1) assert_equals: expected "rgb(159, 243, 76)" but got "rgb(159, 243, 75)"
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 75%, 0.2) 
@@ -1263,30 +1263,30 @@ PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 100%, 12.5%) assert_equals: expected "rgb(32, 64, 0)" but got "rgb(31, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 12.5%, 0) assert_equals: expected "rgba(32, 64, 0, 0)" but got "rgba(31, 63, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 12.5%, 0.2) assert_equals: expected "rgba(32, 64, 0, 0.2)" but got "rgba(31, 63, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 12.5%, 1) assert_equals: expected "rgb(32, 64, 0)" but got "rgb(31, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 100%, 25%) assert_equals: expected "rgb(64, 128, 0)" but got "rgb(63, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 25%, 0) assert_equals: expected "rgba(64, 128, 0, 0)" but got "rgba(63, 127, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 25%, 0.2) assert_equals: expected "rgba(64, 128, 0, 0.2)" but got "rgba(63, 127, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 25%, 1) assert_equals: expected "rgb(64, 128, 0)" but got "rgb(63, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 100%, 37.5%) assert_equals: expected "rgb(96, 191, 0)" but got "rgb(95, 191, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 37.5%, 0) assert_equals: expected "rgba(96, 191, 0, 0)" but got "rgba(95, 191, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 37.5%, 0.2) assert_equals: expected "rgba(96, 191, 0, 0.2)" but got "rgba(95, 191, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 37.5%, 1) assert_equals: expected "rgb(96, 191, 0)" but got "rgb(95, 191, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 100%, 50%) assert_equals: expected "rgb(128, 255, 0)" but got "rgb(127, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 50%, 0) assert_equals: expected "rgba(128, 255, 0, 0)" but got "rgba(127, 255, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 50%, 0.2) assert_equals: expected "rgba(128, 255, 0, 0.2)" but got "rgba(127, 255, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 50%, 1) assert_equals: expected "rgb(128, 255, 0)" but got "rgb(127, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 100%, 62.5%) assert_equals: expected "rgb(159, 255, 64)" but got "rgb(159, 255, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 62.5%, 0) assert_equals: expected "rgba(159, 255, 64, 0)" but got "rgba(159, 255, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 62.5%, 0.2) assert_equals: expected "rgba(159, 255, 64, 0.2)" but got "rgba(159, 255, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 62.5%, 1) assert_equals: expected "rgb(159, 255, 64)" but got "rgb(159, 255, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(90, 100%, 75%) assert_equals: expected "rgb(191, 255, 128)" but got "rgb(191, 255, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 75%, 0) assert_equals: expected "rgba(191, 255, 128, 0)" but got "rgba(191, 255, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 75%, 0.2) assert_equals: expected "rgba(191, 255, 128, 0.2)" but got "rgba(191, 255, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 75%, 1) assert_equals: expected "rgb(191, 255, 128)" but got "rgb(191, 255, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 62.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 75%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 75%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 75%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 75%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 87.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 87.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 87.5%, 0.2) 
@@ -1299,22 +1299,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 62.5%, 0.2) 
@@ -1335,22 +1335,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 12.5%) assert_equals: expected "rgb(28, 36, 28)" but got "rgb(27, 35, 27)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 12.5%, 0) assert_equals: expected "rgba(28, 36, 28, 0)" but got "rgba(27, 35, 27, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(28, 36, 28, 0.2)" but got "rgba(27, 35, 27, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 12.5%, 1) assert_equals: expected "rgb(28, 36, 28)" but got "rgb(27, 35, 27)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 25%) assert_equals: expected "rgb(56, 72, 56)" but got "rgb(55, 71, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 25%, 0) assert_equals: expected "rgba(56, 72, 56, 0)" but got "rgba(55, 71, 55, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 25%, 0.2) assert_equals: expected "rgba(56, 72, 56, 0.2)" but got "rgba(55, 71, 55, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 25%, 1) assert_equals: expected "rgb(56, 72, 56)" but got "rgb(55, 71, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 37.5%) assert_equals: expected "rgb(84, 108, 84)" but got "rgb(83, 107, 83)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 37.5%, 0) assert_equals: expected "rgba(84, 108, 84, 0)" but got "rgba(83, 107, 83, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(84, 108, 84, 0.2)" but got "rgba(83, 107, 83, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 37.5%, 1) assert_equals: expected "rgb(84, 108, 84)" but got "rgb(83, 107, 83)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 50%) assert_equals: expected "rgb(112, 143, 112)" but got "rgb(111, 143, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 50%, 0) assert_equals: expected "rgba(112, 143, 112, 0)" but got "rgba(111, 143, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 50%, 0.2) assert_equals: expected "rgba(112, 143, 112, 0.2)" but got "rgba(111, 143, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 50%, 1) assert_equals: expected "rgb(112, 143, 112)" but got "rgb(111, 143, 111)"
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 62.5%, 0.2) 
@@ -1371,22 +1371,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 25%, 12.5%) assert_equals: expected "rgb(24, 40, 24)" but got "rgb(23, 39, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 12.5%, 0) assert_equals: expected "rgba(24, 40, 24, 0)" but got "rgba(23, 39, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 12.5%, 0.2) assert_equals: expected "rgba(24, 40, 24, 0.2)" but got "rgba(23, 39, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 12.5%, 1) assert_equals: expected "rgb(24, 40, 24)" but got "rgb(23, 39, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 25%, 25%) assert_equals: expected "rgb(48, 80, 48)" but got "rgb(47, 79, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 25%, 0) assert_equals: expected "rgba(48, 80, 48, 0)" but got "rgba(47, 79, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 25%, 0.2) assert_equals: expected "rgba(48, 80, 48, 0.2)" but got "rgba(47, 79, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 25%, 1) assert_equals: expected "rgb(48, 80, 48)" but got "rgb(47, 79, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 25%, 37.5%) assert_equals: expected "rgb(72, 120, 72)" but got "rgb(71, 119, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 37.5%, 0) assert_equals: expected "rgba(72, 120, 72, 0)" but got "rgba(71, 119, 71, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 37.5%, 0.2) assert_equals: expected "rgba(72, 120, 72, 0.2)" but got "rgba(71, 119, 71, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 37.5%, 1) assert_equals: expected "rgb(72, 120, 72)" but got "rgb(71, 119, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 25%, 50%) assert_equals: expected "rgb(96, 159, 96)" but got "rgb(95, 159, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 50%, 0) assert_equals: expected "rgba(96, 159, 96, 0)" but got "rgba(95, 159, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 50%, 0.2) assert_equals: expected "rgba(96, 159, 96, 0.2)" but got "rgba(95, 159, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 50%, 1) assert_equals: expected "rgb(96, 159, 96)" but got "rgb(95, 159, 95)"
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 62.5%, 0.2) 
@@ -1407,26 +1407,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 12.5%) assert_equals: expected "rgb(20, 44, 20)" but got "rgb(19, 43, 19)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 12.5%, 0) assert_equals: expected "rgba(20, 44, 20, 0)" but got "rgba(19, 43, 19, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(20, 44, 20, 0.2)" but got "rgba(19, 43, 19, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 12.5%, 1) assert_equals: expected "rgb(20, 44, 20)" but got "rgb(19, 43, 19)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 25%) assert_equals: expected "rgb(40, 88, 40)" but got "rgb(39, 87, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 25%, 0) assert_equals: expected "rgba(40, 88, 40, 0)" but got "rgba(39, 87, 39, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 25%, 0.2) assert_equals: expected "rgba(40, 88, 40, 0.2)" but got "rgba(39, 87, 39, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 25%, 1) assert_equals: expected "rgb(40, 88, 40)" but got "rgb(39, 87, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 37.5%) assert_equals: expected "rgb(60, 131, 60)" but got "rgb(59, 131, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 37.5%, 0) assert_equals: expected "rgba(60, 131, 60, 0)" but got "rgba(59, 131, 59, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(60, 131, 60, 0.2)" but got "rgba(59, 131, 59, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 37.5%, 1) assert_equals: expected "rgb(60, 131, 60)" but got "rgb(59, 131, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 50%) assert_equals: expected "rgb(80, 175, 80)" but got "rgb(79, 175, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 50%, 0) assert_equals: expected "rgba(80, 175, 80, 0)" but got "rgba(79, 175, 79, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 50%, 0.2) assert_equals: expected "rgba(80, 175, 80, 0.2)" but got "rgba(79, 175, 79, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 50%, 1) assert_equals: expected "rgb(80, 175, 80)" but got "rgb(79, 175, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 62.5%) assert_equals: expected "rgb(124, 195, 124)" but got "rgb(123, 195, 123)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 62.5%, 0) assert_equals: expected "rgba(124, 195, 124, 0)" but got "rgba(123, 195, 123, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(124, 195, 124, 0.2)" but got "rgba(123, 195, 123, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 62.5%, 1) assert_equals: expected "rgb(124, 195, 124)" but got "rgb(123, 195, 123)"
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 75%, 0.2) 
@@ -1443,26 +1443,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 50%, 12.5%) assert_equals: expected "rgb(16, 48, 16)" but got "rgb(15, 47, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 12.5%, 0) assert_equals: expected "rgba(16, 48, 16, 0)" but got "rgba(15, 47, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 12.5%, 0.2) assert_equals: expected "rgba(16, 48, 16, 0.2)" but got "rgba(15, 47, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 12.5%, 1) assert_equals: expected "rgb(16, 48, 16)" but got "rgb(15, 47, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 50%, 25%) assert_equals: expected "rgb(32, 96, 32)" but got "rgb(31, 95, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 25%, 0) assert_equals: expected "rgba(32, 96, 32, 0)" but got "rgba(31, 95, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 25%, 0.2) assert_equals: expected "rgba(32, 96, 32, 0.2)" but got "rgba(31, 95, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 25%, 1) assert_equals: expected "rgb(32, 96, 32)" but got "rgb(31, 95, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 50%, 37.5%) assert_equals: expected "rgb(48, 143, 48)" but got "rgb(47, 143, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 37.5%, 0) assert_equals: expected "rgba(48, 143, 48, 0)" but got "rgba(47, 143, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 37.5%, 0.2) assert_equals: expected "rgba(48, 143, 48, 0.2)" but got "rgba(47, 143, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 37.5%, 1) assert_equals: expected "rgb(48, 143, 48)" but got "rgb(47, 143, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 50%, 50%) assert_equals: expected "rgb(64, 191, 64)" but got "rgb(63, 191, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 50%, 0) assert_equals: expected "rgba(64, 191, 64, 0)" but got "rgba(63, 191, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 50%, 0.2) assert_equals: expected "rgba(64, 191, 64, 0.2)" but got "rgba(63, 191, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 50%, 1) assert_equals: expected "rgb(64, 191, 64)" but got "rgb(63, 191, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 50%, 62.5%) assert_equals: expected "rgb(112, 207, 112)" but got "rgb(111, 207, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 62.5%, 0) assert_equals: expected "rgba(112, 207, 112, 0)" but got "rgba(111, 207, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 62.5%, 0.2) assert_equals: expected "rgba(112, 207, 112, 0.2)" but got "rgba(111, 207, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 62.5%, 1) assert_equals: expected "rgb(112, 207, 112)" but got "rgb(111, 207, 111)"
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 75%, 0.2) 
@@ -1479,26 +1479,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 12.5%) assert_equals: expected "rgb(12, 52, 12)" but got "rgb(11, 51, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 12.5%, 0) assert_equals: expected "rgba(12, 52, 12, 0)" but got "rgba(11, 51, 11, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(12, 52, 12, 0.2)" but got "rgba(11, 51, 11, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 12.5%, 1) assert_equals: expected "rgb(12, 52, 12)" but got "rgb(11, 51, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 25%) assert_equals: expected "rgb(24, 104, 24)" but got "rgb(23, 103, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 25%, 0) assert_equals: expected "rgba(24, 104, 24, 0)" but got "rgba(23, 103, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 25%, 0.2) assert_equals: expected "rgba(24, 104, 24, 0.2)" but got "rgba(23, 103, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 25%, 1) assert_equals: expected "rgb(24, 104, 24)" but got "rgb(23, 103, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 37.5%) assert_equals: expected "rgb(36, 155, 36)" but got "rgb(35, 155, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 37.5%, 0) assert_equals: expected "rgba(36, 155, 36, 0)" but got "rgba(35, 155, 35, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(36, 155, 36, 0.2)" but got "rgba(35, 155, 35, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 37.5%, 1) assert_equals: expected "rgb(36, 155, 36)" but got "rgb(35, 155, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 50%) assert_equals: expected "rgb(48, 207, 48)" but got "rgb(47, 207, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 50%, 0) assert_equals: expected "rgba(48, 207, 48, 0)" but got "rgba(47, 207, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 50%, 0.2) assert_equals: expected "rgba(48, 207, 48, 0.2)" but got "rgba(47, 207, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 50%, 1) assert_equals: expected "rgb(48, 207, 48)" but got "rgb(47, 207, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 62.5%) assert_equals: expected "rgb(100, 219, 100)" but got "rgb(99, 219, 99)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 62.5%, 0) assert_equals: expected "rgba(100, 219, 100, 0)" but got "rgba(99, 219, 99, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(100, 219, 100, 0.2)" but got "rgba(99, 219, 99, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 62.5%, 1) assert_equals: expected "rgb(100, 219, 100)" but got "rgb(99, 219, 99)"
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 75%, 0.2) 
@@ -1515,26 +1515,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 75%, 12.5%) assert_equals: expected "rgb(8, 56, 8)" but got "rgb(7, 55, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 12.5%, 0) assert_equals: expected "rgba(8, 56, 8, 0)" but got "rgba(7, 55, 7, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 12.5%, 0.2) assert_equals: expected "rgba(8, 56, 8, 0.2)" but got "rgba(7, 55, 7, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 12.5%, 1) assert_equals: expected "rgb(8, 56, 8)" but got "rgb(7, 55, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 75%, 25%) assert_equals: expected "rgb(16, 112, 16)" but got "rgb(15, 111, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 25%, 0) assert_equals: expected "rgba(16, 112, 16, 0)" but got "rgba(15, 111, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 25%, 0.2) assert_equals: expected "rgba(16, 112, 16, 0.2)" but got "rgba(15, 111, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 25%, 1) assert_equals: expected "rgb(16, 112, 16)" but got "rgb(15, 111, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 75%, 37.5%) assert_equals: expected "rgb(24, 167, 24)" but got "rgb(23, 167, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 37.5%, 0) assert_equals: expected "rgba(24, 167, 24, 0)" but got "rgba(23, 167, 23, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 37.5%, 0.2) assert_equals: expected "rgba(24, 167, 24, 0.2)" but got "rgba(23, 167, 23, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 37.5%, 1) assert_equals: expected "rgb(24, 167, 24)" but got "rgb(23, 167, 23)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 75%, 50%) assert_equals: expected "rgb(32, 223, 32)" but got "rgb(31, 223, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 50%, 0) assert_equals: expected "rgba(32, 223, 32, 0)" but got "rgba(31, 223, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 50%, 0.2) assert_equals: expected "rgba(32, 223, 32, 0.2)" but got "rgba(31, 223, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 50%, 1) assert_equals: expected "rgb(32, 223, 32)" but got "rgb(31, 223, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 75%, 62.5%) assert_equals: expected "rgb(88, 231, 88)" but got "rgb(87, 231, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 62.5%, 0) assert_equals: expected "rgba(88, 231, 88, 0)" but got "rgba(87, 231, 87, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 62.5%, 0.2) assert_equals: expected "rgba(88, 231, 88, 0.2)" but got "rgba(87, 231, 87, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 62.5%, 1) assert_equals: expected "rgb(88, 231, 88)" but got "rgb(87, 231, 87)"
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 75%, 0.2) 
@@ -1551,26 +1551,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 12.5%) assert_equals: expected "rgb(4, 60, 4)" but got "rgb(3, 59, 3)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 12.5%, 0) assert_equals: expected "rgba(4, 60, 4, 0)" but got "rgba(3, 59, 3, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(4, 60, 4, 0.2)" but got "rgba(3, 59, 3, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 12.5%, 1) assert_equals: expected "rgb(4, 60, 4)" but got "rgb(3, 59, 3)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 25%) assert_equals: expected "rgb(8, 120, 8)" but got "rgb(7, 119, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 25%, 0) assert_equals: expected "rgba(8, 120, 8, 0)" but got "rgba(7, 119, 7, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 25%, 0.2) assert_equals: expected "rgba(8, 120, 8, 0.2)" but got "rgba(7, 119, 7, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 25%, 1) assert_equals: expected "rgb(8, 120, 8)" but got "rgb(7, 119, 7)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 37.5%) assert_equals: expected "rgb(12, 179, 12)" but got "rgb(11, 179, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 37.5%, 0) assert_equals: expected "rgba(12, 179, 12, 0)" but got "rgba(11, 179, 11, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(12, 179, 12, 0.2)" but got "rgba(11, 179, 11, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 37.5%, 1) assert_equals: expected "rgb(12, 179, 12)" but got "rgb(11, 179, 11)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 50%) assert_equals: expected "rgb(16, 239, 16)" but got "rgb(15, 239, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 50%, 0) assert_equals: expected "rgba(16, 239, 16, 0)" but got "rgba(15, 239, 15, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 50%, 0.2) assert_equals: expected "rgba(16, 239, 16, 0.2)" but got "rgba(15, 239, 15, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 50%, 1) assert_equals: expected "rgb(16, 239, 16)" but got "rgb(15, 239, 15)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 62.5%) assert_equals: expected "rgb(76, 243, 76)" but got "rgb(75, 243, 75)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 62.5%, 0) assert_equals: expected "rgba(76, 243, 76, 0)" but got "rgba(75, 243, 75, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(76, 243, 76, 0.2)" but got "rgba(75, 243, 75, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 62.5%, 1) assert_equals: expected "rgb(76, 243, 76)" but got "rgb(75, 243, 75)"
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 75%, 0.2) 
@@ -1587,14 +1587,14 @@ PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 100%, 12.5%) assert_equals: expected "rgb(0, 64, 0)" but got "rgb(0, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 12.5%, 0) assert_equals: expected "rgba(0, 64, 0, 0)" but got "rgba(0, 63, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 12.5%, 0.2) assert_equals: expected "rgba(0, 64, 0, 0.2)" but got "rgba(0, 63, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 12.5%, 1) assert_equals: expected "rgb(0, 64, 0)" but got "rgb(0, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 100%, 25%) assert_equals: expected "rgb(0, 128, 0)" but got "rgb(0, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 25%, 0) assert_equals: expected "rgba(0, 128, 0, 0)" but got "rgba(0, 127, 0, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 25%, 0.2) assert_equals: expected "rgba(0, 128, 0, 0.2)" but got "rgba(0, 127, 0, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 25%, 1) assert_equals: expected "rgb(0, 128, 0)" but got "rgb(0, 127, 0)"
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 25%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 37.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 37.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 37.5%, 0.2) 
@@ -1603,14 +1603,14 @@ PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 50%)
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 50%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 50%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 50%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 100%, 62.5%) assert_equals: expected "rgb(64, 255, 64)" but got "rgb(63, 255, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 62.5%, 0) assert_equals: expected "rgba(64, 255, 64, 0)" but got "rgba(63, 255, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 62.5%, 0.2) assert_equals: expected "rgba(64, 255, 64, 0.2)" but got "rgba(63, 255, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 62.5%, 1) assert_equals: expected "rgb(64, 255, 64)" but got "rgb(63, 255, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(120, 100%, 75%) assert_equals: expected "rgb(128, 255, 128)" but got "rgb(127, 255, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 75%, 0) assert_equals: expected "rgba(128, 255, 128, 0)" but got "rgba(127, 255, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 75%, 0.2) assert_equals: expected "rgba(128, 255, 128, 0.2)" but got "rgba(127, 255, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 75%, 1) assert_equals: expected "rgb(128, 255, 128)" but got "rgb(127, 255, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 62.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 75%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 75%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 75%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 75%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 87.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 87.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 87.5%, 0.2) 
@@ -1623,22 +1623,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 62.5%, 0.2) 
@@ -1659,22 +1659,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 12.5%) assert_equals: expected "rgb(28, 36, 36)" but got "rgb(27, 35, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 12.5%, 0) assert_equals: expected "rgba(28, 36, 36, 0)" but got "rgba(27, 35, 35, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(28, 36, 36, 0.2)" but got "rgba(27, 35, 35, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 12.5%, 1) assert_equals: expected "rgb(28, 36, 36)" but got "rgb(27, 35, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 25%) assert_equals: expected "rgb(56, 72, 72)" but got "rgb(55, 71, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 25%, 0) assert_equals: expected "rgba(56, 72, 72, 0)" but got "rgba(55, 71, 71, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 25%, 0.2) assert_equals: expected "rgba(56, 72, 72, 0.2)" but got "rgba(55, 71, 71, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 25%, 1) assert_equals: expected "rgb(56, 72, 72)" but got "rgb(55, 71, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 37.5%) assert_equals: expected "rgb(84, 108, 108)" but got "rgb(83, 107, 107)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 37.5%, 0) assert_equals: expected "rgba(84, 108, 108, 0)" but got "rgba(83, 107, 107, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(84, 108, 108, 0.2)" but got "rgba(83, 107, 107, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 37.5%, 1) assert_equals: expected "rgb(84, 108, 108)" but got "rgb(83, 107, 107)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 50%) assert_equals: expected "rgb(112, 143, 143)" but got "rgb(111, 143, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 50%, 0) assert_equals: expected "rgba(112, 143, 143, 0)" but got "rgba(111, 143, 143, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 50%, 0.2) assert_equals: expected "rgba(112, 143, 143, 0.2)" but got "rgba(111, 143, 143, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 50%, 1) assert_equals: expected "rgb(112, 143, 143)" but got "rgb(111, 143, 143)"
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 62.5%, 0.2) 
@@ -1695,22 +1695,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 25%, 12.5%) assert_equals: expected "rgb(24, 40, 40)" but got "rgb(23, 39, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 12.5%, 0) assert_equals: expected "rgba(24, 40, 40, 0)" but got "rgba(23, 39, 39, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 12.5%, 0.2) assert_equals: expected "rgba(24, 40, 40, 0.2)" but got "rgba(23, 39, 39, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 12.5%, 1) assert_equals: expected "rgb(24, 40, 40)" but got "rgb(23, 39, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 25%, 25%) assert_equals: expected "rgb(48, 80, 80)" but got "rgb(47, 79, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 25%, 0) assert_equals: expected "rgba(48, 80, 80, 0)" but got "rgba(47, 79, 79, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 25%, 0.2) assert_equals: expected "rgba(48, 80, 80, 0.2)" but got "rgba(47, 79, 79, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 25%, 1) assert_equals: expected "rgb(48, 80, 80)" but got "rgb(47, 79, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 25%, 37.5%) assert_equals: expected "rgb(72, 120, 120)" but got "rgb(71, 119, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 37.5%, 0) assert_equals: expected "rgba(72, 120, 120, 0)" but got "rgba(71, 119, 119, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 37.5%, 0.2) assert_equals: expected "rgba(72, 120, 120, 0.2)" but got "rgba(71, 119, 119, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 37.5%, 1) assert_equals: expected "rgb(72, 120, 120)" but got "rgb(71, 119, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 25%, 50%) assert_equals: expected "rgb(96, 159, 159)" but got "rgb(95, 159, 159)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 50%, 0) assert_equals: expected "rgba(96, 159, 159, 0)" but got "rgba(95, 159, 159, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 50%, 0.2) assert_equals: expected "rgba(96, 159, 159, 0.2)" but got "rgba(95, 159, 159, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 50%, 1) assert_equals: expected "rgb(96, 159, 159)" but got "rgb(95, 159, 159)"
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 62.5%, 0.2) 
@@ -1731,26 +1731,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 12.5%) assert_equals: expected "rgb(20, 44, 44)" but got "rgb(19, 43, 43)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 12.5%, 0) assert_equals: expected "rgba(20, 44, 44, 0)" but got "rgba(19, 43, 43, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(20, 44, 44, 0.2)" but got "rgba(19, 43, 43, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 12.5%, 1) assert_equals: expected "rgb(20, 44, 44)" but got "rgb(19, 43, 43)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 25%) assert_equals: expected "rgb(40, 88, 88)" but got "rgb(39, 87, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 25%, 0) assert_equals: expected "rgba(40, 88, 88, 0)" but got "rgba(39, 87, 87, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 25%, 0.2) assert_equals: expected "rgba(40, 88, 88, 0.2)" but got "rgba(39, 87, 87, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 25%, 1) assert_equals: expected "rgb(40, 88, 88)" but got "rgb(39, 87, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 37.5%) assert_equals: expected "rgb(60, 131, 131)" but got "rgb(59, 131, 131)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 37.5%, 0) assert_equals: expected "rgba(60, 131, 131, 0)" but got "rgba(59, 131, 131, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(60, 131, 131, 0.2)" but got "rgba(59, 131, 131, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 37.5%, 1) assert_equals: expected "rgb(60, 131, 131)" but got "rgb(59, 131, 131)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 50%) assert_equals: expected "rgb(80, 175, 175)" but got "rgb(79, 175, 175)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 50%, 0) assert_equals: expected "rgba(80, 175, 175, 0)" but got "rgba(79, 175, 175, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 50%, 0.2) assert_equals: expected "rgba(80, 175, 175, 0.2)" but got "rgba(79, 175, 175, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 50%, 1) assert_equals: expected "rgb(80, 175, 175)" but got "rgb(79, 175, 175)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 62.5%) assert_equals: expected "rgb(124, 195, 195)" but got "rgb(123, 195, 195)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 62.5%, 0) assert_equals: expected "rgba(124, 195, 195, 0)" but got "rgba(123, 195, 195, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(124, 195, 195, 0.2)" but got "rgba(123, 195, 195, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 62.5%, 1) assert_equals: expected "rgb(124, 195, 195)" but got "rgb(123, 195, 195)"
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 75%, 0.2) 
@@ -1767,26 +1767,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 50%, 12.5%) assert_equals: expected "rgb(16, 48, 48)" but got "rgb(15, 47, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 12.5%, 0) assert_equals: expected "rgba(16, 48, 48, 0)" but got "rgba(15, 47, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 12.5%, 0.2) assert_equals: expected "rgba(16, 48, 48, 0.2)" but got "rgba(15, 47, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 12.5%, 1) assert_equals: expected "rgb(16, 48, 48)" but got "rgb(15, 47, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 50%, 25%) assert_equals: expected "rgb(32, 96, 96)" but got "rgb(31, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 25%, 0) assert_equals: expected "rgba(32, 96, 96, 0)" but got "rgba(31, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 25%, 0.2) assert_equals: expected "rgba(32, 96, 96, 0.2)" but got "rgba(31, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 25%, 1) assert_equals: expected "rgb(32, 96, 96)" but got "rgb(31, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 50%, 37.5%) assert_equals: expected "rgb(48, 143, 143)" but got "rgb(47, 143, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 37.5%, 0) assert_equals: expected "rgba(48, 143, 143, 0)" but got "rgba(47, 143, 143, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 37.5%, 0.2) assert_equals: expected "rgba(48, 143, 143, 0.2)" but got "rgba(47, 143, 143, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 37.5%, 1) assert_equals: expected "rgb(48, 143, 143)" but got "rgb(47, 143, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 50%, 50%) assert_equals: expected "rgb(64, 191, 191)" but got "rgb(63, 191, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 50%, 0) assert_equals: expected "rgba(64, 191, 191, 0)" but got "rgba(63, 191, 191, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 50%, 0.2) assert_equals: expected "rgba(64, 191, 191, 0.2)" but got "rgba(63, 191, 191, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 50%, 1) assert_equals: expected "rgb(64, 191, 191)" but got "rgb(63, 191, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 50%, 62.5%) assert_equals: expected "rgb(112, 207, 207)" but got "rgb(111, 207, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 62.5%, 0) assert_equals: expected "rgba(112, 207, 207, 0)" but got "rgba(111, 207, 207, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 62.5%, 0.2) assert_equals: expected "rgba(112, 207, 207, 0.2)" but got "rgba(111, 207, 207, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 62.5%, 1) assert_equals: expected "rgb(112, 207, 207)" but got "rgb(111, 207, 207)"
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 75%, 0.2) 
@@ -1803,26 +1803,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 12.5%) assert_equals: expected "rgb(12, 52, 52)" but got "rgb(11, 51, 51)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 12.5%, 0) assert_equals: expected "rgba(12, 52, 52, 0)" but got "rgba(11, 51, 51, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(12, 52, 52, 0.2)" but got "rgba(11, 51, 51, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 12.5%, 1) assert_equals: expected "rgb(12, 52, 52)" but got "rgb(11, 51, 51)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 25%) assert_equals: expected "rgb(24, 104, 104)" but got "rgb(23, 103, 103)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 25%, 0) assert_equals: expected "rgba(24, 104, 104, 0)" but got "rgba(23, 103, 103, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 25%, 0.2) assert_equals: expected "rgba(24, 104, 104, 0.2)" but got "rgba(23, 103, 103, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 25%, 1) assert_equals: expected "rgb(24, 104, 104)" but got "rgb(23, 103, 103)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 37.5%) assert_equals: expected "rgb(36, 155, 155)" but got "rgb(35, 155, 155)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 37.5%, 0) assert_equals: expected "rgba(36, 155, 155, 0)" but got "rgba(35, 155, 155, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(36, 155, 155, 0.2)" but got "rgba(35, 155, 155, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 37.5%, 1) assert_equals: expected "rgb(36, 155, 155)" but got "rgb(35, 155, 155)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 50%) assert_equals: expected "rgb(48, 207, 207)" but got "rgb(47, 207, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 50%, 0) assert_equals: expected "rgba(48, 207, 207, 0)" but got "rgba(47, 207, 207, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 50%, 0.2) assert_equals: expected "rgba(48, 207, 207, 0.2)" but got "rgba(47, 207, 207, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 50%, 1) assert_equals: expected "rgb(48, 207, 207)" but got "rgb(47, 207, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 62.5%) assert_equals: expected "rgb(100, 219, 219)" but got "rgb(99, 219, 219)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 62.5%, 0) assert_equals: expected "rgba(100, 219, 219, 0)" but got "rgba(99, 219, 219, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(100, 219, 219, 0.2)" but got "rgba(99, 219, 219, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 62.5%, 1) assert_equals: expected "rgb(100, 219, 219)" but got "rgb(99, 219, 219)"
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 75%, 0.2) 
@@ -1839,26 +1839,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 75%, 12.5%) assert_equals: expected "rgb(8, 56, 56)" but got "rgb(7, 55, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 12.5%, 0) assert_equals: expected "rgba(8, 56, 56, 0)" but got "rgba(7, 55, 55, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 12.5%, 0.2) assert_equals: expected "rgba(8, 56, 56, 0.2)" but got "rgba(7, 55, 55, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 12.5%, 1) assert_equals: expected "rgb(8, 56, 56)" but got "rgb(7, 55, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 75%, 25%) assert_equals: expected "rgb(16, 112, 112)" but got "rgb(15, 111, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 25%, 0) assert_equals: expected "rgba(16, 112, 112, 0)" but got "rgba(15, 111, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 25%, 0.2) assert_equals: expected "rgba(16, 112, 112, 0.2)" but got "rgba(15, 111, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 25%, 1) assert_equals: expected "rgb(16, 112, 112)" but got "rgb(15, 111, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 75%, 37.5%) assert_equals: expected "rgb(24, 167, 167)" but got "rgb(23, 167, 167)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 37.5%, 0) assert_equals: expected "rgba(24, 167, 167, 0)" but got "rgba(23, 167, 167, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 37.5%, 0.2) assert_equals: expected "rgba(24, 167, 167, 0.2)" but got "rgba(23, 167, 167, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 37.5%, 1) assert_equals: expected "rgb(24, 167, 167)" but got "rgb(23, 167, 167)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 75%, 50%) assert_equals: expected "rgb(32, 223, 223)" but got "rgb(31, 223, 223)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 50%, 0) assert_equals: expected "rgba(32, 223, 223, 0)" but got "rgba(31, 223, 223, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 50%, 0.2) assert_equals: expected "rgba(32, 223, 223, 0.2)" but got "rgba(31, 223, 223, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 50%, 1) assert_equals: expected "rgb(32, 223, 223)" but got "rgb(31, 223, 223)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 75%, 62.5%) assert_equals: expected "rgb(88, 231, 231)" but got "rgb(87, 231, 231)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 62.5%, 0) assert_equals: expected "rgba(88, 231, 231, 0)" but got "rgba(87, 231, 231, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 62.5%, 0.2) assert_equals: expected "rgba(88, 231, 231, 0.2)" but got "rgba(87, 231, 231, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 62.5%, 1) assert_equals: expected "rgb(88, 231, 231)" but got "rgb(87, 231, 231)"
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 75%, 0.2) 
@@ -1875,26 +1875,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 12.5%) assert_equals: expected "rgb(4, 60, 60)" but got "rgb(3, 59, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 12.5%, 0) assert_equals: expected "rgba(4, 60, 60, 0)" but got "rgba(3, 59, 59, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(4, 60, 60, 0.2)" but got "rgba(3, 59, 59, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 12.5%, 1) assert_equals: expected "rgb(4, 60, 60)" but got "rgb(3, 59, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 25%) assert_equals: expected "rgb(8, 120, 120)" but got "rgb(7, 119, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 25%, 0) assert_equals: expected "rgba(8, 120, 120, 0)" but got "rgba(7, 119, 119, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 25%, 0.2) assert_equals: expected "rgba(8, 120, 120, 0.2)" but got "rgba(7, 119, 119, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 25%, 1) assert_equals: expected "rgb(8, 120, 120)" but got "rgb(7, 119, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 37.5%) assert_equals: expected "rgb(12, 179, 179)" but got "rgb(11, 179, 179)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 37.5%, 0) assert_equals: expected "rgba(12, 179, 179, 0)" but got "rgba(11, 179, 179, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(12, 179, 179, 0.2)" but got "rgba(11, 179, 179, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 37.5%, 1) assert_equals: expected "rgb(12, 179, 179)" but got "rgb(11, 179, 179)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 50%) assert_equals: expected "rgb(16, 239, 239)" but got "rgb(15, 239, 239)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 50%, 0) assert_equals: expected "rgba(16, 239, 239, 0)" but got "rgba(15, 239, 239, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 50%, 0.2) assert_equals: expected "rgba(16, 239, 239, 0.2)" but got "rgba(15, 239, 239, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 50%, 1) assert_equals: expected "rgb(16, 239, 239)" but got "rgb(15, 239, 239)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 62.5%) assert_equals: expected "rgb(76, 243, 243)" but got "rgb(75, 243, 243)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 62.5%, 0) assert_equals: expected "rgba(76, 243, 243, 0)" but got "rgba(75, 243, 243, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(76, 243, 243, 0.2)" but got "rgba(75, 243, 243, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 62.5%, 1) assert_equals: expected "rgb(76, 243, 243)" but got "rgb(75, 243, 243)"
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 75%, 0.2) 
@@ -1911,14 +1911,14 @@ PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 100%, 12.5%) assert_equals: expected "rgb(0, 64, 64)" but got "rgb(0, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 12.5%, 0) assert_equals: expected "rgba(0, 64, 64, 0)" but got "rgba(0, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 12.5%, 0.2) assert_equals: expected "rgba(0, 64, 64, 0.2)" but got "rgba(0, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 12.5%, 1) assert_equals: expected "rgb(0, 64, 64)" but got "rgb(0, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 100%, 25%) assert_equals: expected "rgb(0, 128, 128)" but got "rgb(0, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 25%, 0) assert_equals: expected "rgba(0, 128, 128, 0)" but got "rgba(0, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 25%, 0.2) assert_equals: expected "rgba(0, 128, 128, 0.2)" but got "rgba(0, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 25%, 1) assert_equals: expected "rgb(0, 128, 128)" but got "rgb(0, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 25%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 37.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 37.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 37.5%, 0.2) 
@@ -1927,14 +1927,14 @@ PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 50%)
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 50%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 50%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 50%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 100%, 62.5%) assert_equals: expected "rgb(64, 255, 255)" but got "rgb(63, 255, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 62.5%, 0) assert_equals: expected "rgba(64, 255, 255, 0)" but got "rgba(63, 255, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 62.5%, 0.2) assert_equals: expected "rgba(64, 255, 255, 0.2)" but got "rgba(63, 255, 255, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 62.5%, 1) assert_equals: expected "rgb(64, 255, 255)" but got "rgb(63, 255, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(180, 100%, 75%) assert_equals: expected "rgb(128, 255, 255)" but got "rgb(127, 255, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 75%, 0) assert_equals: expected "rgba(128, 255, 255, 0)" but got "rgba(127, 255, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 75%, 0.2) assert_equals: expected "rgba(128, 255, 255, 0.2)" but got "rgba(127, 255, 255, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 75%, 1) assert_equals: expected "rgb(128, 255, 255)" but got "rgb(127, 255, 255)"
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 62.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 75%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 75%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 75%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 75%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 87.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 87.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 87.5%, 0.2) 
@@ -1947,22 +1947,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 62.5%, 0.2) 
@@ -1983,22 +1983,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 12.5%) assert_equals: expected "rgb(28, 32, 36)" but got "rgb(27, 31, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 12.5%, 0) assert_equals: expected "rgba(28, 32, 36, 0)" but got "rgba(27, 31, 35, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(28, 32, 36, 0.2)" but got "rgba(27, 31, 35, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 12.5%, 1) assert_equals: expected "rgb(28, 32, 36)" but got "rgb(27, 31, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 25%) assert_equals: expected "rgb(56, 64, 72)" but got "rgb(55, 63, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 25%, 0) assert_equals: expected "rgba(56, 64, 72, 0)" but got "rgba(55, 63, 71, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 25%, 0.2) assert_equals: expected "rgba(56, 64, 72, 0.2)" but got "rgba(55, 63, 71, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 25%, 1) assert_equals: expected "rgb(56, 64, 72)" but got "rgb(55, 63, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 37.5%) assert_equals: expected "rgb(84, 96, 108)" but got "rgb(83, 95, 107)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 37.5%, 0) assert_equals: expected "rgba(84, 96, 108, 0)" but got "rgba(83, 95, 107, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(84, 96, 108, 0.2)" but got "rgba(83, 95, 107, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 37.5%, 1) assert_equals: expected "rgb(84, 96, 108)" but got "rgb(83, 95, 107)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 50%) assert_equals: expected "rgb(112, 128, 143)" but got "rgb(111, 127, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 50%, 0) assert_equals: expected "rgba(112, 128, 143, 0)" but got "rgba(111, 127, 143, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 50%, 0.2) assert_equals: expected "rgba(112, 128, 143, 0.2)" but got "rgba(111, 127, 143, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 50%, 1) assert_equals: expected "rgb(112, 128, 143)" but got "rgb(111, 127, 143)"
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 62.5%, 0.2) 
@@ -2019,22 +2019,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 25%, 12.5%) assert_equals: expected "rgb(24, 32, 40)" but got "rgb(23, 31, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 12.5%, 0) assert_equals: expected "rgba(24, 32, 40, 0)" but got "rgba(23, 31, 39, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 12.5%, 0.2) assert_equals: expected "rgba(24, 32, 40, 0.2)" but got "rgba(23, 31, 39, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 12.5%, 1) assert_equals: expected "rgb(24, 32, 40)" but got "rgb(23, 31, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 25%, 25%) assert_equals: expected "rgb(48, 64, 80)" but got "rgb(47, 63, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 25%, 0) assert_equals: expected "rgba(48, 64, 80, 0)" but got "rgba(47, 63, 79, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 25%, 0.2) assert_equals: expected "rgba(48, 64, 80, 0.2)" but got "rgba(47, 63, 79, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 25%, 1) assert_equals: expected "rgb(48, 64, 80)" but got "rgb(47, 63, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 25%, 37.5%) assert_equals: expected "rgb(72, 96, 120)" but got "rgb(71, 95, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 37.5%, 0) assert_equals: expected "rgba(72, 96, 120, 0)" but got "rgba(71, 95, 119, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 37.5%, 0.2) assert_equals: expected "rgba(72, 96, 120, 0.2)" but got "rgba(71, 95, 119, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 37.5%, 1) assert_equals: expected "rgb(72, 96, 120)" but got "rgb(71, 95, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 25%, 50%) assert_equals: expected "rgb(96, 128, 159)" but got "rgb(95, 127, 159)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 50%, 0) assert_equals: expected "rgba(96, 128, 159, 0)" but got "rgba(95, 127, 159, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 50%, 0.2) assert_equals: expected "rgba(96, 128, 159, 0.2)" but got "rgba(95, 127, 159, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 50%, 1) assert_equals: expected "rgb(96, 128, 159)" but got "rgb(95, 127, 159)"
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 62.5%, 0.2) 
@@ -2055,26 +2055,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 12.5%) assert_equals: expected "rgb(20, 32, 44)" but got "rgb(19, 31, 43)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 12.5%, 0) assert_equals: expected "rgba(20, 32, 44, 0)" but got "rgba(19, 31, 43, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(20, 32, 44, 0.2)" but got "rgba(19, 31, 43, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 12.5%, 1) assert_equals: expected "rgb(20, 32, 44)" but got "rgb(19, 31, 43)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 25%) assert_equals: expected "rgb(40, 64, 88)" but got "rgb(39, 63, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 25%, 0) assert_equals: expected "rgba(40, 64, 88, 0)" but got "rgba(39, 63, 87, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 25%, 0.2) assert_equals: expected "rgba(40, 64, 88, 0.2)" but got "rgba(39, 63, 87, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 25%, 1) assert_equals: expected "rgb(40, 64, 88)" but got "rgb(39, 63, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 37.5%) assert_equals: expected "rgb(60, 96, 131)" but got "rgb(59, 95, 131)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 37.5%, 0) assert_equals: expected "rgba(60, 96, 131, 0)" but got "rgba(59, 95, 131, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(60, 96, 131, 0.2)" but got "rgba(59, 95, 131, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 37.5%, 1) assert_equals: expected "rgb(60, 96, 131)" but got "rgb(59, 95, 131)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 50%) assert_equals: expected "rgb(80, 128, 175)" but got "rgb(79, 127, 175)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 50%, 0) assert_equals: expected "rgba(80, 128, 175, 0)" but got "rgba(79, 127, 175, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 50%, 0.2) assert_equals: expected "rgba(80, 128, 175, 0.2)" but got "rgba(79, 127, 175, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 50%, 1) assert_equals: expected "rgb(80, 128, 175)" but got "rgb(79, 127, 175)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 62.5%) assert_equals: expected "rgb(124, 159, 195)" but got "rgb(123, 159, 195)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 62.5%, 0) assert_equals: expected "rgba(124, 159, 195, 0)" but got "rgba(123, 159, 195, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(124, 159, 195, 0.2)" but got "rgba(123, 159, 195, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 62.5%, 1) assert_equals: expected "rgb(124, 159, 195)" but got "rgb(123, 159, 195)"
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 75%, 0.2) 
@@ -2091,26 +2091,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 50%, 12.5%) assert_equals: expected "rgb(16, 32, 48)" but got "rgb(15, 31, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 12.5%, 0) assert_equals: expected "rgba(16, 32, 48, 0)" but got "rgba(15, 31, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 12.5%, 0.2) assert_equals: expected "rgba(16, 32, 48, 0.2)" but got "rgba(15, 31, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 12.5%, 1) assert_equals: expected "rgb(16, 32, 48)" but got "rgb(15, 31, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 50%, 25%) assert_equals: expected "rgb(32, 64, 96)" but got "rgb(31, 63, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 25%, 0) assert_equals: expected "rgba(32, 64, 96, 0)" but got "rgba(31, 63, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 25%, 0.2) assert_equals: expected "rgba(32, 64, 96, 0.2)" but got "rgba(31, 63, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 25%, 1) assert_equals: expected "rgb(32, 64, 96)" but got "rgb(31, 63, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 50%, 37.5%) assert_equals: expected "rgb(48, 96, 143)" but got "rgb(47, 95, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 37.5%, 0) assert_equals: expected "rgba(48, 96, 143, 0)" but got "rgba(47, 95, 143, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 37.5%, 0.2) assert_equals: expected "rgba(48, 96, 143, 0.2)" but got "rgba(47, 95, 143, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 37.5%, 1) assert_equals: expected "rgb(48, 96, 143)" but got "rgb(47, 95, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 50%, 50%) assert_equals: expected "rgb(64, 128, 191)" but got "rgb(63, 127, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 50%, 0) assert_equals: expected "rgba(64, 128, 191, 0)" but got "rgba(63, 127, 191, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 50%, 0.2) assert_equals: expected "rgba(64, 128, 191, 0.2)" but got "rgba(63, 127, 191, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 50%, 1) assert_equals: expected "rgb(64, 128, 191)" but got "rgb(63, 127, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 50%, 62.5%) assert_equals: expected "rgb(112, 159, 207)" but got "rgb(111, 159, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 62.5%, 0) assert_equals: expected "rgba(112, 159, 207, 0)" but got "rgba(111, 159, 207, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 62.5%, 0.2) assert_equals: expected "rgba(112, 159, 207, 0.2)" but got "rgba(111, 159, 207, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 62.5%, 1) assert_equals: expected "rgb(112, 159, 207)" but got "rgb(111, 159, 207)"
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 75%, 0.2) 
@@ -2127,26 +2127,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 12.5%) assert_equals: expected "rgb(12, 32, 52)" but got "rgb(11, 31, 51)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 12.5%, 0) assert_equals: expected "rgba(12, 32, 52, 0)" but got "rgba(11, 31, 51, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(12, 32, 52, 0.2)" but got "rgba(11, 31, 51, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 12.5%, 1) assert_equals: expected "rgb(12, 32, 52)" but got "rgb(11, 31, 51)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 25%) assert_equals: expected "rgb(24, 64, 104)" but got "rgb(23, 63, 103)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 25%, 0) assert_equals: expected "rgba(24, 64, 104, 0)" but got "rgba(23, 63, 103, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 25%, 0.2) assert_equals: expected "rgba(24, 64, 104, 0.2)" but got "rgba(23, 63, 103, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 25%, 1) assert_equals: expected "rgb(24, 64, 104)" but got "rgb(23, 63, 103)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 37.5%) assert_equals: expected "rgb(36, 96, 155)" but got "rgb(35, 95, 155)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 37.5%, 0) assert_equals: expected "rgba(36, 96, 155, 0)" but got "rgba(35, 95, 155, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(36, 96, 155, 0.2)" but got "rgba(35, 95, 155, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 37.5%, 1) assert_equals: expected "rgb(36, 96, 155)" but got "rgb(35, 95, 155)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 50%) assert_equals: expected "rgb(48, 128, 207)" but got "rgb(47, 127, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 50%, 0) assert_equals: expected "rgba(48, 128, 207, 0)" but got "rgba(47, 127, 207, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 50%, 0.2) assert_equals: expected "rgba(48, 128, 207, 0.2)" but got "rgba(47, 127, 207, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 50%, 1) assert_equals: expected "rgb(48, 128, 207)" but got "rgb(47, 127, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 62.5%) assert_equals: expected "rgb(100, 159, 219)" but got "rgb(99, 159, 219)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 62.5%, 0) assert_equals: expected "rgba(100, 159, 219, 0)" but got "rgba(99, 159, 219, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(100, 159, 219, 0.2)" but got "rgba(99, 159, 219, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 62.5%, 1) assert_equals: expected "rgb(100, 159, 219)" but got "rgb(99, 159, 219)"
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 75%, 0.2) 
@@ -2163,26 +2163,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 75%, 12.5%) assert_equals: expected "rgb(8, 32, 56)" but got "rgb(7, 31, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 12.5%, 0) assert_equals: expected "rgba(8, 32, 56, 0)" but got "rgba(7, 31, 55, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 12.5%, 0.2) assert_equals: expected "rgba(8, 32, 56, 0.2)" but got "rgba(7, 31, 55, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 12.5%, 1) assert_equals: expected "rgb(8, 32, 56)" but got "rgb(7, 31, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 75%, 25%) assert_equals: expected "rgb(16, 64, 112)" but got "rgb(15, 63, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 25%, 0) assert_equals: expected "rgba(16, 64, 112, 0)" but got "rgba(15, 63, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 25%, 0.2) assert_equals: expected "rgba(16, 64, 112, 0.2)" but got "rgba(15, 63, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 25%, 1) assert_equals: expected "rgb(16, 64, 112)" but got "rgb(15, 63, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 75%, 37.5%) assert_equals: expected "rgb(24, 96, 167)" but got "rgb(23, 95, 167)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 37.5%, 0) assert_equals: expected "rgba(24, 96, 167, 0)" but got "rgba(23, 95, 167, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 37.5%, 0.2) assert_equals: expected "rgba(24, 96, 167, 0.2)" but got "rgba(23, 95, 167, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 37.5%, 1) assert_equals: expected "rgb(24, 96, 167)" but got "rgb(23, 95, 167)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 75%, 50%) assert_equals: expected "rgb(32, 128, 223)" but got "rgb(31, 127, 223)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 50%, 0) assert_equals: expected "rgba(32, 128, 223, 0)" but got "rgba(31, 127, 223, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 50%, 0.2) assert_equals: expected "rgba(32, 128, 223, 0.2)" but got "rgba(31, 127, 223, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 50%, 1) assert_equals: expected "rgb(32, 128, 223)" but got "rgb(31, 127, 223)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 75%, 62.5%) assert_equals: expected "rgb(88, 159, 231)" but got "rgb(87, 159, 231)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 62.5%, 0) assert_equals: expected "rgba(88, 159, 231, 0)" but got "rgba(87, 159, 231, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 62.5%, 0.2) assert_equals: expected "rgba(88, 159, 231, 0.2)" but got "rgba(87, 159, 231, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 62.5%, 1) assert_equals: expected "rgb(88, 159, 231)" but got "rgb(87, 159, 231)"
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 75%, 0.2) 
@@ -2199,26 +2199,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 12.5%) assert_equals: expected "rgb(4, 32, 60)" but got "rgb(3, 31, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 12.5%, 0) assert_equals: expected "rgba(4, 32, 60, 0)" but got "rgba(3, 31, 59, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(4, 32, 60, 0.2)" but got "rgba(3, 31, 59, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 12.5%, 1) assert_equals: expected "rgb(4, 32, 60)" but got "rgb(3, 31, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 25%) assert_equals: expected "rgb(8, 64, 120)" but got "rgb(7, 63, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 25%, 0) assert_equals: expected "rgba(8, 64, 120, 0)" but got "rgba(7, 63, 119, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 25%, 0.2) assert_equals: expected "rgba(8, 64, 120, 0.2)" but got "rgba(7, 63, 119, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 25%, 1) assert_equals: expected "rgb(8, 64, 120)" but got "rgb(7, 63, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 37.5%) assert_equals: expected "rgb(12, 96, 179)" but got "rgb(11, 95, 179)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 37.5%, 0) assert_equals: expected "rgba(12, 96, 179, 0)" but got "rgba(11, 95, 179, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(12, 96, 179, 0.2)" but got "rgba(11, 95, 179, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 37.5%, 1) assert_equals: expected "rgb(12, 96, 179)" but got "rgb(11, 95, 179)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 50%) assert_equals: expected "rgb(16, 128, 239)" but got "rgb(15, 127, 239)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 50%, 0) assert_equals: expected "rgba(16, 128, 239, 0)" but got "rgba(15, 127, 239, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 50%, 0.2) assert_equals: expected "rgba(16, 128, 239, 0.2)" but got "rgba(15, 127, 239, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 50%, 1) assert_equals: expected "rgb(16, 128, 239)" but got "rgb(15, 127, 239)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 62.5%) assert_equals: expected "rgb(76, 159, 243)" but got "rgb(75, 159, 243)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 62.5%, 0) assert_equals: expected "rgba(76, 159, 243, 0)" but got "rgba(75, 159, 243, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(76, 159, 243, 0.2)" but got "rgba(75, 159, 243, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 62.5%, 1) assert_equals: expected "rgb(76, 159, 243)" but got "rgb(75, 159, 243)"
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 75%, 0.2) 
@@ -2235,30 +2235,30 @@ PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 100%, 12.5%) assert_equals: expected "rgb(0, 32, 64)" but got "rgb(0, 31, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 12.5%, 0) assert_equals: expected "rgba(0, 32, 64, 0)" but got "rgba(0, 31, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 12.5%, 0.2) assert_equals: expected "rgba(0, 32, 64, 0.2)" but got "rgba(0, 31, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 12.5%, 1) assert_equals: expected "rgb(0, 32, 64)" but got "rgb(0, 31, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 100%, 25%) assert_equals: expected "rgb(0, 64, 128)" but got "rgb(0, 63, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 25%, 0) assert_equals: expected "rgba(0, 64, 128, 0)" but got "rgba(0, 63, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 25%, 0.2) assert_equals: expected "rgba(0, 64, 128, 0.2)" but got "rgba(0, 63, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 25%, 1) assert_equals: expected "rgb(0, 64, 128)" but got "rgb(0, 63, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 100%, 37.5%) assert_equals: expected "rgb(0, 96, 191)" but got "rgb(0, 95, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 37.5%, 0) assert_equals: expected "rgba(0, 96, 191, 0)" but got "rgba(0, 95, 191, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 37.5%, 0.2) assert_equals: expected "rgba(0, 96, 191, 0.2)" but got "rgba(0, 95, 191, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 37.5%, 1) assert_equals: expected "rgb(0, 96, 191)" but got "rgb(0, 95, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 100%, 50%) assert_equals: expected "rgb(0, 128, 255)" but got "rgb(0, 127, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 50%, 0) assert_equals: expected "rgba(0, 128, 255, 0)" but got "rgba(0, 127, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 50%, 0.2) assert_equals: expected "rgba(0, 128, 255, 0.2)" but got "rgba(0, 127, 255, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 50%, 1) assert_equals: expected "rgb(0, 128, 255)" but got "rgb(0, 127, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 100%, 62.5%) assert_equals: expected "rgb(64, 159, 255)" but got "rgb(63, 159, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 62.5%, 0) assert_equals: expected "rgba(64, 159, 255, 0)" but got "rgba(63, 159, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 62.5%, 0.2) assert_equals: expected "rgba(64, 159, 255, 0.2)" but got "rgba(63, 159, 255, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 62.5%, 1) assert_equals: expected "rgb(64, 159, 255)" but got "rgb(63, 159, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(210, 100%, 75%) assert_equals: expected "rgb(128, 191, 255)" but got "rgb(127, 191, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 75%, 0) assert_equals: expected "rgba(128, 191, 255, 0)" but got "rgba(127, 191, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 75%, 0.2) assert_equals: expected "rgba(128, 191, 255, 0.2)" but got "rgba(127, 191, 255, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 75%, 1) assert_equals: expected "rgb(128, 191, 255)" but got "rgb(127, 191, 255)"
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 62.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 75%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 75%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 75%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 75%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 87.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 87.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 87.5%, 0.2) 
@@ -2271,22 +2271,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 62.5%, 0.2) 
@@ -2307,22 +2307,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 12.5%) assert_equals: expected "rgb(28, 28, 36)" but got "rgb(27, 27, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 12.5%, 0) assert_equals: expected "rgba(28, 28, 36, 0)" but got "rgba(27, 27, 35, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(28, 28, 36, 0.2)" but got "rgba(27, 27, 35, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 12.5%, 1) assert_equals: expected "rgb(28, 28, 36)" but got "rgb(27, 27, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 25%) assert_equals: expected "rgb(56, 56, 72)" but got "rgb(55, 55, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 25%, 0) assert_equals: expected "rgba(56, 56, 72, 0)" but got "rgba(55, 55, 71, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 25%, 0.2) assert_equals: expected "rgba(56, 56, 72, 0.2)" but got "rgba(55, 55, 71, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 25%, 1) assert_equals: expected "rgb(56, 56, 72)" but got "rgb(55, 55, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 37.5%) assert_equals: expected "rgb(84, 84, 108)" but got "rgb(83, 83, 107)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 37.5%, 0) assert_equals: expected "rgba(84, 84, 108, 0)" but got "rgba(83, 83, 107, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(84, 84, 108, 0.2)" but got "rgba(83, 83, 107, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 37.5%, 1) assert_equals: expected "rgb(84, 84, 108)" but got "rgb(83, 83, 107)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 50%) assert_equals: expected "rgb(112, 112, 143)" but got "rgb(111, 111, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 50%, 0) assert_equals: expected "rgba(112, 112, 143, 0)" but got "rgba(111, 111, 143, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 50%, 0.2) assert_equals: expected "rgba(112, 112, 143, 0.2)" but got "rgba(111, 111, 143, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 50%, 1) assert_equals: expected "rgb(112, 112, 143)" but got "rgb(111, 111, 143)"
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 62.5%, 0.2) 
@@ -2343,22 +2343,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 25%, 12.5%) assert_equals: expected "rgb(24, 24, 40)" but got "rgb(23, 23, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 12.5%, 0) assert_equals: expected "rgba(24, 24, 40, 0)" but got "rgba(23, 23, 39, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 12.5%, 0.2) assert_equals: expected "rgba(24, 24, 40, 0.2)" but got "rgba(23, 23, 39, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 12.5%, 1) assert_equals: expected "rgb(24, 24, 40)" but got "rgb(23, 23, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 25%, 25%) assert_equals: expected "rgb(48, 48, 80)" but got "rgb(47, 47, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 25%, 0) assert_equals: expected "rgba(48, 48, 80, 0)" but got "rgba(47, 47, 79, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 25%, 0.2) assert_equals: expected "rgba(48, 48, 80, 0.2)" but got "rgba(47, 47, 79, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 25%, 1) assert_equals: expected "rgb(48, 48, 80)" but got "rgb(47, 47, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 25%, 37.5%) assert_equals: expected "rgb(72, 72, 120)" but got "rgb(71, 71, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 37.5%, 0) assert_equals: expected "rgba(72, 72, 120, 0)" but got "rgba(71, 71, 119, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 37.5%, 0.2) assert_equals: expected "rgba(72, 72, 120, 0.2)" but got "rgba(71, 71, 119, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 37.5%, 1) assert_equals: expected "rgb(72, 72, 120)" but got "rgb(71, 71, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 25%, 50%) assert_equals: expected "rgb(96, 96, 159)" but got "rgb(95, 95, 159)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 50%, 0) assert_equals: expected "rgba(96, 96, 159, 0)" but got "rgba(95, 95, 159, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 50%, 0.2) assert_equals: expected "rgba(96, 96, 159, 0.2)" but got "rgba(95, 95, 159, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 50%, 1) assert_equals: expected "rgb(96, 96, 159)" but got "rgb(95, 95, 159)"
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 62.5%, 0.2) 
@@ -2379,26 +2379,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 12.5%) assert_equals: expected "rgb(20, 20, 44)" but got "rgb(19, 19, 43)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 12.5%, 0) assert_equals: expected "rgba(20, 20, 44, 0)" but got "rgba(19, 19, 43, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(20, 20, 44, 0.2)" but got "rgba(19, 19, 43, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 12.5%, 1) assert_equals: expected "rgb(20, 20, 44)" but got "rgb(19, 19, 43)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 25%) assert_equals: expected "rgb(40, 40, 88)" but got "rgb(39, 39, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 25%, 0) assert_equals: expected "rgba(40, 40, 88, 0)" but got "rgba(39, 39, 87, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 25%, 0.2) assert_equals: expected "rgba(40, 40, 88, 0.2)" but got "rgba(39, 39, 87, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 25%, 1) assert_equals: expected "rgb(40, 40, 88)" but got "rgb(39, 39, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 37.5%) assert_equals: expected "rgb(60, 60, 131)" but got "rgb(59, 59, 131)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 37.5%, 0) assert_equals: expected "rgba(60, 60, 131, 0)" but got "rgba(59, 59, 131, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(60, 60, 131, 0.2)" but got "rgba(59, 59, 131, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 37.5%, 1) assert_equals: expected "rgb(60, 60, 131)" but got "rgb(59, 59, 131)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 50%) assert_equals: expected "rgb(80, 80, 175)" but got "rgb(79, 79, 175)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 50%, 0) assert_equals: expected "rgba(80, 80, 175, 0)" but got "rgba(79, 79, 175, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 50%, 0.2) assert_equals: expected "rgba(80, 80, 175, 0.2)" but got "rgba(79, 79, 175, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 50%, 1) assert_equals: expected "rgb(80, 80, 175)" but got "rgb(79, 79, 175)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 62.5%) assert_equals: expected "rgb(124, 124, 195)" but got "rgb(123, 123, 195)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 62.5%, 0) assert_equals: expected "rgba(124, 124, 195, 0)" but got "rgba(123, 123, 195, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(124, 124, 195, 0.2)" but got "rgba(123, 123, 195, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 62.5%, 1) assert_equals: expected "rgb(124, 124, 195)" but got "rgb(123, 123, 195)"
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 75%, 0.2) 
@@ -2415,26 +2415,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 50%, 12.5%) assert_equals: expected "rgb(16, 16, 48)" but got "rgb(15, 15, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 12.5%, 0) assert_equals: expected "rgba(16, 16, 48, 0)" but got "rgba(15, 15, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 12.5%, 0.2) assert_equals: expected "rgba(16, 16, 48, 0.2)" but got "rgba(15, 15, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 12.5%, 1) assert_equals: expected "rgb(16, 16, 48)" but got "rgb(15, 15, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 50%, 25%) assert_equals: expected "rgb(32, 32, 96)" but got "rgb(31, 31, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 25%, 0) assert_equals: expected "rgba(32, 32, 96, 0)" but got "rgba(31, 31, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 25%, 0.2) assert_equals: expected "rgba(32, 32, 96, 0.2)" but got "rgba(31, 31, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 25%, 1) assert_equals: expected "rgb(32, 32, 96)" but got "rgb(31, 31, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 50%, 37.5%) assert_equals: expected "rgb(48, 48, 143)" but got "rgb(47, 47, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 37.5%, 0) assert_equals: expected "rgba(48, 48, 143, 0)" but got "rgba(47, 47, 143, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 37.5%, 0.2) assert_equals: expected "rgba(48, 48, 143, 0.2)" but got "rgba(47, 47, 143, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 37.5%, 1) assert_equals: expected "rgb(48, 48, 143)" but got "rgb(47, 47, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 50%, 50%) assert_equals: expected "rgb(64, 64, 191)" but got "rgb(63, 63, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 50%, 0) assert_equals: expected "rgba(64, 64, 191, 0)" but got "rgba(63, 63, 191, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 50%, 0.2) assert_equals: expected "rgba(64, 64, 191, 0.2)" but got "rgba(63, 63, 191, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 50%, 1) assert_equals: expected "rgb(64, 64, 191)" but got "rgb(63, 63, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 50%, 62.5%) assert_equals: expected "rgb(112, 112, 207)" but got "rgb(111, 111, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 62.5%, 0) assert_equals: expected "rgba(112, 112, 207, 0)" but got "rgba(111, 111, 207, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 62.5%, 0.2) assert_equals: expected "rgba(112, 112, 207, 0.2)" but got "rgba(111, 111, 207, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 62.5%, 1) assert_equals: expected "rgb(112, 112, 207)" but got "rgb(111, 111, 207)"
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 75%, 0.2) 
@@ -2451,26 +2451,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 12.5%) assert_equals: expected "rgb(12, 12, 52)" but got "rgb(11, 11, 51)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 12.5%, 0) assert_equals: expected "rgba(12, 12, 52, 0)" but got "rgba(11, 11, 51, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(12, 12, 52, 0.2)" but got "rgba(11, 11, 51, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 12.5%, 1) assert_equals: expected "rgb(12, 12, 52)" but got "rgb(11, 11, 51)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 25%) assert_equals: expected "rgb(24, 24, 104)" but got "rgb(23, 23, 103)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 25%, 0) assert_equals: expected "rgba(24, 24, 104, 0)" but got "rgba(23, 23, 103, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 25%, 0.2) assert_equals: expected "rgba(24, 24, 104, 0.2)" but got "rgba(23, 23, 103, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 25%, 1) assert_equals: expected "rgb(24, 24, 104)" but got "rgb(23, 23, 103)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 37.5%) assert_equals: expected "rgb(36, 36, 155)" but got "rgb(35, 35, 155)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 37.5%, 0) assert_equals: expected "rgba(36, 36, 155, 0)" but got "rgba(35, 35, 155, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(36, 36, 155, 0.2)" but got "rgba(35, 35, 155, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 37.5%, 1) assert_equals: expected "rgb(36, 36, 155)" but got "rgb(35, 35, 155)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 50%) assert_equals: expected "rgb(48, 48, 207)" but got "rgb(47, 47, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 50%, 0) assert_equals: expected "rgba(48, 48, 207, 0)" but got "rgba(47, 47, 207, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 50%, 0.2) assert_equals: expected "rgba(48, 48, 207, 0.2)" but got "rgba(47, 47, 207, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 50%, 1) assert_equals: expected "rgb(48, 48, 207)" but got "rgb(47, 47, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 62.5%) assert_equals: expected "rgb(100, 100, 219)" but got "rgb(99, 99, 219)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 62.5%, 0) assert_equals: expected "rgba(100, 100, 219, 0)" but got "rgba(99, 99, 219, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(100, 100, 219, 0.2)" but got "rgba(99, 99, 219, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 62.5%, 1) assert_equals: expected "rgb(100, 100, 219)" but got "rgb(99, 99, 219)"
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 75%, 0.2) 
@@ -2487,26 +2487,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 75%, 12.5%) assert_equals: expected "rgb(8, 8, 56)" but got "rgb(7, 7, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 12.5%, 0) assert_equals: expected "rgba(8, 8, 56, 0)" but got "rgba(7, 7, 55, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 12.5%, 0.2) assert_equals: expected "rgba(8, 8, 56, 0.2)" but got "rgba(7, 7, 55, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 12.5%, 1) assert_equals: expected "rgb(8, 8, 56)" but got "rgb(7, 7, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 75%, 25%) assert_equals: expected "rgb(16, 16, 112)" but got "rgb(15, 15, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 25%, 0) assert_equals: expected "rgba(16, 16, 112, 0)" but got "rgba(15, 15, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 25%, 0.2) assert_equals: expected "rgba(16, 16, 112, 0.2)" but got "rgba(15, 15, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 25%, 1) assert_equals: expected "rgb(16, 16, 112)" but got "rgb(15, 15, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 75%, 37.5%) assert_equals: expected "rgb(24, 24, 167)" but got "rgb(23, 23, 167)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 37.5%, 0) assert_equals: expected "rgba(24, 24, 167, 0)" but got "rgba(23, 23, 167, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 37.5%, 0.2) assert_equals: expected "rgba(24, 24, 167, 0.2)" but got "rgba(23, 23, 167, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 37.5%, 1) assert_equals: expected "rgb(24, 24, 167)" but got "rgb(23, 23, 167)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 75%, 50%) assert_equals: expected "rgb(32, 32, 223)" but got "rgb(31, 31, 223)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 50%, 0) assert_equals: expected "rgba(32, 32, 223, 0)" but got "rgba(31, 31, 223, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 50%, 0.2) assert_equals: expected "rgba(32, 32, 223, 0.2)" but got "rgba(31, 31, 223, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 50%, 1) assert_equals: expected "rgb(32, 32, 223)" but got "rgb(31, 31, 223)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 75%, 62.5%) assert_equals: expected "rgb(88, 88, 231)" but got "rgb(87, 87, 231)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 62.5%, 0) assert_equals: expected "rgba(88, 88, 231, 0)" but got "rgba(87, 87, 231, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 62.5%, 0.2) assert_equals: expected "rgba(88, 88, 231, 0.2)" but got "rgba(87, 87, 231, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 62.5%, 1) assert_equals: expected "rgb(88, 88, 231)" but got "rgb(87, 87, 231)"
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 75%, 0.2) 
@@ -2523,26 +2523,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 12.5%) assert_equals: expected "rgb(4, 4, 60)" but got "rgb(3, 3, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 12.5%, 0) assert_equals: expected "rgba(4, 4, 60, 0)" but got "rgba(3, 3, 59, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(4, 4, 60, 0.2)" but got "rgba(3, 3, 59, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 12.5%, 1) assert_equals: expected "rgb(4, 4, 60)" but got "rgb(3, 3, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 25%) assert_equals: expected "rgb(8, 8, 120)" but got "rgb(7, 7, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 25%, 0) assert_equals: expected "rgba(8, 8, 120, 0)" but got "rgba(7, 7, 119, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 25%, 0.2) assert_equals: expected "rgba(8, 8, 120, 0.2)" but got "rgba(7, 7, 119, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 25%, 1) assert_equals: expected "rgb(8, 8, 120)" but got "rgb(7, 7, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 37.5%) assert_equals: expected "rgb(12, 12, 179)" but got "rgb(11, 11, 179)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 37.5%, 0) assert_equals: expected "rgba(12, 12, 179, 0)" but got "rgba(11, 11, 179, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(12, 12, 179, 0.2)" but got "rgba(11, 11, 179, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 37.5%, 1) assert_equals: expected "rgb(12, 12, 179)" but got "rgb(11, 11, 179)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 50%) assert_equals: expected "rgb(16, 16, 239)" but got "rgb(15, 15, 239)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 50%, 0) assert_equals: expected "rgba(16, 16, 239, 0)" but got "rgba(15, 15, 239, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 50%, 0.2) assert_equals: expected "rgba(16, 16, 239, 0.2)" but got "rgba(15, 15, 239, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 50%, 1) assert_equals: expected "rgb(16, 16, 239)" but got "rgb(15, 15, 239)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 62.5%) assert_equals: expected "rgb(76, 76, 243)" but got "rgb(75, 75, 243)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 62.5%, 0) assert_equals: expected "rgba(76, 76, 243, 0)" but got "rgba(75, 75, 243, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(76, 76, 243, 0.2)" but got "rgba(75, 75, 243, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 62.5%, 1) assert_equals: expected "rgb(76, 76, 243)" but got "rgb(75, 75, 243)"
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 75%, 0.2) 
@@ -2559,14 +2559,14 @@ PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 100%, 12.5%) assert_equals: expected "rgb(0, 0, 64)" but got "rgb(0, 0, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 12.5%, 0) assert_equals: expected "rgba(0, 0, 64, 0)" but got "rgba(0, 0, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 12.5%, 0.2) assert_equals: expected "rgba(0, 0, 64, 0.2)" but got "rgba(0, 0, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 12.5%, 1) assert_equals: expected "rgb(0, 0, 64)" but got "rgb(0, 0, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 100%, 25%) assert_equals: expected "rgb(0, 0, 128)" but got "rgb(0, 0, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 25%, 0) assert_equals: expected "rgba(0, 0, 128, 0)" but got "rgba(0, 0, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 25%, 0.2) assert_equals: expected "rgba(0, 0, 128, 0.2)" but got "rgba(0, 0, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 25%, 1) assert_equals: expected "rgb(0, 0, 128)" but got "rgb(0, 0, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 25%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 37.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 37.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 37.5%, 0.2) 
@@ -2575,14 +2575,14 @@ PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 50%)
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 50%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 50%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 50%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 100%, 62.5%) assert_equals: expected "rgb(64, 64, 255)" but got "rgb(63, 63, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 62.5%, 0) assert_equals: expected "rgba(64, 64, 255, 0)" but got "rgba(63, 63, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 62.5%, 0.2) assert_equals: expected "rgba(64, 64, 255, 0.2)" but got "rgba(63, 63, 255, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 62.5%, 1) assert_equals: expected "rgb(64, 64, 255)" but got "rgb(63, 63, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(240, 100%, 75%) assert_equals: expected "rgb(128, 128, 255)" but got "rgb(127, 127, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 75%, 0) assert_equals: expected "rgba(128, 128, 255, 0)" but got "rgba(127, 127, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 75%, 0.2) assert_equals: expected "rgba(128, 128, 255, 0.2)" but got "rgba(127, 127, 255, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 75%, 1) assert_equals: expected "rgb(128, 128, 255)" but got "rgb(127, 127, 255)"
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 62.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 75%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 75%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 75%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 75%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 87.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 87.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 87.5%, 0.2) 
@@ -2595,22 +2595,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 62.5%, 0.2) 
@@ -2631,22 +2631,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 12.5%) assert_equals: expected "rgb(32, 28, 36)" but got "rgb(31, 27, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 12.5%, 0) assert_equals: expected "rgba(32, 28, 36, 0)" but got "rgba(31, 27, 35, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 28, 36, 0.2)" but got "rgba(31, 27, 35, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 12.5%, 1) assert_equals: expected "rgb(32, 28, 36)" but got "rgb(31, 27, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 25%) assert_equals: expected "rgb(64, 56, 72)" but got "rgb(63, 55, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 25%, 0) assert_equals: expected "rgba(64, 56, 72, 0)" but got "rgba(63, 55, 71, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 25%, 0.2) assert_equals: expected "rgba(64, 56, 72, 0.2)" but got "rgba(63, 55, 71, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 25%, 1) assert_equals: expected "rgb(64, 56, 72)" but got "rgb(63, 55, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 37.5%) assert_equals: expected "rgb(96, 84, 108)" but got "rgb(95, 83, 107)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 37.5%, 0) assert_equals: expected "rgba(96, 84, 108, 0)" but got "rgba(95, 83, 107, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 84, 108, 0.2)" but got "rgba(95, 83, 107, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 37.5%, 1) assert_equals: expected "rgb(96, 84, 108)" but got "rgb(95, 83, 107)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 50%) assert_equals: expected "rgb(128, 112, 143)" but got "rgb(127, 111, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 50%, 0) assert_equals: expected "rgba(128, 112, 143, 0)" but got "rgba(127, 111, 143, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 50%, 0.2) assert_equals: expected "rgba(128, 112, 143, 0.2)" but got "rgba(127, 111, 143, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 50%, 1) assert_equals: expected "rgb(128, 112, 143)" but got "rgb(127, 111, 143)"
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 62.5%, 0.2) 
@@ -2667,22 +2667,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 25%, 12.5%) assert_equals: expected "rgb(32, 24, 40)" but got "rgb(31, 23, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 12.5%, 0) assert_equals: expected "rgba(32, 24, 40, 0)" but got "rgba(31, 23, 39, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 12.5%, 0.2) assert_equals: expected "rgba(32, 24, 40, 0.2)" but got "rgba(31, 23, 39, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 12.5%, 1) assert_equals: expected "rgb(32, 24, 40)" but got "rgb(31, 23, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 25%, 25%) assert_equals: expected "rgb(64, 48, 80)" but got "rgb(63, 47, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 25%, 0) assert_equals: expected "rgba(64, 48, 80, 0)" but got "rgba(63, 47, 79, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 25%, 0.2) assert_equals: expected "rgba(64, 48, 80, 0.2)" but got "rgba(63, 47, 79, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 25%, 1) assert_equals: expected "rgb(64, 48, 80)" but got "rgb(63, 47, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 25%, 37.5%) assert_equals: expected "rgb(96, 72, 120)" but got "rgb(95, 71, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 37.5%, 0) assert_equals: expected "rgba(96, 72, 120, 0)" but got "rgba(95, 71, 119, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 37.5%, 0.2) assert_equals: expected "rgba(96, 72, 120, 0.2)" but got "rgba(95, 71, 119, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 37.5%, 1) assert_equals: expected "rgb(96, 72, 120)" but got "rgb(95, 71, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 25%, 50%) assert_equals: expected "rgb(128, 96, 159)" but got "rgb(127, 95, 159)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 50%, 0) assert_equals: expected "rgba(128, 96, 159, 0)" but got "rgba(127, 95, 159, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 50%, 0.2) assert_equals: expected "rgba(128, 96, 159, 0.2)" but got "rgba(127, 95, 159, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 50%, 1) assert_equals: expected "rgb(128, 96, 159)" but got "rgb(127, 95, 159)"
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 62.5%, 0.2) 
@@ -2703,26 +2703,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 12.5%) assert_equals: expected "rgb(32, 20, 44)" but got "rgb(31, 19, 43)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 12.5%, 0) assert_equals: expected "rgba(32, 20, 44, 0)" but got "rgba(31, 19, 43, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 20, 44, 0.2)" but got "rgba(31, 19, 43, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 12.5%, 1) assert_equals: expected "rgb(32, 20, 44)" but got "rgb(31, 19, 43)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 25%) assert_equals: expected "rgb(64, 40, 88)" but got "rgb(63, 39, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 25%, 0) assert_equals: expected "rgba(64, 40, 88, 0)" but got "rgba(63, 39, 87, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 25%, 0.2) assert_equals: expected "rgba(64, 40, 88, 0.2)" but got "rgba(63, 39, 87, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 25%, 1) assert_equals: expected "rgb(64, 40, 88)" but got "rgb(63, 39, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 37.5%) assert_equals: expected "rgb(96, 60, 131)" but got "rgb(95, 59, 131)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 37.5%, 0) assert_equals: expected "rgba(96, 60, 131, 0)" but got "rgba(95, 59, 131, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 60, 131, 0.2)" but got "rgba(95, 59, 131, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 37.5%, 1) assert_equals: expected "rgb(96, 60, 131)" but got "rgb(95, 59, 131)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 50%) assert_equals: expected "rgb(128, 80, 175)" but got "rgb(127, 79, 175)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 50%, 0) assert_equals: expected "rgba(128, 80, 175, 0)" but got "rgba(127, 79, 175, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 50%, 0.2) assert_equals: expected "rgba(128, 80, 175, 0.2)" but got "rgba(127, 79, 175, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 50%, 1) assert_equals: expected "rgb(128, 80, 175)" but got "rgb(127, 79, 175)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 62.5%) assert_equals: expected "rgb(159, 124, 195)" but got "rgb(159, 123, 195)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 62.5%, 0) assert_equals: expected "rgba(159, 124, 195, 0)" but got "rgba(159, 123, 195, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(159, 124, 195, 0.2)" but got "rgba(159, 123, 195, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 62.5%, 1) assert_equals: expected "rgb(159, 124, 195)" but got "rgb(159, 123, 195)"
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 75%, 0.2) 
@@ -2739,26 +2739,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 50%, 12.5%) assert_equals: expected "rgb(32, 16, 48)" but got "rgb(31, 15, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 12.5%, 0) assert_equals: expected "rgba(32, 16, 48, 0)" but got "rgba(31, 15, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 12.5%, 0.2) assert_equals: expected "rgba(32, 16, 48, 0.2)" but got "rgba(31, 15, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 12.5%, 1) assert_equals: expected "rgb(32, 16, 48)" but got "rgb(31, 15, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 50%, 25%) assert_equals: expected "rgb(64, 32, 96)" but got "rgb(63, 31, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 25%, 0) assert_equals: expected "rgba(64, 32, 96, 0)" but got "rgba(63, 31, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 25%, 0.2) assert_equals: expected "rgba(64, 32, 96, 0.2)" but got "rgba(63, 31, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 25%, 1) assert_equals: expected "rgb(64, 32, 96)" but got "rgb(63, 31, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 50%, 37.5%) assert_equals: expected "rgb(96, 48, 143)" but got "rgb(95, 47, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 37.5%, 0) assert_equals: expected "rgba(96, 48, 143, 0)" but got "rgba(95, 47, 143, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 37.5%, 0.2) assert_equals: expected "rgba(96, 48, 143, 0.2)" but got "rgba(95, 47, 143, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 37.5%, 1) assert_equals: expected "rgb(96, 48, 143)" but got "rgb(95, 47, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 50%, 50%) assert_equals: expected "rgb(128, 64, 191)" but got "rgb(127, 63, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 50%, 0) assert_equals: expected "rgba(128, 64, 191, 0)" but got "rgba(127, 63, 191, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 50%, 0.2) assert_equals: expected "rgba(128, 64, 191, 0.2)" but got "rgba(127, 63, 191, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 50%, 1) assert_equals: expected "rgb(128, 64, 191)" but got "rgb(127, 63, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 50%, 62.5%) assert_equals: expected "rgb(159, 112, 207)" but got "rgb(159, 111, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 62.5%, 0) assert_equals: expected "rgba(159, 112, 207, 0)" but got "rgba(159, 111, 207, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 62.5%, 0.2) assert_equals: expected "rgba(159, 112, 207, 0.2)" but got "rgba(159, 111, 207, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 62.5%, 1) assert_equals: expected "rgb(159, 112, 207)" but got "rgb(159, 111, 207)"
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 75%, 0.2) 
@@ -2775,26 +2775,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 12.5%) assert_equals: expected "rgb(32, 12, 52)" but got "rgb(31, 11, 51)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 12.5%, 0) assert_equals: expected "rgba(32, 12, 52, 0)" but got "rgba(31, 11, 51, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 12, 52, 0.2)" but got "rgba(31, 11, 51, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 12.5%, 1) assert_equals: expected "rgb(32, 12, 52)" but got "rgb(31, 11, 51)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 25%) assert_equals: expected "rgb(64, 24, 104)" but got "rgb(63, 23, 103)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 25%, 0) assert_equals: expected "rgba(64, 24, 104, 0)" but got "rgba(63, 23, 103, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 25%, 0.2) assert_equals: expected "rgba(64, 24, 104, 0.2)" but got "rgba(63, 23, 103, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 25%, 1) assert_equals: expected "rgb(64, 24, 104)" but got "rgb(63, 23, 103)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 37.5%) assert_equals: expected "rgb(96, 36, 155)" but got "rgb(95, 35, 155)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 37.5%, 0) assert_equals: expected "rgba(96, 36, 155, 0)" but got "rgba(95, 35, 155, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 36, 155, 0.2)" but got "rgba(95, 35, 155, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 37.5%, 1) assert_equals: expected "rgb(96, 36, 155)" but got "rgb(95, 35, 155)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 50%) assert_equals: expected "rgb(128, 48, 207)" but got "rgb(127, 47, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 50%, 0) assert_equals: expected "rgba(128, 48, 207, 0)" but got "rgba(127, 47, 207, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 50%, 0.2) assert_equals: expected "rgba(128, 48, 207, 0.2)" but got "rgba(127, 47, 207, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 50%, 1) assert_equals: expected "rgb(128, 48, 207)" but got "rgb(127, 47, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 62.5%) assert_equals: expected "rgb(159, 100, 219)" but got "rgb(159, 99, 219)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 62.5%, 0) assert_equals: expected "rgba(159, 100, 219, 0)" but got "rgba(159, 99, 219, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(159, 100, 219, 0.2)" but got "rgba(159, 99, 219, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 62.5%, 1) assert_equals: expected "rgb(159, 100, 219)" but got "rgb(159, 99, 219)"
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 75%, 0.2) 
@@ -2811,26 +2811,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 75%, 12.5%) assert_equals: expected "rgb(32, 8, 56)" but got "rgb(31, 7, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 12.5%, 0) assert_equals: expected "rgba(32, 8, 56, 0)" but got "rgba(31, 7, 55, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 12.5%, 0.2) assert_equals: expected "rgba(32, 8, 56, 0.2)" but got "rgba(31, 7, 55, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 12.5%, 1) assert_equals: expected "rgb(32, 8, 56)" but got "rgb(31, 7, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 75%, 25%) assert_equals: expected "rgb(64, 16, 112)" but got "rgb(63, 15, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 25%, 0) assert_equals: expected "rgba(64, 16, 112, 0)" but got "rgba(63, 15, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 25%, 0.2) assert_equals: expected "rgba(64, 16, 112, 0.2)" but got "rgba(63, 15, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 25%, 1) assert_equals: expected "rgb(64, 16, 112)" but got "rgb(63, 15, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 75%, 37.5%) assert_equals: expected "rgb(96, 24, 167)" but got "rgb(95, 23, 167)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 37.5%, 0) assert_equals: expected "rgba(96, 24, 167, 0)" but got "rgba(95, 23, 167, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 37.5%, 0.2) assert_equals: expected "rgba(96, 24, 167, 0.2)" but got "rgba(95, 23, 167, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 37.5%, 1) assert_equals: expected "rgb(96, 24, 167)" but got "rgb(95, 23, 167)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 75%, 50%) assert_equals: expected "rgb(128, 32, 223)" but got "rgb(127, 31, 223)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 50%, 0) assert_equals: expected "rgba(128, 32, 223, 0)" but got "rgba(127, 31, 223, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 50%, 0.2) assert_equals: expected "rgba(128, 32, 223, 0.2)" but got "rgba(127, 31, 223, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 50%, 1) assert_equals: expected "rgb(128, 32, 223)" but got "rgb(127, 31, 223)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 75%, 62.5%) assert_equals: expected "rgb(159, 88, 231)" but got "rgb(159, 87, 231)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 62.5%, 0) assert_equals: expected "rgba(159, 88, 231, 0)" but got "rgba(159, 87, 231, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 62.5%, 0.2) assert_equals: expected "rgba(159, 88, 231, 0.2)" but got "rgba(159, 87, 231, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 62.5%, 1) assert_equals: expected "rgb(159, 88, 231)" but got "rgb(159, 87, 231)"
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 75%, 0.2) 
@@ -2847,26 +2847,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 12.5%) assert_equals: expected "rgb(32, 4, 60)" but got "rgb(31, 3, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 12.5%, 0) assert_equals: expected "rgba(32, 4, 60, 0)" but got "rgba(31, 3, 59, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 4, 60, 0.2)" but got "rgba(31, 3, 59, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 12.5%, 1) assert_equals: expected "rgb(32, 4, 60)" but got "rgb(31, 3, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 25%) assert_equals: expected "rgb(64, 8, 120)" but got "rgb(63, 7, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 25%, 0) assert_equals: expected "rgba(64, 8, 120, 0)" but got "rgba(63, 7, 119, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 25%, 0.2) assert_equals: expected "rgba(64, 8, 120, 0.2)" but got "rgba(63, 7, 119, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 25%, 1) assert_equals: expected "rgb(64, 8, 120)" but got "rgb(63, 7, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 37.5%) assert_equals: expected "rgb(96, 12, 179)" but got "rgb(95, 11, 179)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 37.5%, 0) assert_equals: expected "rgba(96, 12, 179, 0)" but got "rgba(95, 11, 179, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 12, 179, 0.2)" but got "rgba(95, 11, 179, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 37.5%, 1) assert_equals: expected "rgb(96, 12, 179)" but got "rgb(95, 11, 179)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 50%) assert_equals: expected "rgb(128, 16, 239)" but got "rgb(127, 15, 239)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 50%, 0) assert_equals: expected "rgba(128, 16, 239, 0)" but got "rgba(127, 15, 239, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 50%, 0.2) assert_equals: expected "rgba(128, 16, 239, 0.2)" but got "rgba(127, 15, 239, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 50%, 1) assert_equals: expected "rgb(128, 16, 239)" but got "rgb(127, 15, 239)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 62.5%) assert_equals: expected "rgb(159, 76, 243)" but got "rgb(159, 75, 243)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 62.5%, 0) assert_equals: expected "rgba(159, 76, 243, 0)" but got "rgba(159, 75, 243, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(159, 76, 243, 0.2)" but got "rgba(159, 75, 243, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 62.5%, 1) assert_equals: expected "rgb(159, 76, 243)" but got "rgb(159, 75, 243)"
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 75%, 0.2) 
@@ -2883,30 +2883,30 @@ PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 100%, 12.5%) assert_equals: expected "rgb(32, 0, 64)" but got "rgb(31, 0, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 12.5%, 0) assert_equals: expected "rgba(32, 0, 64, 0)" but got "rgba(31, 0, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 12.5%, 0.2) assert_equals: expected "rgba(32, 0, 64, 0.2)" but got "rgba(31, 0, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 12.5%, 1) assert_equals: expected "rgb(32, 0, 64)" but got "rgb(31, 0, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 100%, 25%) assert_equals: expected "rgb(64, 0, 128)" but got "rgb(63, 0, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 25%, 0) assert_equals: expected "rgba(64, 0, 128, 0)" but got "rgba(63, 0, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 25%, 0.2) assert_equals: expected "rgba(64, 0, 128, 0.2)" but got "rgba(63, 0, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 25%, 1) assert_equals: expected "rgb(64, 0, 128)" but got "rgb(63, 0, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 100%, 37.5%) assert_equals: expected "rgb(96, 0, 191)" but got "rgb(95, 0, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 37.5%, 0) assert_equals: expected "rgba(96, 0, 191, 0)" but got "rgba(95, 0, 191, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 37.5%, 0.2) assert_equals: expected "rgba(96, 0, 191, 0.2)" but got "rgba(95, 0, 191, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 37.5%, 1) assert_equals: expected "rgb(96, 0, 191)" but got "rgb(95, 0, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 100%, 50%) assert_equals: expected "rgb(128, 0, 255)" but got "rgb(127, 0, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 50%, 0) assert_equals: expected "rgba(128, 0, 255, 0)" but got "rgba(127, 0, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 50%, 0.2) assert_equals: expected "rgba(128, 0, 255, 0.2)" but got "rgba(127, 0, 255, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 50%, 1) assert_equals: expected "rgb(128, 0, 255)" but got "rgb(127, 0, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 100%, 62.5%) assert_equals: expected "rgb(159, 64, 255)" but got "rgb(159, 63, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 62.5%, 0) assert_equals: expected "rgba(159, 64, 255, 0)" but got "rgba(159, 63, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 62.5%, 0.2) assert_equals: expected "rgba(159, 64, 255, 0.2)" but got "rgba(159, 63, 255, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 62.5%, 1) assert_equals: expected "rgb(159, 64, 255)" but got "rgb(159, 63, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(270, 100%, 75%) assert_equals: expected "rgb(191, 128, 255)" but got "rgb(191, 127, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 75%, 0) assert_equals: expected "rgba(191, 128, 255, 0)" but got "rgba(191, 127, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 75%, 0.2) assert_equals: expected "rgba(191, 128, 255, 0.2)" but got "rgba(191, 127, 255, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 75%, 1) assert_equals: expected "rgb(191, 128, 255)" but got "rgb(191, 127, 255)"
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 62.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 75%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 75%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 75%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 75%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 87.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 87.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 87.5%, 0.2) 
@@ -2919,22 +2919,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 62.5%, 0.2) 
@@ -2955,22 +2955,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 12.5%) assert_equals: expected "rgb(36, 28, 36)" but got "rgb(35, 27, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 12.5%, 0) assert_equals: expected "rgba(36, 28, 36, 0)" but got "rgba(35, 27, 35, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(36, 28, 36, 0.2)" but got "rgba(35, 27, 35, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 12.5%, 1) assert_equals: expected "rgb(36, 28, 36)" but got "rgb(35, 27, 35)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 25%) assert_equals: expected "rgb(72, 56, 72)" but got "rgb(71, 55, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 25%, 0) assert_equals: expected "rgba(72, 56, 72, 0)" but got "rgba(71, 55, 71, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 25%, 0.2) assert_equals: expected "rgba(72, 56, 72, 0.2)" but got "rgba(71, 55, 71, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 25%, 1) assert_equals: expected "rgb(72, 56, 72)" but got "rgb(71, 55, 71)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 37.5%) assert_equals: expected "rgb(108, 84, 108)" but got "rgb(107, 83, 107)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 37.5%, 0) assert_equals: expected "rgba(108, 84, 108, 0)" but got "rgba(107, 83, 107, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(108, 84, 108, 0.2)" but got "rgba(107, 83, 107, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 37.5%, 1) assert_equals: expected "rgb(108, 84, 108)" but got "rgb(107, 83, 107)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 50%) assert_equals: expected "rgb(143, 112, 143)" but got "rgb(143, 111, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 50%, 0) assert_equals: expected "rgba(143, 112, 143, 0)" but got "rgba(143, 111, 143, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 50%, 0.2) assert_equals: expected "rgba(143, 112, 143, 0.2)" but got "rgba(143, 111, 143, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 50%, 1) assert_equals: expected "rgb(143, 112, 143)" but got "rgb(143, 111, 143)"
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 62.5%, 0.2) 
@@ -2991,22 +2991,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 25%, 12.5%) assert_equals: expected "rgb(40, 24, 40)" but got "rgb(39, 23, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 12.5%, 0) assert_equals: expected "rgba(40, 24, 40, 0)" but got "rgba(39, 23, 39, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 12.5%, 0.2) assert_equals: expected "rgba(40, 24, 40, 0.2)" but got "rgba(39, 23, 39, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 12.5%, 1) assert_equals: expected "rgb(40, 24, 40)" but got "rgb(39, 23, 39)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 25%, 25%) assert_equals: expected "rgb(80, 48, 80)" but got "rgb(79, 47, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 25%, 0) assert_equals: expected "rgba(80, 48, 80, 0)" but got "rgba(79, 47, 79, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 25%, 0.2) assert_equals: expected "rgba(80, 48, 80, 0.2)" but got "rgba(79, 47, 79, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 25%, 1) assert_equals: expected "rgb(80, 48, 80)" but got "rgb(79, 47, 79)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 25%, 37.5%) assert_equals: expected "rgb(120, 72, 120)" but got "rgb(119, 71, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 37.5%, 0) assert_equals: expected "rgba(120, 72, 120, 0)" but got "rgba(119, 71, 119, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 37.5%, 0.2) assert_equals: expected "rgba(120, 72, 120, 0.2)" but got "rgba(119, 71, 119, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 37.5%, 1) assert_equals: expected "rgb(120, 72, 120)" but got "rgb(119, 71, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 25%, 50%) assert_equals: expected "rgb(159, 96, 159)" but got "rgb(159, 95, 159)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 50%, 0) assert_equals: expected "rgba(159, 96, 159, 0)" but got "rgba(159, 95, 159, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 50%, 0.2) assert_equals: expected "rgba(159, 96, 159, 0.2)" but got "rgba(159, 95, 159, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 50%, 1) assert_equals: expected "rgb(159, 96, 159)" but got "rgb(159, 95, 159)"
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 62.5%, 0.2) 
@@ -3027,26 +3027,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 12.5%) assert_equals: expected "rgb(44, 20, 44)" but got "rgb(43, 19, 43)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 12.5%, 0) assert_equals: expected "rgba(44, 20, 44, 0)" but got "rgba(43, 19, 43, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(44, 20, 44, 0.2)" but got "rgba(43, 19, 43, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 12.5%, 1) assert_equals: expected "rgb(44, 20, 44)" but got "rgb(43, 19, 43)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 25%) assert_equals: expected "rgb(88, 40, 88)" but got "rgb(87, 39, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 25%, 0) assert_equals: expected "rgba(88, 40, 88, 0)" but got "rgba(87, 39, 87, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 25%, 0.2) assert_equals: expected "rgba(88, 40, 88, 0.2)" but got "rgba(87, 39, 87, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 25%, 1) assert_equals: expected "rgb(88, 40, 88)" but got "rgb(87, 39, 87)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 37.5%) assert_equals: expected "rgb(131, 60, 131)" but got "rgb(131, 59, 131)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 37.5%, 0) assert_equals: expected "rgba(131, 60, 131, 0)" but got "rgba(131, 59, 131, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(131, 60, 131, 0.2)" but got "rgba(131, 59, 131, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 37.5%, 1) assert_equals: expected "rgb(131, 60, 131)" but got "rgb(131, 59, 131)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 50%) assert_equals: expected "rgb(175, 80, 175)" but got "rgb(175, 79, 175)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 50%, 0) assert_equals: expected "rgba(175, 80, 175, 0)" but got "rgba(175, 79, 175, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 50%, 0.2) assert_equals: expected "rgba(175, 80, 175, 0.2)" but got "rgba(175, 79, 175, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 50%, 1) assert_equals: expected "rgb(175, 80, 175)" but got "rgb(175, 79, 175)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 62.5%) assert_equals: expected "rgb(195, 124, 195)" but got "rgb(195, 123, 195)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 62.5%, 0) assert_equals: expected "rgba(195, 124, 195, 0)" but got "rgba(195, 123, 195, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(195, 124, 195, 0.2)" but got "rgba(195, 123, 195, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 62.5%, 1) assert_equals: expected "rgb(195, 124, 195)" but got "rgb(195, 123, 195)"
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 75%, 0.2) 
@@ -3063,26 +3063,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 50%, 12.5%) assert_equals: expected "rgb(48, 16, 48)" but got "rgb(47, 15, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 12.5%, 0) assert_equals: expected "rgba(48, 16, 48, 0)" but got "rgba(47, 15, 47, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 12.5%, 0.2) assert_equals: expected "rgba(48, 16, 48, 0.2)" but got "rgba(47, 15, 47, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 12.5%, 1) assert_equals: expected "rgb(48, 16, 48)" but got "rgb(47, 15, 47)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 50%, 25%) assert_equals: expected "rgb(96, 32, 96)" but got "rgb(95, 31, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 25%, 0) assert_equals: expected "rgba(96, 32, 96, 0)" but got "rgba(95, 31, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 25%, 0.2) assert_equals: expected "rgba(96, 32, 96, 0.2)" but got "rgba(95, 31, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 25%, 1) assert_equals: expected "rgb(96, 32, 96)" but got "rgb(95, 31, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 50%, 37.5%) assert_equals: expected "rgb(143, 48, 143)" but got "rgb(143, 47, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 37.5%, 0) assert_equals: expected "rgba(143, 48, 143, 0)" but got "rgba(143, 47, 143, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 37.5%, 0.2) assert_equals: expected "rgba(143, 48, 143, 0.2)" but got "rgba(143, 47, 143, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 37.5%, 1) assert_equals: expected "rgb(143, 48, 143)" but got "rgb(143, 47, 143)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 50%, 50%) assert_equals: expected "rgb(191, 64, 191)" but got "rgb(191, 63, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 50%, 0) assert_equals: expected "rgba(191, 64, 191, 0)" but got "rgba(191, 63, 191, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 50%, 0.2) assert_equals: expected "rgba(191, 64, 191, 0.2)" but got "rgba(191, 63, 191, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 50%, 1) assert_equals: expected "rgb(191, 64, 191)" but got "rgb(191, 63, 191)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 50%, 62.5%) assert_equals: expected "rgb(207, 112, 207)" but got "rgb(207, 111, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 62.5%, 0) assert_equals: expected "rgba(207, 112, 207, 0)" but got "rgba(207, 111, 207, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 62.5%, 0.2) assert_equals: expected "rgba(207, 112, 207, 0.2)" but got "rgba(207, 111, 207, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 62.5%, 1) assert_equals: expected "rgb(207, 112, 207)" but got "rgb(207, 111, 207)"
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 75%, 0.2) 
@@ -3099,26 +3099,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 12.5%) assert_equals: expected "rgb(52, 12, 52)" but got "rgb(51, 11, 51)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 12.5%, 0) assert_equals: expected "rgba(52, 12, 52, 0)" but got "rgba(51, 11, 51, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(52, 12, 52, 0.2)" but got "rgba(51, 11, 51, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 12.5%, 1) assert_equals: expected "rgb(52, 12, 52)" but got "rgb(51, 11, 51)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 25%) assert_equals: expected "rgb(104, 24, 104)" but got "rgb(103, 23, 103)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 25%, 0) assert_equals: expected "rgba(104, 24, 104, 0)" but got "rgba(103, 23, 103, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 25%, 0.2) assert_equals: expected "rgba(104, 24, 104, 0.2)" but got "rgba(103, 23, 103, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 25%, 1) assert_equals: expected "rgb(104, 24, 104)" but got "rgb(103, 23, 103)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 37.5%) assert_equals: expected "rgb(155, 36, 155)" but got "rgb(155, 35, 155)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 37.5%, 0) assert_equals: expected "rgba(155, 36, 155, 0)" but got "rgba(155, 35, 155, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(155, 36, 155, 0.2)" but got "rgba(155, 35, 155, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 37.5%, 1) assert_equals: expected "rgb(155, 36, 155)" but got "rgb(155, 35, 155)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 50%) assert_equals: expected "rgb(207, 48, 207)" but got "rgb(207, 47, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 50%, 0) assert_equals: expected "rgba(207, 48, 207, 0)" but got "rgba(207, 47, 207, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 50%, 0.2) assert_equals: expected "rgba(207, 48, 207, 0.2)" but got "rgba(207, 47, 207, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 50%, 1) assert_equals: expected "rgb(207, 48, 207)" but got "rgb(207, 47, 207)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 62.5%) assert_equals: expected "rgb(219, 100, 219)" but got "rgb(219, 99, 219)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 62.5%, 0) assert_equals: expected "rgba(219, 100, 219, 0)" but got "rgba(219, 99, 219, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(219, 100, 219, 0.2)" but got "rgba(219, 99, 219, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 62.5%, 1) assert_equals: expected "rgb(219, 100, 219)" but got "rgb(219, 99, 219)"
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 75%, 0.2) 
@@ -3135,26 +3135,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 75%, 12.5%) assert_equals: expected "rgb(56, 8, 56)" but got "rgb(55, 7, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 12.5%, 0) assert_equals: expected "rgba(56, 8, 56, 0)" but got "rgba(55, 7, 55, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 12.5%, 0.2) assert_equals: expected "rgba(56, 8, 56, 0.2)" but got "rgba(55, 7, 55, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 12.5%, 1) assert_equals: expected "rgb(56, 8, 56)" but got "rgb(55, 7, 55)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 75%, 25%) assert_equals: expected "rgb(112, 16, 112)" but got "rgb(111, 15, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 25%, 0) assert_equals: expected "rgba(112, 16, 112, 0)" but got "rgba(111, 15, 111, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 25%, 0.2) assert_equals: expected "rgba(112, 16, 112, 0.2)" but got "rgba(111, 15, 111, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 25%, 1) assert_equals: expected "rgb(112, 16, 112)" but got "rgb(111, 15, 111)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 75%, 37.5%) assert_equals: expected "rgb(167, 24, 167)" but got "rgb(167, 23, 167)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 37.5%, 0) assert_equals: expected "rgba(167, 24, 167, 0)" but got "rgba(167, 23, 167, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 37.5%, 0.2) assert_equals: expected "rgba(167, 24, 167, 0.2)" but got "rgba(167, 23, 167, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 37.5%, 1) assert_equals: expected "rgb(167, 24, 167)" but got "rgb(167, 23, 167)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 75%, 50%) assert_equals: expected "rgb(223, 32, 223)" but got "rgb(223, 31, 223)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 50%, 0) assert_equals: expected "rgba(223, 32, 223, 0)" but got "rgba(223, 31, 223, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 50%, 0.2) assert_equals: expected "rgba(223, 32, 223, 0.2)" but got "rgba(223, 31, 223, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 50%, 1) assert_equals: expected "rgb(223, 32, 223)" but got "rgb(223, 31, 223)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 75%, 62.5%) assert_equals: expected "rgb(231, 88, 231)" but got "rgb(231, 87, 231)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 62.5%, 0) assert_equals: expected "rgba(231, 88, 231, 0)" but got "rgba(231, 87, 231, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 62.5%, 0.2) assert_equals: expected "rgba(231, 88, 231, 0.2)" but got "rgba(231, 87, 231, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 62.5%, 1) assert_equals: expected "rgb(231, 88, 231)" but got "rgb(231, 87, 231)"
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 75%, 0.2) 
@@ -3171,26 +3171,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 12.5%) assert_equals: expected "rgb(60, 4, 60)" but got "rgb(59, 3, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 12.5%, 0) assert_equals: expected "rgba(60, 4, 60, 0)" but got "rgba(59, 3, 59, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(60, 4, 60, 0.2)" but got "rgba(59, 3, 59, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 12.5%, 1) assert_equals: expected "rgb(60, 4, 60)" but got "rgb(59, 3, 59)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 25%) assert_equals: expected "rgb(120, 8, 120)" but got "rgb(119, 7, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 25%, 0) assert_equals: expected "rgba(120, 8, 120, 0)" but got "rgba(119, 7, 119, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 25%, 0.2) assert_equals: expected "rgba(120, 8, 120, 0.2)" but got "rgba(119, 7, 119, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 25%, 1) assert_equals: expected "rgb(120, 8, 120)" but got "rgb(119, 7, 119)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 37.5%) assert_equals: expected "rgb(179, 12, 179)" but got "rgb(179, 11, 179)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 37.5%, 0) assert_equals: expected "rgba(179, 12, 179, 0)" but got "rgba(179, 11, 179, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(179, 12, 179, 0.2)" but got "rgba(179, 11, 179, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 37.5%, 1) assert_equals: expected "rgb(179, 12, 179)" but got "rgb(179, 11, 179)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 50%) assert_equals: expected "rgb(239, 16, 239)" but got "rgb(239, 15, 239)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 50%, 0) assert_equals: expected "rgba(239, 16, 239, 0)" but got "rgba(239, 15, 239, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 50%, 0.2) assert_equals: expected "rgba(239, 16, 239, 0.2)" but got "rgba(239, 15, 239, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 50%, 1) assert_equals: expected "rgb(239, 16, 239)" but got "rgb(239, 15, 239)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 62.5%) assert_equals: expected "rgb(243, 76, 243)" but got "rgb(243, 75, 243)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 62.5%, 0) assert_equals: expected "rgba(243, 76, 243, 0)" but got "rgba(243, 75, 243, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(243, 76, 243, 0.2)" but got "rgba(243, 75, 243, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 62.5%, 1) assert_equals: expected "rgb(243, 76, 243)" but got "rgb(243, 75, 243)"
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 75%, 0.2) 
@@ -3207,14 +3207,14 @@ PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 100%, 12.5%) assert_equals: expected "rgb(64, 0, 64)" but got "rgb(63, 0, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 12.5%, 0) assert_equals: expected "rgba(64, 0, 64, 0)" but got "rgba(63, 0, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 12.5%, 0.2) assert_equals: expected "rgba(64, 0, 64, 0.2)" but got "rgba(63, 0, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 12.5%, 1) assert_equals: expected "rgb(64, 0, 64)" but got "rgb(63, 0, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 100%, 25%) assert_equals: expected "rgb(128, 0, 128)" but got "rgb(127, 0, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 25%, 0) assert_equals: expected "rgba(128, 0, 128, 0)" but got "rgba(127, 0, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 25%, 0.2) assert_equals: expected "rgba(128, 0, 128, 0.2)" but got "rgba(127, 0, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 25%, 1) assert_equals: expected "rgb(128, 0, 128)" but got "rgb(127, 0, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 25%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 37.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 37.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 37.5%, 0.2) 
@@ -3223,14 +3223,14 @@ PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 50%)
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 50%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 50%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 50%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 100%, 62.5%) assert_equals: expected "rgb(255, 64, 255)" but got "rgb(255, 63, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 62.5%, 0) assert_equals: expected "rgba(255, 64, 255, 0)" but got "rgba(255, 63, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 62.5%, 0.2) assert_equals: expected "rgba(255, 64, 255, 0.2)" but got "rgba(255, 63, 255, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 62.5%, 1) assert_equals: expected "rgb(255, 64, 255)" but got "rgb(255, 63, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(300, 100%, 75%) assert_equals: expected "rgb(255, 128, 255)" but got "rgb(255, 127, 255)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 75%, 0) assert_equals: expected "rgba(255, 128, 255, 0)" but got "rgba(255, 127, 255, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 75%, 0.2) assert_equals: expected "rgba(255, 128, 255, 0.2)" but got "rgba(255, 127, 255, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 75%, 1) assert_equals: expected "rgb(255, 128, 255)" but got "rgb(255, 127, 255)"
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 62.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 75%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 75%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 75%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 75%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 87.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 87.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 87.5%, 0.2) 
@@ -3243,22 +3243,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 62.5%, 0.2) 
@@ -3279,22 +3279,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 12.5%) assert_equals: expected "rgb(36, 28, 32)" but got "rgb(35, 27, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 12.5%, 0) assert_equals: expected "rgba(36, 28, 32, 0)" but got "rgba(35, 27, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(36, 28, 32, 0.2)" but got "rgba(35, 27, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 12.5%, 1) assert_equals: expected "rgb(36, 28, 32)" but got "rgb(35, 27, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 25%) assert_equals: expected "rgb(72, 56, 64)" but got "rgb(71, 55, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 25%, 0) assert_equals: expected "rgba(72, 56, 64, 0)" but got "rgba(71, 55, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 25%, 0.2) assert_equals: expected "rgba(72, 56, 64, 0.2)" but got "rgba(71, 55, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 25%, 1) assert_equals: expected "rgb(72, 56, 64)" but got "rgb(71, 55, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 37.5%) assert_equals: expected "rgb(108, 84, 96)" but got "rgb(107, 83, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 37.5%, 0) assert_equals: expected "rgba(108, 84, 96, 0)" but got "rgba(107, 83, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(108, 84, 96, 0.2)" but got "rgba(107, 83, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 37.5%, 1) assert_equals: expected "rgb(108, 84, 96)" but got "rgb(107, 83, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 50%) assert_equals: expected "rgb(143, 112, 128)" but got "rgb(143, 111, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 50%, 0) assert_equals: expected "rgba(143, 112, 128, 0)" but got "rgba(143, 111, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 50%, 0.2) assert_equals: expected "rgba(143, 112, 128, 0.2)" but got "rgba(143, 111, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 50%, 1) assert_equals: expected "rgb(143, 112, 128)" but got "rgb(143, 111, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 62.5%, 0.2) 
@@ -3315,22 +3315,22 @@ PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 25%, 12.5%) assert_equals: expected "rgb(40, 24, 32)" but got "rgb(39, 23, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 12.5%, 0) assert_equals: expected "rgba(40, 24, 32, 0)" but got "rgba(39, 23, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 12.5%, 0.2) assert_equals: expected "rgba(40, 24, 32, 0.2)" but got "rgba(39, 23, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 12.5%, 1) assert_equals: expected "rgb(40, 24, 32)" but got "rgb(39, 23, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 25%, 25%) assert_equals: expected "rgb(80, 48, 64)" but got "rgb(79, 47, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 25%, 0) assert_equals: expected "rgba(80, 48, 64, 0)" but got "rgba(79, 47, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 25%, 0.2) assert_equals: expected "rgba(80, 48, 64, 0.2)" but got "rgba(79, 47, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 25%, 1) assert_equals: expected "rgb(80, 48, 64)" but got "rgb(79, 47, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 25%, 37.5%) assert_equals: expected "rgb(120, 72, 96)" but got "rgb(119, 71, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 37.5%, 0) assert_equals: expected "rgba(120, 72, 96, 0)" but got "rgba(119, 71, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 37.5%, 0.2) assert_equals: expected "rgba(120, 72, 96, 0.2)" but got "rgba(119, 71, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 37.5%, 1) assert_equals: expected "rgb(120, 72, 96)" but got "rgb(119, 71, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 25%, 50%) assert_equals: expected "rgb(159, 96, 128)" but got "rgb(159, 95, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 50%, 0) assert_equals: expected "rgba(159, 96, 128, 0)" but got "rgba(159, 95, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 50%, 0.2) assert_equals: expected "rgba(159, 96, 128, 0.2)" but got "rgba(159, 95, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 50%, 1) assert_equals: expected "rgb(159, 96, 128)" but got "rgb(159, 95, 127)"
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 50%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 62.5%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 62.5%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 62.5%, 0.2) 
@@ -3351,26 +3351,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 12.5%) assert_equals: expected "rgb(44, 20, 32)" but got "rgb(43, 19, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 12.5%, 0) assert_equals: expected "rgba(44, 20, 32, 0)" but got "rgba(43, 19, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(44, 20, 32, 0.2)" but got "rgba(43, 19, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 12.5%, 1) assert_equals: expected "rgb(44, 20, 32)" but got "rgb(43, 19, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 25%) assert_equals: expected "rgb(88, 40, 64)" but got "rgb(87, 39, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 25%, 0) assert_equals: expected "rgba(88, 40, 64, 0)" but got "rgba(87, 39, 63, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 25%, 0.2) assert_equals: expected "rgba(88, 40, 64, 0.2)" but got "rgba(87, 39, 63, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 25%, 1) assert_equals: expected "rgb(88, 40, 64)" but got "rgb(87, 39, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 37.5%) assert_equals: expected "rgb(131, 60, 96)" but got "rgb(131, 59, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 37.5%, 0) assert_equals: expected "rgba(131, 60, 96, 0)" but got "rgba(131, 59, 95, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(131, 60, 96, 0.2)" but got "rgba(131, 59, 95, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 37.5%, 1) assert_equals: expected "rgb(131, 60, 96)" but got "rgb(131, 59, 95)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 50%) assert_equals: expected "rgb(175, 80, 128)" but got "rgb(175, 79, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 50%, 0) assert_equals: expected "rgba(175, 80, 128, 0)" but got "rgba(175, 79, 127, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 50%, 0.2) assert_equals: expected "rgba(175, 80, 128, 0.2)" but got "rgba(175, 79, 127, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 50%, 1) assert_equals: expected "rgb(175, 80, 128)" but got "rgb(175, 79, 127)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 62.5%) assert_equals: expected "rgb(195, 124, 159)" but got "rgb(195, 123, 159)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 62.5%, 0) assert_equals: expected "rgba(195, 124, 159, 0)" but got "rgba(195, 123, 159, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(195, 124, 159, 0.2)" but got "rgba(195, 123, 159, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 62.5%, 1) assert_equals: expected "rgb(195, 124, 159)" but got "rgb(195, 123, 159)"
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 12.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 12.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 12.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 12.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 25%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 25%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 25%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 25%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 37.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 37.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 37.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 37.5%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 50%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 50%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 50%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 50%, 1) 
+PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 62.5%) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 62.5%, 0) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 62.5%, 0.2) 
+PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 62.5%, 1) 
 PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 75%) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 75%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 75%, 0.2) 
@@ -3387,26 +3387,26 @@ PASS HSL/HSLA value should parse and round correctly: hsl(330, 50%, 0%)
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 0%, 0) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 0%, 0.2) 
 PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 0%, 1) 
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 50%, 12.5%) assert_equals: expected "rgb(48, 16, 32)" but got "rgb(47, 15, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 12.5%, 0) assert_equals: expected "rgba(48, 16, 32, 0)" but got "rgba(47, 15, 31, 0)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 12.5%, 0.2) assert_equals: expected "rgba(48, 16, 32, 0.2)" but got "rgba(47, 15, 31, 0.2)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 12.5%, 1) assert_equals: expected "rgb(48, 16, 32)" but got "rgb(47, 15, 31)"
-FAIL HSL/HSLA value should parse and round correctly: hsl(330, 50%, 25%) assert_equals: expected "rgb(96, 32, 64)" but got "rgb(95, 31, 63)"
-FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 25%, 0)&n