Changeset 251750 in webkit


Ignore:
Timestamp:
Oct 29, 2019, 5:55:27 PM (5 years ago)
Author:
Simon Fraser
Message:

Align CSS hsl() -> rgb() color conversion with the spec
​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:
Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r251746 r251750  
    6969
    7070        * fast/events/ios/autocorrect-with-range-selection.html:
     71
     722019-10-29  Simon Fraser  <simon.fraser@apple.com>
     73
     74        Align CSS hsl() -> rgb() color conversion with the spec
     75        https://bugs.webkit.org/show_bug.cgi?id=203592
     76
     77        Reviewed by Tim Horton.
     78
     79        * platform/mac/fast/css/hsl-color-expected.txt:
     80        * platform/mac/fast/css/hsla-color-expected.txt:
    7181
    72822019-10-07  Jer Noble  <jer.noble@apple.com>

  • trunk/LayoutTests/css3/calc/color-hsl-expected.txt

    r122694 r251750  
    44
    55
    6 PASS getComputedStyle(document.getElementById("simple"), null).color is "rgb(31, 223, 31)"
    7 PASS getComputedStyle(document.getElementById("alpha"), null).color is "rgba(31, 223, 31, 0.701961)"
     6PASS getComputedStyle(document.getElementById("simple"), null).color is "rgb(32, 223, 32)"
     7PASS getComputedStyle(document.getElementById("alpha"), null).color is "rgba(32, 223, 32, 0.701961)"
    88PASS successfullyParsed is true
    99

  • trunk/LayoutTests/fast/css3-text/css3-text-decoration/getComputedStyle/getComputedStyle-text-decoration-color-expected.txt

    r145785 r251750  
    6262
    6363Valid value 'hsla(240, 100%, 50%, 0.5)':
    64 PASS e.style.webkitTextDecorationColor is 'rgba(0, 0, 255, 0.498039)'
     64FAIL e.style.webkitTextDecorationColor should be rgba(0, 0, 255, 0.498039). Was rgba(0, 0, 255, 0.501961).
    6565PASS e.style.getPropertyCSSValue('-webkit-text-decoration-color').toString() is '[object CSSPrimitiveValue]'
    66 PASS e.style.getPropertyCSSValue('-webkit-text-decoration-color').cssText is 'rgba(0, 0, 255, 0.498039)'
     66FAIL e.style.getPropertyCSSValue('-webkit-text-decoration-color').cssText should be rgba(0, 0, 255, 0.498039). Was rgba(0, 0, 255, 0.501961).
    6767PASS computedStyle.getPropertyCSSValue('-webkit-text-decoration-color').toString() is '[object CSSPrimitiveValue]'
    68 PASS computedStyle.getPropertyCSSValue('-webkit-text-decoration-color').cssText is 'rgba(0, 0, 255, 0.498039)'
    69 PASS computedStyle.webkitTextDecorationColor is 'rgba(0, 0, 255, 0.498039)'
     68FAIL computedStyle.getPropertyCSSValue('-webkit-text-decoration-color').cssText should be rgba(0, 0, 255, 0.498039). Was rgba(0, 0, 255, 0.501961).
     69FAIL computedStyle.webkitTextDecorationColor should be rgba(0, 0, 255, 0.498039). Was rgba(0, 0, 255, 0.501961).
    7070
    7171Initial value:

  • trunk/LayoutTests/imported/w3c/ChangeLog

    r251739 r251750  
     12019-10-29  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Align CSS hsl() -> rgb() color conversion with the spec
     4        https://bugs.webkit.org/show_bug.cgi?id=203592
     5
     6        Reviewed by Tim Horton.
     7       
     8        Fix lots of tests in css/css-color/color-resolving-hsl.html by matching the specified rounding
     9        when converting between hsl() and rgb().
     10       
     11        Remove some duplicated code, and call HSLToSRGB().
     12
     13        * web-platform-tests/css/css-color/color-resolving-expected.txt:
     14        * web-platform-tests/css/css-color/color-resolving-hsl-expected.txt:
     15        * web-platform-tests/css/css-color/parsing/color-computed-expected.txt:
     16        * web-platform-tests/css/css-color/parsing/color-valid-expected.txt:
     17
    1182019-10-29  Simon Fraser  <simon.fraser@apple.com>
    219

  • trunk/LayoutTests/imported/w3c/web-platform-tests/css/css-color/color-resolving-expected.txt

    r239574 r251750  
    104104PASS Angles are represented as a part of a circle and wrap around: hsl(780, 100%, 37.5%)
    105105PASS Angles are represented as a part of a circle and wrap around: hsl(-300, 100%, 37.5%)
    106 FAIL Valid numbers should be parsed: hsl(300, 50%, 50%) assert_equals: expected "rgb(191, 64, 191)" but got "rgb(191, 63, 191)"
     106PASS Valid numbers should be parsed: hsl(300, 50%, 50%)
    107107PASS Angles are accepted in HSL/HSLA: hsl(30deg, 100%, 100%)
    108108PASS HSL and HSLA are synonyms: hsl(0, 0%, 0%, 0%)
    … …  
    119119PASS Angles are represented as a part of a circle and wrap around: hsla(-300, 100%, 37.5%, 0)
    120120PASS Invalid alpha values should be clamped to 0 and 1 respectively: hsla(-300, 100%, 37.5%, -3)
    121 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)"
     121FAIL 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)"
    122122PASS Angles are accepted in HSL/HSLA: hsla(30deg, 100%, 100%, 1)
    123123PASS The second and third parameters of hsl/hsla must be a percent: hsla(10, 50%, 0, 1)

  • trunk/LayoutTests/imported/w3c/web-platform-tests/css/css-color/color-resolving-hsl-expected.txt

    r232903 r251750  
    44PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 0%, 0.2)
    55PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 0%, 1)
    6 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)"
    7 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)"
    8 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)"
    9 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)"
    10 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)"
    11 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)"
    12 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)"
    13 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)"
    14 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)"
    15 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)"
    16 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)"
    17 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)"
    18 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)"
    19 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)"
    20 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)"
    21 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)"
     6PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 12.5%)
     7PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 12.5%, 0)
     8PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 12.5%, 0.2)
     9PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 12.5%, 1)
     10PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 25%)
     11PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 25%, 0)
     12PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 25%, 0.2)
     13PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 25%, 1)
     14PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 37.5%)
     15PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 37.5%, 0)
     16PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 37.5%, 0.2)
     17PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 37.5%, 1)
     18PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 50%)
     19PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 50%, 0)
     20PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 50%, 0.2)
     21PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 50%, 1)
    2222PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 62.5%)
    2323PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 62.5%, 0)
    … …  
    4040PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 0%, 0.2)
    4141PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 0%, 1)
    42 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)"
    43 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)"
    44 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)"
    45 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)"
    46 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)"
    47 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)"
    48 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)"
    49 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)"
    50 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)"
    51 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)"
    52 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)"
    53 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)"
    54 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)"
    55 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)"
    56 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)"
    57 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)"
     42PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 12.5%)
     43PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 12.5%, 0)
     44PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 12.5%, 0.2)
     45PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 12.5%, 1)
     46PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 25%)
     47PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 25%, 0)
     48PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 25%, 0.2)
     49PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 25%, 1)
     50PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 37.5%)
     51PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 37.5%, 0)
     52PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 37.5%, 0.2)
     53PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 37.5%, 1)
     54PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 50%)
     55PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 50%, 0)
     56PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 50%, 0.2)
     57PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 50%, 1)
    5858PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 62.5%)
    5959PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 62.5%, 0)
    … …  
    7676PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 0%, 0.2)
    7777PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 0%, 1)
    78 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)"
    79 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)"
    80 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)"
    81 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)"
    82 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)"
    83 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)"
    84 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)"
    85 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)"
    86 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)"
    87 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)"
    88 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)"
    89 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)"
    90 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)"
    91 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)"
    92 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)"
    93 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)"
     78PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 12.5%)
     79PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 12.5%, 0)
     80PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 12.5%, 0.2)
     81PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 12.5%, 1)
     82PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 25%)
     83PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 25%, 0)
     84PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 25%, 0.2)
     85PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 25%, 1)
     86PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 37.5%)
     87PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 37.5%, 0)
     88PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 37.5%, 0.2)
     89PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 37.5%, 1)
     90PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 50%)
     91PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 50%, 0)
     92PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 50%, 0.2)
     93PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 50%, 1)
    9494PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 62.5%)
    9595PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 62.5%, 0)
    … …  
    112112PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 0%, 0.2)
    113113PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 0%, 1)
    114 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)"
    115 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)"
    116 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)"
    117 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)"
    118 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)"
    119 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)"
    120 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)"
    121 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)"
    122 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)"
    123 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)"
    124 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)"
    125 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)"
    126 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)"
    127 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)"
    128 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)"
    129 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)"
    130 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)"
    131 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)"
    132 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)"
    133 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)"
     114PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 12.5%)
     115PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 12.5%, 0)
     116PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 12.5%, 0.2)
     117PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 12.5%, 1)
     118PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 25%)
     119PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 25%, 0)
     120PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 25%, 0.2)
     121PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 25%, 1)
     122PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 37.5%)
     123PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 37.5%, 0)
     124PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 37.5%, 0.2)
     125PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 37.5%, 1)
     126PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 50%)
     127PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 50%, 0)
     128PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 50%, 0.2)
     129PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 50%, 1)
     130PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 62.5%)
     131PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 62.5%, 0)
     132PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 62.5%, 0.2)
     133PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 62.5%, 1)
    134134PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 75%)
    135135PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 75%, 0)
    … …  
    148148PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 0%, 0.2)
    149149PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 0%, 1)
    150 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)"
    151 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)"
    152 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)"
    153 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)"
    154 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)"
    155 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)"
    156 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)"
    157 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)"
    158 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)"
    159 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)"
    160 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)"
    161 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)"
    162 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)"
    163 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)"
    164 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)"
    165 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)"
    166 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)"
    167 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)"
    168 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)"
    169 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)"
     150PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 12.5%)
     151PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 12.5%, 0)
     152PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 12.5%, 0.2)
     153PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 12.5%, 1)
     154PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 25%)
     155PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 25%, 0)
     156PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 25%, 0.2)
     157PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 25%, 1)
     158PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 37.5%)
     159PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 37.5%, 0)
     160PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 37.5%, 0.2)
     161PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 37.5%, 1)
     162PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 50%)
     163PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 50%, 0)
     164PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 50%, 0.2)
     165PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 50%, 1)
     166PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 62.5%)
     167PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 62.5%, 0)
     168PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 62.5%, 0.2)
     169PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 62.5%, 1)
    170170PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 75%)
    171171PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 75%, 0)
    … …  
    184184PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 0%, 0.2)
    185185PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 0%, 1)
    186 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)"
    187 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)"
    188 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)"
    189 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)"
    190 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)"
    191 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)"
    192 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)"
    193 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)"
    194 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)"
    195 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)"
    196 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)"
    197 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)"
    198 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)"
    199 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)"
    200 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)"
    201 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)"
    202 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)"
    203 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)"
    204 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)"
    205 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)"
     186PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 12.5%)
     187PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 12.5%, 0)
     188PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 12.5%, 0.2)
     189PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 12.5%, 1)
     190PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 25%)
     191PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 25%, 0)
     192PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 25%, 0.2)
     193PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 25%, 1)
     194PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 37.5%)
     195PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 37.5%, 0)
     196PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 37.5%, 0.2)
     197PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 37.5%, 1)
     198PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 50%)
     199PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 50%, 0)
     200PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 50%, 0.2)
     201PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 50%, 1)
     202PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 62.5%)
     203PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 62.5%, 0)
     204PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 62.5%, 0.2)
     205PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 62.5%, 1)
    206206PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 75%)
    207207PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 75%, 0)
    … …  
    220220PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 0%, 0.2)
    221221PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 0%, 1)
    222 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)"
    223 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)"
    224 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)"
    225 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)"
    226 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)"
    227 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)"
    228 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)"
    229 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)"
    230 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)"
    231 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)"
    232 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)"
    233 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)"
    234 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)"
    235 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)"
    236 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)"
    237 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)"
    238 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)"
    239 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)"
    240 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)"
    241 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)"
     222PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 12.5%)
     223PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 12.5%, 0)
     224PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 12.5%, 0.2)
     225PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 12.5%, 1)
     226PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 25%)
     227PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 25%, 0)
     228PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 25%, 0.2)
     229PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 25%, 1)
     230PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 37.5%)
     231PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 37.5%, 0)
     232PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 37.5%, 0.2)
     233PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 37.5%, 1)
     234PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 50%)
     235PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 50%, 0)
     236PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 50%, 0.2)
     237PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 50%, 1)
     238PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 62.5%)
     239PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 62.5%, 0)
     240PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 62.5%, 0.2)
     241PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 62.5%, 1)
    242242PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 75%)
    243243PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 75%, 0)
    … …  
    256256PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 0%, 0.2)
    257257PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 0%, 1)
    258 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)"
    259 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)"
    260 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)"
    261 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)"
    262 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)"
    263 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)"
    264 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)"
    265 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)"
    266 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)"
    267 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)"
    268 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)"
    269 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)"
    270 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)"
    271 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)"
    272 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)"
    273 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)"
    274 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)"
    275 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)"
    276 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)"
    277 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)"
     258PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 12.5%)
     259PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 12.5%, 0)
     260PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 12.5%, 0.2)
     261PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 12.5%, 1)
     262PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 25%)
     263PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 25%, 0)
     264PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 25%, 0.2)
     265PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 25%, 1)
     266PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 37.5%)
     267PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 37.5%, 0)
     268PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 37.5%, 0.2)
     269PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 37.5%, 1)
     270PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 50%)
     271PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 50%, 0)
     272PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 50%, 0.2)
     273PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 50%, 1)
     274PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 62.5%)
     275PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 62.5%, 0)
     276PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 62.5%, 0.2)
     277PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 62.5%, 1)
    278278PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 75%)
    279279PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 75%, 0)
    … …  
    292292PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 0%, 0.2)
    293293PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 0%, 1)
    294 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)"
    295 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)"
    296 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)"
    297 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)"
    298 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)"
    299 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)"
    300 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)"
    301 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)"
     294PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 12.5%)
     295PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 12.5%, 0)
     296PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 12.5%, 0.2)
     297PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 12.5%, 1)
     298PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 25%)
     299PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 25%, 0)
     300PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 25%, 0.2)
     301PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 25%, 1)
    302302PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 37.5%)
    303303PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 37.5%, 0)
    … …  
    308308PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 50%, 0.2)
    309309PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 50%, 1)
    310 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)"
    311 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)"
    312 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)"
    313 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)"
    314 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)"
    315 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)"
    316 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)"
    317 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)"
     310PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 62.5%)
     311PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 62.5%, 0)
     312PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 62.5%, 0.2)
     313PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 62.5%, 1)
     314PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 75%)
     315PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 75%, 0)
     316PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 75%, 0.2)
     317PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 75%, 1)
    318318PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 87.5%)
    319319PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 87.5%, 0)
    … …  
    328328PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 0%, 0.2)
    329329PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 0%, 1)
    330 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)"
    331 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)"
    332 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)"
    333 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)"
    334 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)"
    335 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)"
    336 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)"
    337 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)"
    338 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)"
    339 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)"
    340 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)"
    341 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)"
    342 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)"
    343 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)"
    344 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)"
    345 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)"
     330PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 12.5%)
     331PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 12.5%, 0)
     332PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 12.5%, 0.2)
     333PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 12.5%, 1)
     334PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 25%)
     335PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 25%, 0)
     336PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 25%, 0.2)
     337PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 25%, 1)
     338PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 37.5%)
     339PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 37.5%, 0)
     340PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 37.5%, 0.2)
     341PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 37.5%, 1)
     342PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 50%)
     343PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 50%, 0)
     344PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 50%, 0.2)
     345PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 50%, 1)
    346346PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 62.5%)
    347347PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 62.5%, 0)
    … …  
    364364PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 0%, 0.2)
    365365PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 0%, 1)
    366 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)"
    367 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)"
    368 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)"
    369 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)"
    370 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)"
    371 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)"
    372 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)"
    373 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)"
    374 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)"
    375 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)"
    376 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)"
    377 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)"
    378 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)"
    379 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)"
    380 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)"
    381 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)"
     366PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 12.5%)
     367PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 12.5%, 0)
     368PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 12.5%, 0.2)
     369PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 12.5%, 1)
     370PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 25%)
     371PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 25%, 0)
     372PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 25%, 0.2)
     373PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 25%, 1)
     374PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 37.5%)
     375PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 37.5%, 0)
     376PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 37.5%, 0.2)
     377PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 37.5%, 1)
     378PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 50%)
     379PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 50%, 0)
     380PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 50%, 0.2)
     381PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 50%, 1)
    382382PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 62.5%)
    383383PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 62.5%, 0)
    … …  
    400400PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 0%, 0.2)
    401401PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 0%, 1)
    402 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)"
    403 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)"
    404 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)"
    405 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)"
    406 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)"
    407 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)"
    408 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)"
    409 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)"
    410 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)"
    411 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)"
    412 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)"
    413 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)"
    414 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)"
    415 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)"
    416 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)"
    417 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)"
     402PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 12.5%)
     403PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 12.5%, 0)
     404PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 12.5%, 0.2)
     405PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 12.5%, 1)
     406PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 25%)
     407PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 25%, 0)
     408PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 25%, 0.2)
     409PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 25%, 1)
     410PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 37.5%)
     411PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 37.5%, 0)
     412PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 37.5%, 0.2)
     413PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 37.5%, 1)
     414PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 50%)
     415PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 50%, 0)
     416PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 50%, 0.2)
     417PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 50%, 1)
    418418PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 62.5%)
    419419PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 62.5%, 0)
    … …  
    436436PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 0%, 0.2)
    437437PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 0%, 1)
    438 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)"
    439 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)"
    440 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)"
    441 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)"
    442 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)"
    443 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)"
    444 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)"
    445 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)"
    446 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)"
    447 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)"
    448 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)"
    449 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)"
    450 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)"
    451 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)"
    452 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)"
    453 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)"
    454 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)"
    455 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)"
    456 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)"
    457 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)"
     438PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 12.5%)
     439PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 12.5%, 0)
     440PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 12.5%, 0.2)
     441PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 12.5%, 1)
     442PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 25%)
     443PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 25%, 0)
     444PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 25%, 0.2)
     445PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 25%, 1)
     446PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 37.5%)
     447PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 37.5%, 0)
     448PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 37.5%, 0.2)
     449PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 37.5%, 1)
     450PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 50%)
     451PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 50%, 0)
     452PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 50%, 0.2)
     453PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 50%, 1)
     454PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 62.5%)
     455PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 62.5%, 0)
     456PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 62.5%, 0.2)
     457PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 62.5%, 1)
    458458PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 75%)
    459459PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 75%, 0)
    … …  
    472472PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 0%, 0.2)
    473473PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 0%, 1)
    474 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)"
    475 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)"
    476 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)"
    477 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)"
    478 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)"
    479 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)"
    480 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)"
    481 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)"
    482 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)"
    483 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)"
    484 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)"
    485 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)"
    486 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)"
    487 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)"
    488 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)"
    489 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)"
    490 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)"
    491 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)"
    492 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)"
    493 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)"
     474PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 12.5%)
     475PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 12.5%, 0)
     476PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 12.5%, 0.2)
     477PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 12.5%, 1)
     478PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 25%)
     479PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 25%, 0)
     480PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 25%, 0.2)
     481PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 25%, 1)
     482PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 37.5%)
     483PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 37.5%, 0)
     484PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 37.5%, 0.2)
     485PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 37.5%, 1)
     486PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 50%)
     487PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 50%, 0)
     488PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 50%, 0.2)
     489PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 50%, 1)
     490PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 62.5%)
     491PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 62.5%, 0)
     492PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 62.5%, 0.2)
     493PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 62.5%, 1)
    494494PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 75%)
    495495PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 75%, 0)
    … …  
    508508PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 0%, 0.2)
    509509PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 0%, 1)
    510 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)"
    511 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)"
    512 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)"
    513 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)"
    514 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)"
    515 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)"
    516 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)"
    517 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)"
    518 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)"
    519 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)"
    520 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)"
    521 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)"
    522 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)"
    523 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)"
    524 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)"
    525 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)"
    526 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)"
    527 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)"
    528 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)"
    529 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)"
     510PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 12.5%)
     511PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 12.5%, 0)
     512PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 12.5%, 0.2)
     513PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 12.5%, 1)
     514PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 25%)
     515PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 25%, 0)
     516PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 25%, 0.2)
     517PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 25%, 1)
     518PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 37.5%)
     519PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 37.5%, 0)
     520PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 37.5%, 0.2)
     521PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 37.5%, 1)
     522PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 50%)
     523PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 50%, 0)
     524PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 50%, 0.2)
     525PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 50%, 1)
     526PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 62.5%)
     527PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 62.5%, 0)
     528PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 62.5%, 0.2)
     529PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 62.5%, 1)
    530530PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 75%)
    531531PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 75%, 0)
    … …  
    544544PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 0%, 0.2)
    545545PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 0%, 1)
    546 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)"
    547 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)"
    548 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)"
    549 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)"
    550 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)"
    551 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)"
    552 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)"
    553 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)"
    554 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)"
    555 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)"
    556 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)"
    557 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)"
    558 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)"
    559 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)"
    560 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)"
    561 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)"
    562 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)"
    563 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)"
    564 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)"
    565 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)"
     546PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 12.5%)
     547PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 12.5%, 0)
     548PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 12.5%, 0.2)
     549PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 12.5%, 1)
     550PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 25%)
     551PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 25%, 0)
     552PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 25%, 0.2)
     553PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 25%, 1)
     554PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 37.5%)
     555PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 37.5%, 0)
     556PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 37.5%, 0.2)
     557PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 37.5%, 1)
     558PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 50%)
     559PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 50%, 0)
     560PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 50%, 0.2)
     561PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 50%, 1)
     562PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 62.5%)
     563PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 62.5%, 0)
     564PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 62.5%, 0.2)
     565PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 62.5%, 1)
    566566PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 75%)
    567567PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 75%, 0)
    … …  
    580580PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 0%, 0.2)
    581581PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 0%, 1)
    582 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)"
    583 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)"
    584 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)"
    585 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)"
    586 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)"
    587 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)"
    588 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)"
    589 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)"
    590 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)"
    591 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)"
    592 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)"
    593 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)"
    594 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)"
    595 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)"
    596 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)"
    597 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)"
    598 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)"
    599 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)"
    600 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)"
    601 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)"
     582PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 12.5%)
     583PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 12.5%, 0)
     584PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 12.5%, 0.2)
     585PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 12.5%, 1)
     586PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 25%)
     587PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 25%, 0)
     588PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 25%, 0.2)
     589PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 25%, 1)
     590PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 37.5%)
     591PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 37.5%, 0)
     592PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 37.5%, 0.2)
     593PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 37.5%, 1)
     594PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 50%)
     595PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 50%, 0)
     596PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 50%, 0.2)
     597PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 50%, 1)
     598PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 62.5%)
     599PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 62.5%, 0)
     600PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 62.5%, 0.2)
     601PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 62.5%, 1)
    602602PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 75%)
    603603PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 75%, 0)
    … …  
    616616PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 0%, 0.2)
    617617PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 0%, 1)
    618 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)"
    619 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)"
    620 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)"
    621 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)"
    622 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)"
    623 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)"
    624 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)"
    625 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)"
    626 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)"
    627 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)"
    628 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)"
    629 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)"
    630 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)"
    631 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)"
    632 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)"
    633 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)"
    634 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)"
    635 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)"
    636 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)"
    637 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)"
    638 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)"
    639 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)"
    640 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)"
    641 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)"
     618PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 12.5%)
     619PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 12.5%, 0)
     620PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 12.5%, 0.2)
     621PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 12.5%, 1)
     622PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 25%)
     623PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 25%, 0)
     624PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 25%, 0.2)
     625PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 25%, 1)
     626PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 37.5%)
     627PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 37.5%, 0)
     628PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 37.5%, 0.2)
     629PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 37.5%, 1)
     630PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 50%)
     631PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 50%, 0)
     632PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 50%, 0.2)
     633PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 50%, 1)
     634PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 62.5%)
     635PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 62.5%, 0)
     636PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 62.5%, 0.2)
     637PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 62.5%, 1)
     638PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 75%)
     639PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 75%, 0)
     640PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 75%, 0.2)
     641PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 75%, 1)
    642642PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 87.5%)
    643643PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 87.5%, 0)
    … …  
    652652PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 0%, 0.2)
    653653PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 0%, 1)
    654 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)"
    655 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)"
    656 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)"
    657 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)"
    658 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)"
    659 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)"
    660 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)"
    661 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)"
    662 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)"
    663 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)"
    664 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)"
    665 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)"
    666 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)"
    667 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)"
    668 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)"
    669 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)"
     654PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 12.5%)
     655PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 12.5%, 0)
     656PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 12.5%, 0.2)
     657PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 12.5%, 1)
     658PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 25%)
     659PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 25%, 0)
     660PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 25%, 0.2)
     661PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 25%, 1)
     662PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 37.5%)
     663PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 37.5%, 0)
     664PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 37.5%, 0.2)
     665PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 37.5%, 1)
     666PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 50%)
     667PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 50%, 0)
     668PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 50%, 0.2)
     669PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 50%, 1)
    670670PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 62.5%)
    671671PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 62.5%, 0)
    … …  
    688688PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 0%, 0.2)
    689689PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 0%, 1)
    690 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)"
    691 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)"
    692 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)"
    693 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)"
    694 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)"
    695 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)"
    696 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)"
    697 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)"
    698 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)"
    699 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)"
    700 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)"
    701 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)"
    702 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)"
    703 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)"
    704 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)"
    705 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)"
     690PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 12.5%)
     691PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 12.5%, 0)
     692PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 12.5%, 0.2)
     693PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 12.5%, 1)
     694PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 25%)
     695PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 25%, 0)
     696PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 25%, 0.2)
     697PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 25%, 1)
     698PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 37.5%)
     699PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 37.5%, 0)
     700PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 37.5%, 0.2)
     701PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 37.5%, 1)
     702PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 50%)
     703PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 50%, 0)
     704PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 50%, 0.2)
     705PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 50%, 1)
    706706PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 62.5%)
    707707PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 62.5%, 0)
    … …  
    724724PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 0%, 0.2)
    725725PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 0%, 1)
    726 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)"
    727 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)"
    728 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)"
    729 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)"
    730 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)"
    731 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)"
    732 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)"
    733 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)"
    734 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)"
    735 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)"
    736 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)"
    737 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)"
    738 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)"
    739 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)"
    740 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)"
    741 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)"
     726PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 12.5%)
     727PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 12.5%, 0)
     728PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 12.5%, 0.2)
     729PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 12.5%, 1)
     730PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 25%)
     731PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 25%, 0)
     732PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 25%, 0.2)
     733PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 25%, 1)
     734PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 37.5%)
     735PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 37.5%, 0)
     736PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 37.5%, 0.2)
     737PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 37.5%, 1)
     738PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 50%)
     739PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 50%, 0)
     740PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 50%, 0.2)
     741PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 50%, 1)
    742742PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 62.5%)
    743743PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 62.5%, 0)
    … …  
    760760PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 0%, 0.2)
    761761PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 0%, 1)
    762 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)"
    763 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)"
    764 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)"
    765 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)"
    766 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)"
    767 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)"
    768 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)"
    769 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)"
    770 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)"
    771 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)"
    772 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)"
    773 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)"
    774 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)"
    775 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)"
    776 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)"
    777 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)"
    778 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)"
    779 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)"
    780 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)"
    781 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)"
     762PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 12.5%)
     763PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 12.5%, 0)
     764PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 12.5%, 0.2)
     765PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 12.5%, 1)
     766PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 25%)
     767PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 25%, 0)
     768PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 25%, 0.2)
     769PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 25%, 1)
     770PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 37.5%)
     771PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 37.5%, 0)
     772PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 37.5%, 0.2)
     773PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 37.5%, 1)
     774PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 50%)
     775PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 50%, 0)
     776PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 50%, 0.2)
     777PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 50%, 1)
     778PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 62.5%)
     779PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 62.5%, 0)
     780PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 62.5%, 0.2)
     781PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 62.5%, 1)
    782782PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 75%)
    783783PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 75%, 0)
    … …  
    796796PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 0%, 0.2)
    797797PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 0%, 1)
    798 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)"
    799 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)"
    800 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)"
    801 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)"
    802 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)"
    803 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)"
    804 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)"
    805 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)"
    806 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)"
    807 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)"
    808 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)"
    809 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)"
    810 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)"
    811 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)"
    812 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)"
    813 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)"
    814 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)"
    815 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)"
    816 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)"
    817 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)"
     798PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 12.5%)
     799PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 12.5%, 0)
     800PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 12.5%, 0.2)
     801PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 12.5%, 1)
     802PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 25%)
     803PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 25%, 0)
     804PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 25%, 0.2)
     805PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 25%, 1)
     806PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 37.5%)
     807PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 37.5%, 0)
     808PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 37.5%, 0.2)
     809PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 37.5%, 1)
     810PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 50%)
     811PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 50%, 0)
     812PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 50%, 0.2)
     813PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 50%, 1)
     814PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 62.5%)
     815PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 62.5%, 0)
     816PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 62.5%, 0.2)
     817PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 62.5%, 1)
    818818PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 75%)
    819819PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 75%, 0)
    … …  
    832832PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 0%, 0.2)
    833833PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 0%, 1)
    834 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)"
    835 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)"
    836 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)"
    837 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)"
    838 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)"
    839 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)"
    840 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)"
    841 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)"
    842 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)"
    843 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)"
    844 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)"
    845 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)"
    846 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)"
    847 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)"
    848 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)"
    849 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)"
    850 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)"
    851 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)"
    852 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)"
    853 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)"
     834PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 12.5%)
     835PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 12.5%, 0)
     836PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 12.5%, 0.2)
     837PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 12.5%, 1)
     838PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 25%)
     839PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 25%, 0)
     840PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 25%, 0.2)
     841PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 25%, 1)
     842PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 37.5%)
     843PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 37.5%, 0)
     844PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 37.5%, 0.2)
     845PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 37.5%, 1)
     846PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 50%)
     847PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 50%, 0)
     848PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 50%, 0.2)
     849PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 50%, 1)
     850PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 62.5%)
     851PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 62.5%, 0)
     852PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 62.5%, 0.2)
     853PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 62.5%, 1)
    854854PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 75%)
    855855PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 75%, 0)
    … …  
    868868PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 0%, 0.2)
    869869PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 0%, 1)
    870 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)"
    871 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)"
    872 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)"
    873 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)"
    874 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)"
    875 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)"
    876 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)"
    877 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)"
    878 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)"
    879 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)"
    880 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)"
    881 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)"
    882 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)"
    883 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)"
    884 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)"
    885 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)"
    886 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)"
    887 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)"
    888 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)"
    889 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)"
     870PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 12.5%)
     871PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 12.5%, 0)
     872PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 12.5%, 0.2)
     873PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 12.5%, 1)
     874PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 25%)
     875PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 25%, 0)
     876PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 25%, 0.2)
     877PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 25%, 1)
     878PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 37.5%)
     879PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 37.5%, 0)
     880PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 37.5%, 0.2)
     881PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 37.5%, 1)
     882PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 50%)
     883PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 50%, 0)
     884PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 50%, 0.2)
     885PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 50%, 1)
     886PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 62.5%)
     887PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 62.5%, 0)
     888PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 62.5%, 0.2)
     889PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 62.5%, 1)
    890890PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 75%)
    891891PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 75%, 0)
    … …  
    904904PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 0%, 0.2)
    905905PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 0%, 1)
    906 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)"
    907 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)"
    908 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)"
    909 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)"
    910 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)"
    911 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)"
    912 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)"
    913 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)"
    914 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)"
    915 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)"
    916 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)"
    917 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)"
    918 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)"
    919 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)"
    920 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)"
    921 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)"
    922 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)"
    923 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)"
    924 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)"
    925 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)"
     906PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 12.5%)
     907PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 12.5%, 0)
     908PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 12.5%, 0.2)
     909PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 12.5%, 1)
     910PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 25%)
     911PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 25%, 0)
     912PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 25%, 0.2)
     913PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 25%, 1)
     914PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 37.5%)
     915PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 37.5%, 0)
     916PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 37.5%, 0.2)
     917PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 37.5%, 1)
     918PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 50%)
     919PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 50%, 0)
     920PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 50%, 0.2)
     921PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 50%, 1)
     922PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 62.5%)
     923PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 62.5%, 0)
     924PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 62.5%, 0.2)
     925PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 62.5%, 1)
    926926PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 75%)
    927927PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 75%, 0)
    … …  
    940940PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 0%, 0.2)
    941941PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 0%, 1)
    942 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)"
    943 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)"
    944 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)"
    945 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)"
    946 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)"
    947 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)"
    948 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)"
    949 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)"
     942PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 12.5%)
     943PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 12.5%, 0)
     944PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 12.5%, 0.2)
     945PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 12.5%, 1)
     946PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 25%)
     947PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 25%, 0)
     948PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 25%, 0.2)
     949PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 25%, 1)
    950950PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 37.5%)
    951951PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 37.5%, 0)
    … …  
    956956PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 50%, 0.2)
    957957PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 50%, 1)
    958 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)"
    959 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)"
    960 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)"
    961 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)"
    962 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)"
    963 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)"
    964 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)"
    965 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)"
     958PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 62.5%)
     959PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 62.5%, 0)
     960PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 62.5%, 0.2)
     961PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 62.5%, 1)
     962PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 75%)
     963PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 75%, 0)
     964PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 75%, 0.2)
     965PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 75%, 1)
    966966PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 87.5%)
    967967PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 87.5%, 0)
    … …  
    976976PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 0%, 0.2)
    977977PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 0%, 1)
    978 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)"
    979 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)"
    980 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)"
    981 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)"
    982 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)"
    983 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)"
    984 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)"
    985 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)"
    986 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)"
    987 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)"
    988 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)"
    989 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)"
    990 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)"
    991 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)"
    992 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)"
    993 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)"
     978PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 12.5%)
     979PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 12.5%, 0)
     980PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 12.5%, 0.2)
     981PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 12.5%, 1)
     982PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 25%)
     983PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 25%, 0)
     984PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 25%, 0.2)
     985PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 25%, 1)
     986PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 37.5%)
     987PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 37.5%, 0)
     988PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 37.5%, 0.2)
     989PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 37.5%, 1)
     990PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 50%)
     991PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 50%, 0)
     992PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 50%, 0.2)
     993PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 50%, 1)
    994994PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 62.5%)
    995995PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 62.5%, 0)
    … …  
    10121012PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 0%, 0.2)
    10131013PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 0%, 1)
    1014 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)"
    1015 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)"
    1016 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)"
    1017 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)"
    1018 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)"
    1019 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)"
    1020 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)"
    1021 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)"
    1022 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)"
    1023 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)"
    1024 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)"
    1025 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)"
    1026 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)"
    1027 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)"
    1028 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)"
    1029 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)"
     1014PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 12.5%)
     1015PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 12.5%, 0)
     1016PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 12.5%, 0.2)
     1017PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 12.5%, 1)
     1018PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 25%)
     1019PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 25%, 0)
     1020PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 25%, 0.2)
     1021PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 25%, 1)
     1022PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 37.5%)
     1023PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 37.5%, 0)
     1024PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 37.5%, 0.2)
     1025PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 37.5%, 1)
     1026PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 50%)
     1027PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 50%, 0)
     1028PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 50%, 0.2)
     1029PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 50%, 1)
    10301030PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 62.5%)
    10311031PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 62.5%, 0)
    … …  
    10481048PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 0%, 0.2)
    10491049PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 0%, 1)
    1050 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)"
    1051 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)"
    1052 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)"
    1053 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)"
    1054 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)"
    1055 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)"
    1056 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)"
    1057 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)"
    1058 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)"
    1059 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)"
    1060 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)"
    1061 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)"
    1062 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)"
    1063 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)"
    1064 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)"
    1065 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)"
     1050PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 12.5%)
     1051PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 12.5%, 0)
     1052PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 12.5%, 0.2)
     1053PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 12.5%, 1)
     1054PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 25%)
     1055PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 25%, 0)
     1056PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 25%, 0.2)
     1057PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 25%, 1)
     1058PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 37.5%)
     1059PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 37.5%, 0)
     1060PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 37.5%, 0.2)
     1061PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 37.5%, 1)
     1062PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 50%)
     1063PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 50%, 0)
     1064PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 50%, 0.2)
     1065PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 50%, 1)
    10661066PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 62.5%)
    10671067PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 62.5%, 0)
    … …  
    10841084PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 0%, 0.2)
    10851085PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 0%, 1)
    1086 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)"
    1087 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)"
    1088 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)"
    1089 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)"
    1090 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)"
    1091 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)"
    1092 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)"
    1093 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)"
    1094 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)"
    1095 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)"
    1096 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)"
    1097 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)"
    1098 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)"
    1099 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)"
    1100 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)"
    1101 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)"
    1102 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)"
    1103 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)"
    1104 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)"
    1105 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)"
     1086PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 12.5%)
     1087PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 12.5%, 0)
     1088PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 12.5%, 0.2)
     1089PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 12.5%, 1)
     1090PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 25%)
     1091PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 25%, 0)
     1092PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 25%, 0.2)
     1093PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 25%, 1)
     1094PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 37.5%)
     1095PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 37.5%, 0)
     1096PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 37.5%, 0.2)
     1097PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 37.5%, 1)
     1098PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 50%)
     1099PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 50%, 0)
     1100PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 50%, 0.2)
     1101PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 50%, 1)
     1102PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 62.5%)
     1103PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 62.5%, 0)
     1104PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 62.5%, 0.2)
     1105PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 62.5%, 1)
    11061106PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 75%)
    11071107PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 75%, 0)
    … …  
    11201120PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 0%, 0.2)
    11211121PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 0%, 1)
    1122 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)"
    1123 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)"
    1124 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)"
    1125 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)"
    1126 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)"
    1127 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)"
    1128 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)"
    1129 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)"
    1130 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)"
    1131 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)"
    1132 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)"
    1133 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)"
    1134 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)"
    1135 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)"
    1136 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)"
    1137 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)"
    1138 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)"
    1139 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)"
    1140 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)"
    1141 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)"
     1122PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 12.5%)
     1123PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 12.5%, 0)
     1124PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 12.5%, 0.2)
     1125PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 12.5%, 1)
     1126PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 25%)
     1127PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 25%, 0)
     1128PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 25%, 0.2)
     1129PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 25%, 1)
     1130PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 37.5%)
     1131PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 37.5%, 0)
     1132PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 37.5%, 0.2)
     1133PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 37.5%, 1)
     1134PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 50%)
     1135PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 50%, 0)
     1136PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 50%, 0.2)
     1137PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 50%, 1)
     1138PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 62.5%)
     1139PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 62.5%, 0)
     1140PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 62.5%, 0.2)
     1141PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 62.5%, 1)
    11421142PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 75%)
    11431143PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 75%, 0)
    … …  
    11561156PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 0%, 0.2)
    11571157PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 0%, 1)
    1158 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)"
    1159 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)"
    1160 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)"
    1161 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)"
    1162 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)"
    1163 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)"
    1164 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)"
    1165 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)"
    1166 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)"
    1167 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)"
    1168 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)"
    1169 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)"
    1170 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)"
    1171 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)"
    1172 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)"
    1173 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)"
    1174 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)"
    1175 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)"
    1176 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)"
    1177 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)"
     1158PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 12.5%)
     1159PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 12.5%, 0)
     1160PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 12.5%, 0.2)
     1161PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 12.5%, 1)
     1162PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 25%)
     1163PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 25%, 0)
     1164PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 25%, 0.2)
     1165PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 25%, 1)
     1166PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 37.5%)
     1167PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 37.5%, 0)
     1168PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 37.5%, 0.2)
     1169PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 37.5%, 1)
     1170PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 50%)
     1171PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 50%, 0)
     1172PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 50%, 0.2)
     1173PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 50%, 1)
     1174PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 62.5%)
     1175PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 62.5%, 0)
     1176PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 62.5%, 0.2)
     1177PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 62.5%, 1)
    11781178PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 75%)
    11791179PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 75%, 0)
    … …  
    11921192PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 0%, 0.2)
    11931193PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 0%, 1)
    1194 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)"
    1195 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)"
    1196 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)"
    1197 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)"
    1198 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)"
    1199 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)"
    1200 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)"
    1201 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)"
    1202 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)"
    1203 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)"
    1204 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)"
    1205 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)"
    1206 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)"
    1207 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)"
    1208 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)"
    1209 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)"
    1210 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)"
    1211 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)"
    1212 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)"
    1213 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)"
     1194PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 12.5%)
     1195PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 12.5%, 0)
     1196PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 12.5%, 0.2)
     1197PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 12.5%, 1)
     1198PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 25%)
     1199PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 25%, 0)
     1200PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 25%, 0.2)
     1201PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 25%, 1)
     1202PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 37.5%)
     1203PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 37.5%, 0)
     1204PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 37.5%, 0.2)
     1205PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 37.5%, 1)
     1206PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 50%)
     1207PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 50%, 0)
     1208PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 50%, 0.2)
     1209PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 50%, 1)
     1210PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 62.5%)
     1211PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 62.5%, 0)
     1212PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 62.5%, 0.2)
     1213PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 62.5%, 1)
    12141214PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 75%)
    12151215PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 75%, 0)
    … …  
    12281228PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 0%, 0.2)
    12291229PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 0%, 1)
    1230 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)"
    1231 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)"
    1232 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)"
    1233 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)"
    1234 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)"
    1235 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)"
    1236 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)"
    1237 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)"
    1238 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)"
    1239 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)"
    1240 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)"
    1241 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)"
    1242 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)"
    1243 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)"
    1244 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)"
    1245 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)"
    1246 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)"
    1247 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)"
    1248 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)"
    1249 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)"
     1230PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 12.5%)
     1231PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 12.5%, 0)
     1232PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 12.5%, 0.2)
     1233PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 12.5%, 1)
     1234PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 25%)
     1235PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 25%, 0)
     1236PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 25%, 0.2)
     1237PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 25%, 1)
     1238PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 37.5%)
     1239PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 37.5%, 0)
     1240PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 37.5%, 0.2)
     1241PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 37.5%, 1)
     1242PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 50%)
     1243PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 50%, 0)
     1244PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 50%, 0.2)
     1245PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 50%, 1)
     1246PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 62.5%)
     1247PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 62.5%, 0)
     1248PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 62.5%, 0.2)
     1249PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 62.5%, 1)
    12501250PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 75%)
    12511251PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 75%, 0)
    … …  
    12641264PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 0%, 0.2)
    12651265PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 0%, 1)
    1266 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)"
    1267 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)"
    1268 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)"
    1269 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)"
    1270 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)"
    1271 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)"
    1272 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)"
    1273 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)"
    1274 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)"
    1275 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)"
    1276 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)"
    1277 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)"
    1278 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)"
    1279 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)"
    1280 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)"
    1281 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)"
    1282 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)"
    1283 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)"
    1284 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)"
    1285 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)"
    1286 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)"
    1287 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)"
    1288 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)"
    1289 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)"
     1266PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 12.5%)
     1267PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 12.5%, 0)
     1268PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 12.5%, 0.2)
     1269PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 12.5%, 1)
     1270PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 25%)
     1271PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 25%, 0)
     1272PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 25%, 0.2)
     1273PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 25%, 1)
     1274PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 37.5%)
     1275PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 37.5%, 0)
     1276PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 37.5%, 0.2)
     1277PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 37.5%, 1)
     1278PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 50%)
     1279PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 50%, 0)
     1280PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 50%, 0.2)
     1281PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 50%, 1)
     1282PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 62.5%)
     1283PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 62.5%, 0)
     1284PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 62.5%, 0.2)
     1285PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 62.5%, 1)
     1286PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 75%)
     1287PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 75%, 0)
     1288PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 75%, 0.2)
     1289PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 75%, 1)
    12901290PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 87.5%)
    12911291PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 87.5%, 0)
    … …  
    13001300PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 0%, 0.2)
    13011301PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 0%, 1)
    1302 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)"
    1303 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)"
    1304 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)"
    1305 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)"
    1306 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)"
    1307 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)"
    1308 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)"
    1309 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)"
    1310 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)"
    1311 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)"
    1312 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)"
    1313 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)"
    1314 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)"
    1315 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)"
    1316 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)"
    1317 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)"
     1302PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 12.5%)
     1303PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 12.5%, 0)
     1304PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 12.5%, 0.2)
     1305PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 12.5%, 1)
     1306PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 25%)
     1307PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 25%, 0)
     1308PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 25%, 0.2)
     1309PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 25%, 1)
     1310PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 37.5%)
     1311PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 37.5%, 0)
     1312PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 37.5%, 0.2)
     1313PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 37.5%, 1)
     1314PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 50%)
     1315PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 50%, 0)
     1316PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 50%, 0.2)
     1317PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 50%, 1)
    13181318PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 62.5%)
    13191319PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 62.5%, 0)
    … …  
    13361336PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 0%, 0.2)
    13371337PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 0%, 1)
    1338 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)"
    1339 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)"
    1340 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)"
    1341 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)"
    1342 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)"
    1343 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)"
    1344 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)"
    1345 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)"
    1346 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)"
    1347 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)"
    1348 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)"
    1349 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)"
    1350 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)"
    1351 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)"
    1352 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)"
    1353 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)"
     1338PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 12.5%)
     1339PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 12.5%, 0)
     1340PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 12.5%, 0.2)
     1341PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 12.5%, 1)
     1342PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 25%)
     1343PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 25%, 0)
     1344PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 25%, 0.2)
     1345PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 25%, 1)
     1346PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 37.5%)
     1347PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 37.5%, 0)
     1348PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 37.5%, 0.2)
     1349PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 37.5%, 1)
     1350PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 50%)
     1351PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 50%, 0)
     1352PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 50%, 0.2)
     1353PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 50%, 1)
    13541354PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 62.5%)
    13551355PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 62.5%, 0)
    … …  
    13721372PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 0%, 0.2)
    13731373PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 0%, 1)
    1374 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)"
    1375 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)"
    1376 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)"
    1377 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)"
    1378 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)"
    1379 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)"
    1380 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)"
    1381 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)"
    1382 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)"
    1383 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)"
    1384 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)"
    1385 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)"
    1386 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)"
    1387 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)"
    1388 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)"
    1389 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)"
     1374PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 12.5%)
     1375PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 12.5%, 0)
     1376PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 12.5%, 0.2)
     1377PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 12.5%, 1)
     1378PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 25%)
     1379PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 25%, 0)
     1380PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 25%, 0.2)
     1381PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 25%, 1)
     1382PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 37.5%)
     1383PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 37.5%, 0)
     1384PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 37.5%, 0.2)
     1385PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 37.5%, 1)
     1386PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 50%)
     1387PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 50%, 0)
     1388PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 50%, 0.2)
     1389PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 50%, 1)
    13901390PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 62.5%)
    13911391PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 62.5%, 0)
    … …  
    14081408PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 0%, 0.2)
    14091409PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 0%, 1)
    1410 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)"
    1411 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)"
    1412 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)"
    1413 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)"
    1414 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)"
    1415 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)"
    1416 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)"
    1417 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)"
    1418 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)"
    1419 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)"
    1420 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)"
    1421 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)"
    1422 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)"
    1423 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)"
    1424 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)"
    1425 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)"
    1426 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)"
    1427 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)"
    1428 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)"
    1429 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)"
     1410PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 12.5%)
     1411PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 12.5%, 0)
     1412PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 12.5%, 0.2)
     1413PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 12.5%, 1)
     1414PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 25%)
     1415PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 25%, 0)
     1416PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 25%, 0.2)
     1417PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 25%, 1)
     1418PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 37.5%)
     1419PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 37.5%, 0)
     1420PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 37.5%, 0.2)
     1421PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 37.5%, 1)
     1422PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 50%)
     1423PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 50%, 0)
     1424PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 50%, 0.2)
     1425PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 50%, 1)
     1426PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 62.5%)
     1427PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 62.5%, 0)
     1428PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 62.5%, 0.2)
     1429PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 62.5%, 1)
    14301430PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 75%)
    14311431PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 75%, 0)
    … …  
    14441444PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 0%, 0.2)
    14451445PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 0%, 1)
    1446 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)"
    1447 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)"
    1448 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)"
    1449 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)"
    1450 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)"
    1451 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)"
    1452 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)"
    1453 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)"
    1454 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)"
    1455 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)"
    1456 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)"
    1457 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)"
    1458 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)"
    1459 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)"
    1460 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)"
    1461 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)"
    1462 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)"
    1463 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)"
    1464 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)"
    1465 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)"
     1446PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 12.5%)
     1447PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 12.5%, 0)
     1448PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 12.5%, 0.2)
     1449PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 12.5%, 1)
     1450PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 25%)
     1451PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 25%, 0)
     1452PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 25%, 0.2)
     1453PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 25%, 1)
     1454PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 37.5%)
     1455PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 37.5%, 0)
     1456PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 37.5%, 0.2)
     1457PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 37.5%, 1)
     1458PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 50%)
     1459PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 50%, 0)
     1460PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 50%, 0.2)
     1461PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 50%, 1)
     1462PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 62.5%)
     1463PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 62.5%, 0)
     1464PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 62.5%, 0.2)
     1465PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 62.5%, 1)
    14661466PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 75%)
    14671467PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 75%, 0)
    … …  
    14801480PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 0%, 0.2)
    14811481PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 0%, 1)
    1482 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)"
    1483 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)"
    1484 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)"
    1485 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)"
    1486 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)"
    1487 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)"
    1488 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)"
    1489 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)"
    1490 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)"
    1491 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)"
    1492 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)"
    1493 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)"
    1494 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)"
    1495 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)"
    1496 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)"
    1497 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)"
    1498 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)"
    1499 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)"
    1500 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)"
    1501 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)"
     1482PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 12.5%)
     1483PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 12.5%, 0)
     1484PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 12.5%, 0.2)
     1485PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 12.5%, 1)
     1486PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 25%)
     1487PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 25%, 0)
     1488PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 25%, 0.2)
     1489PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 25%, 1)
     1490PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 37.5%)
     1491PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 37.5%, 0)
     1492PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 37.5%, 0.2)
     1493PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 37.5%, 1)
     1494PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 50%)
     1495PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 50%, 0)
     1496PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 50%, 0.2)
     1497PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 50%, 1)
     1498PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 62.5%)
     1499PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 62.5%, 0)
     1500PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 62.5%, 0.2)
     1501PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 62.5%, 1)
    15021502PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 75%)
    15031503PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 75%, 0)
    … …  
    15161516PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 0%, 0.2)
    15171517PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 0%, 1)
    1518 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)"
    1519 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)"
    1520 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)"
    1521 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)"
    1522 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)"
    1523 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)"
    1524 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)"
    1525 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)"
    1526 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)"
    1527 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)"
    1528 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)"
    1529 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)"
    1530 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)"
    1531 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)"
    1532 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)"
    1533 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)"
    1534 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)"
    1535 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)"
    1536 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)"
    1537 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)"
     1518PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 12.5%)
     1519PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 12.5%, 0)
     1520PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 12.5%, 0.2)
     1521PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 12.5%, 1)
     1522PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 25%)
     1523PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 25%, 0)
     1524PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 25%, 0.2)
     1525PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 25%, 1)
     1526PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 37.5%)
     1527PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 37.5%, 0)
     1528PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 37.5%, 0.2)
     1529PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 37.5%, 1)
     1530PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 50%)
     1531PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 50%, 0)
     1532PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 50%, 0.2)
     1533PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 50%, 1)
     1534PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 62.5%)
     1535PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 62.5%, 0)
     1536PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 62.5%, 0.2)
     1537PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 62.5%, 1)
    15381538PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 75%)
    15391539PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 75%, 0)
    … …  
    15521552PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 0%, 0.2)
    15531553PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 0%, 1)
    1554 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)"
    1555 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)"
    1556 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)"
    1557 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)"
    1558 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)"
    1559 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)"
    1560 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)"
    1561 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)"
    1562 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)"
    1563 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)"
    1564 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)"
    1565 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)"
    1566 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)"
    1567 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)"
    1568 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)"
    1569 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)"
    1570 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)"
    1571 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)"
    1572 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)"
    1573 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)"
     1554PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 12.5%)
     1555PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 12.5%, 0)
     1556PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 12.5%, 0.2)
     1557PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 12.5%, 1)
     1558PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 25%)
     1559PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 25%, 0)
     1560PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 25%, 0.2)
     1561PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 25%, 1)
     1562PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 37.5%)
     1563PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 37.5%, 0)
     1564PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 37.5%, 0.2)
     1565PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 37.5%, 1)
     1566PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 50%)
     1567PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 50%, 0)
     1568PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 50%, 0.2)
     1569PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 50%, 1)
     1570PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 62.5%)
     1571PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 62.5%, 0)
     1572PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 62.5%, 0.2)
     1573PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 62.5%, 1)
    15741574PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 75%)
    15751575PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 75%, 0)
    … …  
    15881588PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 0%, 0.2)
    15891589PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 0%, 1)
    1590 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)"
    1591 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)"
    1592 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)"
    1593 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)"
    1594 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)"
    1595 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)"
    1596 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)"
    1597 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)"
     1590PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 12.5%)
     1591PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 12.5%, 0)
     1592PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 12.5%, 0.2)
     1593PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 12.5%, 1)
     1594PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 25%)
     1595PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 25%, 0)
     1596PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 25%, 0.2)
     1597PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 25%, 1)
    15981598PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 37.5%)
    15991599PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 37.5%, 0)
    … …  
    16041604PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 50%, 0.2)
    16051605PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 50%, 1)
    1606 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)"
    1607 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)"
    1608 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)"
    1609 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)"
    1610 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)"
    1611 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)"
    1612 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)"
    1613 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)"
     1606PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 62.5%)
     1607PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 62.5%, 0)
     1608PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 62.5%, 0.2)
     1609PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 62.5%, 1)
     1610PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 75%)
     1611PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 75%, 0)
     1612PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 75%, 0.2)
     1613PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 75%, 1)
    16141614PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 87.5%)
    16151615PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 87.5%, 0)
    … …  
    16241624PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 0%, 0.2)
    16251625PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 0%, 1)
    1626 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)"
    1627 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)"
    1628 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)"
    1629 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)"
    1630 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)"
    1631 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)"
    1632 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)"
    1633 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)"
    1634 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)"
    1635 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)"
    1636 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)"
    1637 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)"
    1638 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)"
    1639 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)"
    1640 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)"
    1641 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)"
     1626PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 12.5%)
     1627PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 12.5%, 0)
     1628PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 12.5%, 0.2)
     1629PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 12.5%, 1)
     1630PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 25%)
     1631PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 25%, 0)
     1632PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 25%, 0.2)
     1633PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 25%, 1)
     1634PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 37.5%)
     1635PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 37.5%, 0)
     1636PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 37.5%, 0.2)
     1637PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 37.5%, 1)
     1638PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 50%)
     1639PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 50%, 0)
     1640PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 50%, 0.2)
     1641PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 50%, 1)
    16421642PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 62.5%)
    16431643PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 62.5%, 0)
    … …  
    16601660PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 0%, 0.2)
    16611661PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 0%, 1)
    1662 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)"
    1663 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)"
    1664 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)"
    1665 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)"
    1666 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)"
    1667 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)"
    1668 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)"
    1669 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)"
    1670 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)"
    1671 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)"
    1672 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)"
    1673 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)"
    1674 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)"
    1675 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)"
    1676 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)"
    1677 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)"
     1662PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 12.5%)
     1663PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 12.5%, 0)
     1664PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 12.5%, 0.2)
     1665PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 12.5%, 1)
     1666PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 25%)
     1667PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 25%, 0)
     1668PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 25%, 0.2)
     1669PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 25%, 1)
     1670PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 37.5%)
     1671PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 37.5%, 0)
     1672PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 37.5%, 0.2)
     1673PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 37.5%, 1)
     1674PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 50%)
     1675PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 50%, 0)
     1676PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 50%, 0.2)
     1677PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 50%, 1)
    16781678PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 62.5%)
    16791679PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 62.5%, 0)
    … …  
    16961696PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 0%, 0.2)
    16971697PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 0%, 1)
    1698 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)"
    1699 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)"
    1700 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)"
    1701 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)"
    1702 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)"
    1703 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)"
    1704 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)"
    1705 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)"
    1706 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)"
    1707 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)"
    1708 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)"
    1709 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)"
    1710 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)"
    1711 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)"
    1712 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)"
    1713 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)"
     1698PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 12.5%)
     1699PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 12.5%, 0)
     1700PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 12.5%, 0.2)
     1701PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 12.5%, 1)
     1702PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 25%)
     1703PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 25%, 0)
     1704PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 25%, 0.2)
     1705PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 25%, 1)
     1706PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 37.5%)
     1707PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 37.5%, 0)
     1708PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 37.5%, 0.2)
     1709PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 37.5%, 1)
     1710PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 50%)
     1711PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 50%, 0)
     1712PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 50%, 0.2)
     1713PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 50%, 1)
    17141714PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 62.5%)
    17151715PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 62.5%, 0)
    … …  
    17321732PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 0%, 0.2)
    17331733PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 0%, 1)
    1734 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)"
    1735 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)"
    1736 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)"
    1737 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)"
    1738 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)"
    1739 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)"
    1740 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)"
    1741 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)"
    1742 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)"
    1743 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)"
    1744 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)"
    1745 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)"
    1746 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)"
    1747 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)"
    1748 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)"
    1749 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)"
    1750 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)"
    1751 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)"
    1752 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)"
    1753 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)"
     1734PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 12.5%)
     1735PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 12.5%, 0)
     1736PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 12.5%, 0.2)
     1737PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 12.5%, 1)
     1738PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 25%)
     1739PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 25%, 0)
     1740PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 25%, 0.2)
     1741PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 25%, 1)
     1742PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 37.5%)
     1743PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 37.5%, 0)
     1744PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 37.5%, 0.2)
     1745PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 37.5%, 1)
     1746PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 50%)
     1747PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 50%, 0)
     1748PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 50%, 0.2)
     1749PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 50%, 1)
     1750PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 62.5%)
     1751PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 62.5%, 0)
     1752PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 62.5%, 0.2)
     1753PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 62.5%, 1)
    17541754PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 75%)
    17551755PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 75%, 0)
    … …  
    17681768PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 0%, 0.2)
    17691769PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 0%, 1)
    1770 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)"
    1771 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)"
    1772 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)"
    1773 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)"
    1774 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)"
    1775 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)"
    1776 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)"
    1777 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)"
    1778 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)"
    1779 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)"
    1780 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)"
    1781 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)"
    1782 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)"
    1783 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)"
    1784 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)"
    1785 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)"
    1786 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)"
    1787 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)"
    1788 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)"
    1789 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)"
     1770PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 12.5%)
     1771PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 12.5%, 0)
     1772PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 12.5%, 0.2)
     1773PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 12.5%, 1)
     1774PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 25%)
     1775PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 25%, 0)
     1776PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 25%, 0.2)
     1777PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 25%, 1)
     1778PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 37.5%)
     1779PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 37.5%, 0)
     1780PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 37.5%, 0.2)
     1781PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 37.5%, 1)
     1782PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 50%)
     1783PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 50%, 0)
     1784PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 50%, 0.2)
     1785PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 50%, 1)
     1786PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 62.5%)
     1787PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 62.5%, 0)
     1788PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 62.5%, 0.2)
     1789PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 62.5%, 1)
    17901790PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 75%)
    17911791PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 75%, 0)
    … …  
    18041804PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 0%, 0.2)
    18051805PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 0%, 1)
    1806 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)"
    1807 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)"
    1808 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)"
    1809 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)"
    1810 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)"
    1811 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)"
    1812 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)"
    1813 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)"
    1814 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)"
    1815 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)"
    1816 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)"
    1817 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)"
    1818 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)"
    1819 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)"
    1820 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)"
    1821 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)"
    1822 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)"
    1823 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)"
    1824 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)"
    1825 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)"
     1806PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 12.5%)
     1807PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 12.5%, 0)
     1808PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 12.5%, 0.2)
     1809PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 12.5%, 1)
     1810PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 25%)
     1811PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 25%, 0)
     1812PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 25%, 0.2)
     1813PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 25%, 1)
     1814PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 37.5%)
     1815PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 37.5%, 0)
     1816PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 37.5%, 0.2)
     1817PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 37.5%, 1)
     1818PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 50%)
     1819PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 50%, 0)
     1820PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 50%, 0.2)
     1821PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 50%, 1)
     1822PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 62.5%)
     1823PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 62.5%, 0)
     1824PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 62.5%, 0.2)
     1825PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 62.5%, 1)
    18261826PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 75%)
    18271827PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 75%, 0)
    … …  
    18401840PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 0%, 0.2)
    18411841PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 0%, 1)
    1842 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)"
    1843 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)"
    1844 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)"
    1845 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)"
    1846 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)"
    1847 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)"
    1848 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)"
    1849 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)"
    1850 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)"
    1851 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)"
    1852 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)"
    1853 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)"
    1854 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)"
    1855 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)"
    1856 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)"
    1857 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)"
    1858 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)"
    1859 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)"
    1860 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)"
    1861 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)"
     1842PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 12.5%)
     1843PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 12.5%, 0)
     1844PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 12.5%, 0.2)
     1845PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 12.5%, 1)
     1846PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 25%)
     1847PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 25%, 0)
     1848PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 25%, 0.2)
     1849PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 25%, 1)
     1850PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 37.5%)
     1851PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 37.5%, 0)
     1852PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 37.5%, 0.2)
     1853PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 37.5%, 1)
     1854PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 50%)
     1855PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 50%, 0)
     1856PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 50%, 0.2)
     1857PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 50%, 1)
     1858PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 62.5%)
     1859PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 62.5%, 0)
     1860PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 62.5%, 0.2)
     1861PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 62.5%, 1)
    18621862PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 75%)
    18631863PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 75%, 0)
    … …  
    18761876PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 0%, 0.2)
    18771877PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 0%, 1)
    1878 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)"
    1879 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)"
    1880 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)"
    1881 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)"
    1882 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)"
    1883 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)"
    1884 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)"
    1885 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)"
    1886 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)"
    1887 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)"
    1888 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)"
    1889 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)"
    1890 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)"
    1891 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)"
    1892 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)"
    1893 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)"
    1894 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)"
    1895 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)"
    1896 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)"
    1897 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)"
     1878PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 12.5%)
     1879PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 12.5%, 0)
     1880PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 12.5%, 0.2)
     1881PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 12.5%, 1)
     1882PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 25%)
     1883PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 25%, 0)
     1884PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 25%, 0.2)
     1885PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 25%, 1)
     1886PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 37.5%)
     1887PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 37.5%, 0)
     1888PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 37.5%, 0.2)
     1889PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 37.5%, 1)
     1890PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 50%)
     1891PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 50%, 0)
     1892PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 50%, 0.2)
     1893PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 50%, 1)
     1894PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 62.5%)
     1895PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 62.5%, 0)
     1896PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 62.5%, 0.2)
     1897PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 62.5%, 1)
    18981898PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 75%)
    18991899PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 75%, 0)
    … …  
    19121912PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 0%, 0.2)
    19131913PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 0%, 1)
    1914 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)"
    1915 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)"
    1916 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)"
    1917 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)"
    1918 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)"
    1919 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)"
    1920 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)"
    1921 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)"
     1914PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 12.5%)
     1915PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 12.5%, 0)
     1916PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 12.5%, 0.2)
     1917PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 12.5%, 1)
     1918PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 25%)
     1919PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 25%, 0)
     1920PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 25%, 0.2)
     1921PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 25%, 1)
    19221922PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 37.5%)
    19231923PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 37.5%, 0)
    … …  
    19281928PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 50%, 0.2)
    19291929PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 50%, 1)
    1930 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)"
    1931 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)"
    1932 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)"
    1933 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)"
    1934 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)"
    1935 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)"
    1936 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)"
    1937 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)"
     1930PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 62.5%)
     1931PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 62.5%, 0)
     1932PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 62.5%, 0.2)
     1933PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 62.5%, 1)
     1934PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 75%)
     1935PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 75%, 0)
     1936PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 75%, 0.2)
     1937PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 75%, 1)
    19381938PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 87.5%)
    19391939PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 87.5%, 0)
    … …  
    19481948PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 0%, 0.2)
    19491949PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 0%, 1)
    1950 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)"
    1951 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)"
    1952 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)"
    1953 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)"
    1954 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)"
    1955 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)"
    1956 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)"
    1957 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)"
    1958 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)"
    1959 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)"
    1960 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)"
    1961 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)"
    1962 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)"
    1963 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)"
    1964 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)"
    1965 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)"
     1950PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 12.5%)
     1951PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 12.5%, 0)
     1952PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 12.5%, 0.2)
     1953PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 12.5%, 1)
     1954PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 25%)
     1955PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 25%, 0)
     1956PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 25%, 0.2)
     1957PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 25%, 1)
     1958PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 37.5%)
     1959PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 37.5%, 0)
     1960PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 37.5%, 0.2)
     1961PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 37.5%, 1)
     1962PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 50%)
     1963PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 50%, 0)
     1964PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 50%, 0.2)
     1965PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 50%, 1)
    19661966PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 62.5%)
    19671967PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 62.5%, 0)
    … …  
    19841984PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 0%, 0.2)
    19851985PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 0%, 1)
    1986 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)"
    1987 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)"
    1988 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)"
    1989 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)"
    1990 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)"
    1991 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)"
    1992 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)"
    1993 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)"
    1994 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)"
    1995 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)"
    1996 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)"
    1997 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)"
    1998 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)"
    1999 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)"
    2000 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)"
    2001 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)"
     1986PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 12.5%)
     1987PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 12.5%, 0)
     1988PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 12.5%, 0.2)
     1989PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 12.5%, 1)
     1990PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 25%)
     1991PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 25%, 0)
     1992PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 25%, 0.2)
     1993PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 25%, 1)
     1994PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 37.5%)
     1995PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 37.5%, 0)
     1996PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 37.5%, 0.2)
     1997PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 37.5%, 1)
     1998PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 50%)
     1999PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 50%, 0)
     2000PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 50%, 0.2)
     2001PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 50%, 1)
    20022002PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 62.5%)
    20032003PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 62.5%, 0)
    … …  
    20202020PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 0%, 0.2)
    20212021PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 0%, 1)
    2022 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)"
    2023 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)"
    2024 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)"
    2025 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)"
    2026 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)"
    2027 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)"
    2028 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)"
    2029 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)"
    2030 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)"
    2031 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)"
    2032 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)"
    2033 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)"
    2034 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)"
    2035 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)"
    2036 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)"
    2037 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)"
     2022PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 12.5%)
     2023PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 12.5%, 0)
     2024PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 12.5%, 0.2)
     2025PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 12.5%, 1)
     2026PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 25%)
     2027PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 25%, 0)
     2028PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 25%, 0.2)
     2029PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 25%, 1)
     2030PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 37.5%)
     2031PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 37.5%, 0)
     2032PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 37.5%, 0.2)
     2033PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 37.5%, 1)
     2034PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 50%)
     2035PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 50%, 0)
     2036PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 50%, 0.2)
     2037PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 50%, 1)
    20382038PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 62.5%)
    20392039PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 62.5%, 0)
    … …  
    20562056PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 0%, 0.2)
    20572057PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 0%, 1)
    2058 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)"
    2059 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)"
    2060 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)"
    2061 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)"
    2062 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)"
    2063 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)"
    2064 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)"
    2065 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)"
    2066 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)"
    2067 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)"
    2068 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)"
    2069 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)"
    2070 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)"
    2071 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)"
    2072 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)"
    2073 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)"
    2074 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)"
    2075 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)"
    2076 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)"
    2077 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)"
     2058PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 12.5%)
     2059PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 12.5%, 0)
     2060PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 12.5%, 0.2)
     2061PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 12.5%, 1)
     2062PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 25%)
     2063PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 25%, 0)
     2064PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 25%, 0.2)
     2065PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 25%, 1)
     2066PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 37.5%)
     2067PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 37.5%, 0)
     2068PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 37.5%, 0.2)
     2069PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 37.5%, 1)
     2070PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 50%)
     2071PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 50%, 0)
     2072PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 50%, 0.2)
     2073PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 50%, 1)
     2074PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 62.5%)
     2075PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 62.5%, 0)
     2076PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 62.5%, 0.2)
     2077PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 62.5%, 1)
    20782078PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 75%)
    20792079PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 75%, 0)
    … …  
    20922092PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 0%, 0.2)
    20932093PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 0%, 1)
    2094 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)"
    2095 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)"
    2096 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)"
    2097 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)"
    2098 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)"
    2099 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)"
    2100 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)"
    2101 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)"
    2102 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)"
    2103 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)"
    2104 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)"
    2105 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)"
    2106 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)"
    2107 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)"
    2108 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)"
    2109 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)"
    2110 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)"
    2111 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)"
    2112 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)"
    2113 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)"
     2094PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 12.5%)
     2095PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 12.5%, 0)
     2096PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 12.5%, 0.2)
     2097PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 12.5%, 1)
     2098PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 25%)
     2099PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 25%, 0)
     2100PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 25%, 0.2)
     2101PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 25%, 1)
     2102PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 37.5%)
     2103PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 37.5%, 0)
     2104PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 37.5%, 0.2)
     2105PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 37.5%, 1)
     2106PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 50%)
     2107PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 50%, 0)
     2108PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 50%, 0.2)
     2109PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 50%, 1)
     2110PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 62.5%)
     2111PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 62.5%, 0)
     2112PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 62.5%, 0.2)
     2113PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 62.5%, 1)
    21142114PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 75%)
    21152115PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 75%, 0)
    … …  
    21282128PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 0%, 0.2)
    21292129PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 0%, 1)
    2130 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)"
    2131 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)"
    2132 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)"
    2133 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)"
    2134 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)"
    2135 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)"
    2136 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)"
    2137 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)"
    2138 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)"
    2139 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)"
    2140 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)"
    2141 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)"
    2142 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)"
    2143 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)"
    2144 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)"
    2145 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)"
    2146 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)"
    2147 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)"
    2148 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)"
    2149 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)"
     2130PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 12.5%)
     2131PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 12.5%, 0)
     2132PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 12.5%, 0.2)
     2133PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 12.5%, 1)
     2134PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 25%)
     2135PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 25%, 0)
     2136PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 25%, 0.2)
     2137PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 25%, 1)
     2138PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 37.5%)
     2139PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 37.5%, 0)
     2140PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 37.5%, 0.2)
     2141PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 37.5%, 1)
     2142PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 50%)
     2143PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 50%, 0)
     2144PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 50%, 0.2)
     2145PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 50%, 1)
     2146PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 62.5%)
     2147PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 62.5%, 0)
     2148PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 62.5%, 0.2)
     2149PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 62.5%, 1)
    21502150PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 75%)
    21512151PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 75%, 0)
    … …  
    21642164PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 0%, 0.2)
    21652165PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 0%, 1)
    2166 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)"
    2167 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)"
    2168 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)"
    2169 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)"
    2170 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)"
    2171 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)"
    2172 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)"
    2173 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)"
    2174 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)"
    2175 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)"
    2176 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)"
    2177 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)"
    2178 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)"
    2179 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)"
    2180 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)"
    2181 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)"
    2182 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)"
    2183 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)"
    2184 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)"
    2185 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)"
     2166PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 12.5%)
     2167PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 12.5%, 0)
     2168PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 12.5%, 0.2)
     2169PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 12.5%, 1)
     2170PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 25%)
     2171PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 25%, 0)
     2172PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 25%, 0.2)
     2173PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 25%, 1)
     2174PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 37.5%)
     2175PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 37.5%, 0)
     2176PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 37.5%, 0.2)
     2177PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 37.5%, 1)
     2178PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 50%)
     2179PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 50%, 0)
     2180PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 50%, 0.2)
     2181PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 50%, 1)
     2182PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 62.5%)
     2183PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 62.5%, 0)
     2184PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 62.5%, 0.2)
     2185PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 62.5%, 1)
    21862186PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 75%)
    21872187PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 75%, 0)
    … …  
    22002200PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 0%, 0.2)
    22012201PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 0%, 1)
    2202 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)"
    2203 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)"
    2204 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)"
    2205 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)"
    2206 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)"
    2207 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)"
    2208 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)"
    2209 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)"
    2210 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)"
    2211 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)"
    2212 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)"
    2213 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)"
    2214 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)"
    2215 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)"
    2216 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)"
    2217 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)"
    2218 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)"
    2219 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)"
    2220 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)"
    2221 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)"
     2202PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 12.5%)
     2203PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 12.5%, 0)
     2204PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 12.5%, 0.2)
     2205PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 12.5%, 1)
     2206PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 25%)
     2207PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 25%, 0)
     2208PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 25%, 0.2)
     2209PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 25%, 1)
     2210PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 37.5%)
     2211PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 37.5%, 0)
     2212PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 37.5%, 0.2)
     2213PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 37.5%, 1)
     2214PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 50%)
     2215PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 50%, 0)
     2216PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 50%, 0.2)
     2217PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 50%, 1)
     2218PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 62.5%)
     2219PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 62.5%, 0)
     2220PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 62.5%, 0.2)
     2221PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 62.5%, 1)
    22222222PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 75%)
    22232223PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 75%, 0)
    … …  
    22362236PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 0%, 0.2)
    22372237PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 0%, 1)
    2238 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)"
    2239 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)"
    2240 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)"
    2241 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)"
    2242 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)"
    2243 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)"
    2244 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)"
    2245 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)"
    2246 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)"
    2247 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)"
    2248 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)"
    2249 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)"
    2250 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)"
    2251 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)"
    2252 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)"
    2253 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)"
    2254 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)"
    2255 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)"
    2256 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)"
    2257 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)"
    2258 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)"
    2259 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)"
    2260 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)"
    2261 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)"
     2238PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 12.5%)
     2239PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 12.5%, 0)
     2240PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 12.5%, 0.2)
     2241PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 12.5%, 1)
     2242PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 25%)
     2243PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 25%, 0)
     2244PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 25%, 0.2)
     2245PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 25%, 1)
     2246PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 37.5%)
     2247PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 37.5%, 0)
     2248PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 37.5%, 0.2)
     2249PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 37.5%, 1)
     2250PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 50%)
     2251PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 50%, 0)
     2252PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 50%, 0.2)
     2253PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 50%, 1)
     2254PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 62.5%)
     2255PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 62.5%, 0)
     2256PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 62.5%, 0.2)
     2257PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 62.5%, 1)
     2258PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 75%)
     2259PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 75%, 0)
     2260PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 75%, 0.2)
     2261PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 75%, 1)
    22622262PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 87.5%)
    22632263PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 87.5%, 0)
    … …  
    22722272PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 0%, 0.2)
    22732273PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 0%, 1)
    2274 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)"
    2275 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)"
    2276 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)"
    2277 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)"
    2278 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)"
    2279 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)"
    2280 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)"
    2281 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)"
    2282 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)"
    2283 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)"
    2284 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)"
    2285 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)"
    2286 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)"
    2287 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)"
    2288 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)"
    2289 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)"
     2274PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 12.5%)
     2275PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 12.5%, 0)
     2276PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 12.5%, 0.2)
     2277PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 12.5%, 1)
     2278PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 25%)
     2279PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 25%, 0)
     2280PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 25%, 0.2)
     2281PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 25%, 1)
     2282PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 37.5%)
     2283PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 37.5%, 0)
     2284PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 37.5%, 0.2)
     2285PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 37.5%, 1)
     2286PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 50%)
     2287PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 50%, 0)
     2288PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 50%, 0.2)
     2289PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 50%, 1)
    22902290PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 62.5%)
    22912291PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 62.5%, 0)
    … …  
    23082308PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 0%, 0.2)
    23092309PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 0%, 1)
    2310 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)"
    2311 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)"
    2312 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)"
    2313 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)"
    2314 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)"
    2315 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)"
    2316 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)"
    2317 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)"
    2318 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)"
    2319 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)"
    2320 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)"
    2321 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)"
    2322 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)"
    2323 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)"
    2324 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)"
    2325 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)"
     2310PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 12.5%)
     2311PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 12.5%, 0)
     2312PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 12.5%, 0.2)
     2313PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 12.5%, 1)
     2314PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 25%)
     2315PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 25%, 0)
     2316PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 25%, 0.2)
     2317PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 25%, 1)
     2318PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 37.5%)
     2319PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 37.5%, 0)
     2320PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 37.5%, 0.2)
     2321PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 37.5%, 1)
     2322PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 50%)
     2323PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 50%, 0)
     2324PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 50%, 0.2)
     2325PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 50%, 1)
    23262326PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 62.5%)
    23272327PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 62.5%, 0)
    … …  
    23442344PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 0%, 0.2)
    23452345PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 0%, 1)
    2346 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)"
    2347 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)"
    2348 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)"
    2349 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)"
    2350 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)"
    2351 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)"
    2352 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)"
    2353 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)"
    2354 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)"
    2355 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)"
    2356 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)"
    2357 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)"
    2358 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)"
    2359 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)"
    2360 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)"
    2361 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)"
     2346PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 12.5%)
     2347PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 12.5%, 0)
     2348PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 12.5%, 0.2)
     2349PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 12.5%, 1)
     2350PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 25%)
     2351PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 25%, 0)
     2352PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 25%, 0.2)
     2353PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 25%, 1)
     2354PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 37.5%)
     2355PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 37.5%, 0)
     2356PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 37.5%, 0.2)
     2357PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 37.5%, 1)
     2358PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 50%)
     2359PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 50%, 0)
     2360PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 50%, 0.2)
     2361PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 50%, 1)
    23622362PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 62.5%)
    23632363PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 62.5%, 0)
    … …  
    23802380PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 0%, 0.2)
    23812381PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 0%, 1)
    2382 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)"
    2383 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)"
    2384 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)"
    2385 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)"
    2386 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)"
    2387 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)"
    2388 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)"
    2389 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)"
    2390 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)"
    2391 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)"
    2392 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)"
    2393 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)"
    2394 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)"
    2395 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)"
    2396 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)"
    2397 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)"
    2398 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)"
    2399 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)"
    2400 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)"
    2401 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)"
     2382PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 12.5%)
     2383PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 12.5%, 0)
     2384PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 12.5%, 0.2)
     2385PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 12.5%, 1)
     2386PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 25%)
     2387PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 25%, 0)
     2388PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 25%, 0.2)
     2389PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 25%, 1)
     2390PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 37.5%)
     2391PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 37.5%, 0)
     2392PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 37.5%, 0.2)
     2393PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 37.5%, 1)
     2394PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 50%)
     2395PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 50%, 0)
     2396PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 50%, 0.2)
     2397PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 50%, 1)
     2398PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 62.5%)
     2399PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 62.5%, 0)
     2400PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 62.5%, 0.2)
     2401PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 62.5%, 1)
    24022402PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 75%)
    24032403PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 75%, 0)
    … …  
    24162416PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 0%, 0.2)
    24172417PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 0%, 1)
    2418 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)"
    2419 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)"
    2420 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)"
    2421 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)"
    2422 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)"
    2423 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)"
    2424 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)"
    2425 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)"
    2426 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)"
    2427 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)"
    2428 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)"
    2429 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)"
    2430 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)"
    2431 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)"
    2432 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)"
    2433 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)"
    2434 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)"
    2435 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)"
    2436 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)"
    2437 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)"
     2418PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 12.5%)
     2419PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 12.5%, 0)
     2420PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 12.5%, 0.2)
     2421PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 12.5%, 1)
     2422PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 25%)
     2423PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 25%, 0)
     2424PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 25%, 0.2)
     2425PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 25%, 1)
     2426PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 37.5%)
     2427PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 37.5%, 0)
     2428PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 37.5%, 0.2)
     2429PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 37.5%, 1)
     2430PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 50%)
     2431PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 50%, 0)
     2432PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 50%, 0.2)
     2433PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 50%, 1)
     2434PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 62.5%)
     2435PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 62.5%, 0)
     2436PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 62.5%, 0.2)
     2437PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 62.5%, 1)
    24382438PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 75%)
    24392439PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 75%, 0)
    … …  
    24522452PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 0%, 0.2)
    24532453PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 0%, 1)
    2454 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)"
    2455 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)"
    2456 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)"
    2457 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)"
    2458 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)"
    2459 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)"
    2460 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)"
    2461 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)"
    2462 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)"
    2463 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)"
    2464 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)"
    2465 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)"
    2466 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)"
    2467 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)"
    2468 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)"
    2469 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)"
    2470 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)"
    2471 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)"
    2472 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)"
    2473 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)"
     2454PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 12.5%)
     2455PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 12.5%, 0)
     2456PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 12.5%, 0.2)
     2457PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 12.5%, 1)
     2458PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 25%)
     2459PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 25%, 0)
     2460PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 25%, 0.2)
     2461PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 25%, 1)
     2462PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 37.5%)
     2463PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 37.5%, 0)
     2464PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 37.5%, 0.2)
     2465PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 37.5%, 1)
     2466PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 50%)
     2467PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 50%, 0)
     2468PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 50%, 0.2)
     2469PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 50%, 1)
     2470PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 62.5%)
     2471PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 62.5%, 0)
     2472PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 62.5%, 0.2)
     2473PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 62.5%, 1)
    24742474PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 75%)
    24752475PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 75%, 0)
    … …  
    24882488PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 0%, 0.2)
    24892489PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 0%, 1)
    2490 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)"
    2491 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)"
    2492 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)"
    2493 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)"
    2494 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)"
    2495 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)"
    2496 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)"
    2497 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)"
    2498 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)"
    2499 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)"
    2500 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)"
    2501 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)"
    2502 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)"
    2503 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)"
    2504 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)"
    2505 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)"
    2506 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)"
    2507 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)"
    2508 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)"
    2509 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)"
     2490PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 12.5%)
     2491PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 12.5%, 0)
     2492PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 12.5%, 0.2)
     2493PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 12.5%, 1)
     2494PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 25%)
     2495PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 25%, 0)
     2496PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 25%, 0.2)
     2497PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 25%, 1)
     2498PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 37.5%)
     2499PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 37.5%, 0)
     2500PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 37.5%, 0.2)
     2501PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 37.5%, 1)
     2502PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 50%)
     2503PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 50%, 0)
     2504PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 50%, 0.2)
     2505PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 50%, 1)
     2506PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 62.5%)
     2507PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 62.5%, 0)
     2508PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 62.5%, 0.2)
     2509PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 62.5%, 1)
    25102510PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 75%)
    25112511PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 75%, 0)
    … …  
    25242524PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 0%, 0.2)
    25252525PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 0%, 1)
    2526 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)"
    2527 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)"
    2528 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)"
    2529 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)"
    2530 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)"
    2531 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)"
    2532 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)"
    2533 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)"
    2534 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)"
    2535 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)"
    2536 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)"
    2537 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)"
    2538 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)"
    2539 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)"
    2540 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)"
    2541 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)"
    2542 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)"
    2543 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)"
    2544 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)"
    2545 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)"
     2526PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 12.5%)
     2527PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 12.5%, 0)
     2528PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 12.5%, 0.2)
     2529PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 12.5%, 1)
     2530PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 25%)
     2531PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 25%, 0)
     2532PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 25%, 0.2)
     2533PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 25%, 1)
     2534PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 37.5%)
     2535PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 37.5%, 0)
     2536PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 37.5%, 0.2)
     2537PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 37.5%, 1)
     2538PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 50%)
     2539PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 50%, 0)
     2540PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 50%, 0.2)
     2541PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 50%, 1)
     2542PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 62.5%)
     2543PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 62.5%, 0)
     2544PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 62.5%, 0.2)
     2545PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 62.5%, 1)
    25462546PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 75%)
    25472547PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 75%, 0)
    … …  
    25602560PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 0%, 0.2)
    25612561PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 0%, 1)
    2562 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)"
    2563 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)"
    2564 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)"
    2565 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)"
    2566 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)"
    2567 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)"
    2568 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)"
    2569 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)"
     2562PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 12.5%)
     2563PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 12.5%, 0)
     2564PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 12.5%, 0.2)
     2565PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 12.5%, 1)
     2566PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 25%)
     2567PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 25%, 0)
     2568PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 25%, 0.2)
     2569PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 25%, 1)
    25702570PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 37.5%)
    25712571PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 37.5%, 0)
    … …  
    25762576PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 50%, 0.2)
    25772577PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 50%, 1)
    2578 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)"
    2579 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)"
    2580 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)"
    2581 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)"
    2582 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)"
    2583 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)"
    2584 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)"
    2585 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)"
     2578PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 62.5%)
     2579PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 62.5%, 0)
     2580PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 62.5%, 0.2)
     2581PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 62.5%, 1)
     2582PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 75%)
     2583PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 75%, 0)
     2584PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 75%, 0.2)
     2585PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 75%, 1)
    25862586PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 87.5%)
    25872587PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 87.5%, 0)
    … …  
    25962596PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 0%, 0.2)
    25972597PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 0%, 1)
    2598 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)"
    2599 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)"
    2600 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)"
    2601 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)"
    2602 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)"
    2603 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)"
    2604 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)"
    2605 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)"
    2606 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)"
    2607 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)"
    2608 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)"
    2609 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)"
    2610 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)"
    2611 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)"
    2612 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)"
    2613 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)"
     2598PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 12.5%)
     2599PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 12.5%, 0)
     2600PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 12.5%, 0.2)
     2601PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 12.5%, 1)
     2602PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 25%)
     2603PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 25%, 0)
     2604PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 25%, 0.2)
     2605PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 25%, 1)
     2606PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 37.5%)
     2607PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 37.5%, 0)
     2608PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 37.5%, 0.2)
     2609PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 37.5%, 1)
     2610PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 50%)
     2611PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 50%, 0)
     2612PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 50%, 0.2)
     2613PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 50%, 1)
    26142614PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 62.5%)
    26152615PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 62.5%, 0)
    … …  
    26322632PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 0%, 0.2)
    26332633PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 0%, 1)
    2634 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)"
    2635 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)"
    2636 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)"
    2637 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)"
    2638 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)"
    2639 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)"
    2640 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)"
    2641 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)"
    2642 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)"
    2643 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)"
    2644 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)"
    2645 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)"
    2646 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)"
    2647 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)"
    2648 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)"
    2649 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)"
     2634PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 12.5%)
     2635PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 12.5%, 0)
     2636PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 12.5%, 0.2)
     2637PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 12.5%, 1)
     2638PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 25%)
     2639PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 25%, 0)
     2640PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 25%, 0.2)
     2641PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 25%, 1)
     2642PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 37.5%)
     2643PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 37.5%, 0)
     2644PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 37.5%, 0.2)
     2645PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 37.5%, 1)
     2646PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 50%)
     2647PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 50%, 0)
     2648PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 50%, 0.2)
     2649PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 50%, 1)
    26502650PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 62.5%)
    26512651PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 62.5%, 0)
    … …  
    26682668PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 0%, 0.2)
    26692669PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 0%, 1)
    2670 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)"
    2671 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)"
    2672 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)"
    2673 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)"
    2674 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)"
    2675 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)"
    2676 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)"
    2677 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)"
    2678 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)"
    2679 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)"
    2680 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)"
    2681 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)"
    2682 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)"
    2683 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)"
    2684 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)"
    2685 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)"
     2670PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 12.5%)
     2671PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 12.5%, 0)
     2672PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 12.5%, 0.2)
     2673PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 12.5%, 1)
     2674PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 25%)
     2675PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 25%, 0)
     2676PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 25%, 0.2)
     2677PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 25%, 1)
     2678PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 37.5%)
     2679PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 37.5%, 0)
     2680PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 37.5%, 0.2)
     2681PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 37.5%, 1)
     2682PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 50%)
     2683PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 50%, 0)
     2684PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 50%, 0.2)
     2685PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 50%, 1)
    26862686PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 62.5%)
    26872687PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 62.5%, 0)
    … …  
    27042704PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 0%, 0.2)
    27052705PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 0%, 1)
    2706 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)"
    2707 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)"
    2708 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)"
    2709 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)"
    2710 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)"
    2711 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)"
    2712 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)"
    2713 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)"
    2714 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)"
    2715 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)"
    2716 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)"
    2717 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)"
    2718 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)"
    2719 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)"
    2720 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)"
    2721 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)"
    2722 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)"
    2723 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)"
    2724 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)"
    2725 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)"
     2706PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 12.5%)
     2707PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 12.5%, 0)
     2708PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 12.5%, 0.2)
     2709PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 12.5%, 1)
     2710PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 25%)
     2711PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 25%, 0)
     2712PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 25%, 0.2)
     2713PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 25%, 1)
     2714PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 37.5%)
     2715PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 37.5%, 0)
     2716PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 37.5%, 0.2)
     2717PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 37.5%, 1)
     2718PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 50%)
     2719PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 50%, 0)
     2720PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 50%, 0.2)
     2721PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 50%, 1)
     2722PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 62.5%)
     2723PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 62.5%, 0)
     2724PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 62.5%, 0.2)
     2725PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 62.5%, 1)
    27262726PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 75%)
    27272727PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 75%, 0)
    … …  
    27402740PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 0%, 0.2)
    27412741PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 0%, 1)
    2742 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)"
    2743 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)"
    2744 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)"
    2745 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)"
    2746 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)"
    2747 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)"
    2748 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)"
    2749 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)"
    2750 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)"
    2751 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)"
    2752 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)"
    2753 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)"
    2754 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)"
    2755 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)"
    2756 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)"
    2757 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)"
    2758 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)"
    2759 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)"
    2760 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)"
    2761 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)"
     2742PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 12.5%)
     2743PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 12.5%, 0)
     2744PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 12.5%, 0.2)
     2745PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 12.5%, 1)
     2746PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 25%)
     2747PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 25%, 0)
     2748PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 25%, 0.2)
     2749PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 25%, 1)
     2750PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 37.5%)
     2751PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 37.5%, 0)
     2752PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 37.5%, 0.2)
     2753PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 37.5%, 1)
     2754PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 50%)
     2755PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 50%, 0)
     2756PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 50%, 0.2)
     2757PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 50%, 1)
     2758PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 62.5%)
     2759PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 62.5%, 0)
     2760PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 62.5%, 0.2)
     2761PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 62.5%, 1)
    27622762PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 75%)
    27632763PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 75%, 0)
    … …  
    27762776PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 0%, 0.2)
    27772777PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 0%, 1)
    2778 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)"
    2779 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)"
    2780 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)"
    2781 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)"
    2782 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)"
    2783 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)"
    2784 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)"
    2785 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)"
    2786 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)"
    2787 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)"
    2788 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)"
    2789 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)"
    2790 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)"
    2791 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)"
    2792 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)"
    2793 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)"
    2794 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)"
    2795 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)"
    2796 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)"
    2797 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)"
     2778PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 12.5%)
     2779PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 12.5%, 0)
     2780PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 12.5%, 0.2)
     2781PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 12.5%, 1)
     2782PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 25%)
     2783PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 25%, 0)
     2784PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 25%, 0.2)
     2785PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 25%, 1)
     2786PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 37.5%)
     2787PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 37.5%, 0)
     2788PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 37.5%, 0.2)
     2789PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 37.5%, 1)
     2790PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 50%)
     2791PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 50%, 0)
     2792PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 50%, 0.2)
     2793PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 50%, 1)
     2794PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 62.5%)
     2795PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 62.5%, 0)
     2796PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 62.5%, 0.2)
     2797PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 62.5%, 1)
    27982798PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 75%)
    27992799PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 75%, 0)
    … …  
    28122812PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 0%, 0.2)
    28132813PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 0%, 1)
    2814 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)"
    2815 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)"
    2816 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)"
    2817 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)"
    2818 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)"
    2819 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)"
    2820 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)"
    2821 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)"
    2822 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)"
    2823 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)"
    2824 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)"
    2825 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)"
    2826 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)"
    2827 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)"
    2828 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)"
    2829 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)"
    2830 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)"
    2831 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)"
    2832 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)"
    2833 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)"
     2814PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 12.5%)
     2815PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 12.5%, 0)
     2816PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 12.5%, 0.2)
     2817PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 12.5%, 1)
     2818PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 25%)
     2819PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 25%, 0)
     2820PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 25%, 0.2)
     2821PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 25%, 1)
     2822PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 37.5%)
     2823PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 37.5%, 0)
     2824PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 37.5%, 0.2)
     2825PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 37.5%, 1)
     2826PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 50%)
     2827PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 50%, 0)
     2828PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 50%, 0.2)
     2829PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 50%, 1)
     2830PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 62.5%)
     2831PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 62.5%, 0)
     2832PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 62.5%, 0.2)
     2833PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 62.5%, 1)
    28342834PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 75%)
    28352835PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 75%, 0)
    … …  
    28482848PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 0%, 0.2)
    28492849PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 0%, 1)
    2850 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)"
    2851 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)"
    2852 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)"
    2853 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)"
    2854 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)"
    2855 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)"
    2856 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)"
    2857 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)"
    2858 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)"
    2859 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)"
    2860 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)"
    2861 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)"
    2862 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)"
    2863 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)"
    2864 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)"
    2865 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)"
    2866 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)"
    2867 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)"
    2868 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)"
    2869 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)"
     2850PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 12.5%)
     2851PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 12.5%, 0)
     2852PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 12.5%, 0.2)
     2853PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 12.5%, 1)
     2854PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 25%)
     2855PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 25%, 0)
     2856PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 25%, 0.2)
     2857PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 25%, 1)
     2858PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 37.5%)
     2859PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 37.5%, 0)
     2860PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 37.5%, 0.2)
     2861PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 37.5%, 1)
     2862PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 50%)
     2863PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 50%, 0)
     2864PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 50%, 0.2)
     2865PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 50%, 1)
     2866PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 62.5%)
     2867PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 62.5%, 0)
     2868PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 62.5%, 0.2)
     2869PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 62.5%, 1)
    28702870PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 75%)
    28712871PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 75%, 0)
    … …  
    28842884PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 0%, 0.2)
    28852885PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 0%, 1)
    2886 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)"
    2887 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)"
    2888 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)"
    2889 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)"
    2890 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)"
    2891 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)"
    2892 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)"
    2893 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)"
    2894 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)"
    2895 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)"
    2896 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)"
    2897 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)"
    2898 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)"
    2899 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)"
    2900 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)"
    2901 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)"
    2902 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)"
    2903 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)"
    2904 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)"
    2905 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)"
    2906 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)"
    2907 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)"
    2908 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)"
    2909 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)"
     2886PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 12.5%)
     2887PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 12.5%, 0)
     2888PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 12.5%, 0.2)
     2889PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 12.5%, 1)
     2890PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 25%)
     2891PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 25%, 0)
     2892PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 25%, 0.2)
     2893PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 25%, 1)
     2894PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 37.5%)
     2895PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 37.5%, 0)
     2896PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 37.5%, 0.2)
     2897PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 37.5%, 1)
     2898PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 50%)
     2899PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 50%, 0)
     2900PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 50%, 0.2)
     2901PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 50%, 1)
     2902PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 62.5%)
     2903PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 62.5%, 0)
     2904PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 62.5%, 0.2)
     2905PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 62.5%, 1)
     2906PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 75%)
     2907PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 75%, 0)
     2908PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 75%, 0.2)
     2909PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 75%, 1)
    29102910PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 87.5%)
    29112911PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 87.5%, 0)
    … …  
    29202920PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 0%, 0.2)
    29212921PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 0%, 1)
    2922 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)"
    2923 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)"
    2924 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)"
    2925 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)"
    2926 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)"
    2927 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)"
    2928 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)"
    2929 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)"
    2930 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)"
    2931 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)"
    2932 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)"
    2933 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)"
    2934 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)"
    2935 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)"
    2936 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)"
    2937 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)"
     2922PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 12.5%)
     2923PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 12.5%, 0)
     2924PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 12.5%, 0.2)
     2925PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 12.5%, 1)
     2926PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 25%)
     2927PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 25%, 0)
     2928PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 25%, 0.2)
     2929PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 25%, 1)
     2930PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 37.5%)
     2931PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 37.5%, 0)
     2932PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 37.5%, 0.2)
     2933PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 37.5%, 1)
     2934PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 50%)
     2935PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 50%, 0)
     2936PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 50%, 0.2)
     2937PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 50%, 1)
    29382938PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 62.5%)
    29392939PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 62.5%, 0)
    … …  
    29562956PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 0%, 0.2)
    29572957PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 0%, 1)
    2958 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)"
    2959 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)"
    2960 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)"
    2961 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)"
    2962 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)"
    2963 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)"
    2964 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)"
    2965 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)"
    2966 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)"
    2967 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)"
    2968 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)"
    2969 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)"
    2970 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)"
    2971 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)"
    2972 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)"
    2973 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)"
     2958PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 12.5%)
     2959PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 12.5%, 0)
     2960PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 12.5%, 0.2)
     2961PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 12.5%, 1)
     2962PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 25%)
     2963PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 25%, 0)
     2964PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 25%, 0.2)
     2965PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 25%, 1)
     2966PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 37.5%)
     2967PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 37.5%, 0)
     2968PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 37.5%, 0.2)
     2969PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 37.5%, 1)
     2970PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 50%)
     2971PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 50%, 0)
     2972PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 50%, 0.2)
     2973PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 50%, 1)
    29742974PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 62.5%)
    29752975PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 62.5%, 0)
    … …  
    29922992PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 0%, 0.2)
    29932993PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 0%, 1)
    2994 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)"
    2995 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)"
    2996 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)"
    2997 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)"
    2998 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)"
    2999 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)"
    3000 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)"
    3001 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)"
    3002 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)"
    3003 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)"
    3004 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)"
    3005 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)"
    3006 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)"
    3007 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)"
    3008 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)"
    3009 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)"
     2994PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 12.5%)
     2995PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 12.5%, 0)
     2996PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 12.5%, 0.2)
     2997PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 12.5%, 1)
     2998PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 25%)
     2999PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 25%, 0)
     3000PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 25%, 0.2)
     3001PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 25%, 1)
     3002PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 37.5%)
     3003PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 37.5%, 0)
     3004PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 37.5%, 0.2)
     3005PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 37.5%, 1)
     3006PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 50%)
     3007PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 50%, 0)
     3008PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 50%, 0.2)
     3009PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 50%, 1)
    30103010PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 62.5%)
    30113011PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 62.5%, 0)
    … …  
    30283028PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 0%, 0.2)
    30293029PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 0%, 1)
    3030 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)"
    3031 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)"
    3032 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)"
    3033 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)"
    3034 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)"
    3035 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)"
    3036 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)"
    3037 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)"
    3038 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)"
    3039 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)"
    3040 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)"
    3041 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)"
    3042 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)"
    3043 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)"
    3044 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)"
    3045 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)"
    3046 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)"
    3047 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)"
    3048 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)"
    3049 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)"
     3030PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 12.5%)
     3031PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 12.5%, 0)
     3032PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 12.5%, 0.2)
     3033PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 12.5%, 1)
     3034PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 25%)
     3035PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 25%, 0)
     3036PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 25%, 0.2)
     3037PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 25%, 1)
     3038PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 37.5%)
     3039PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 37.5%, 0)
     3040PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 37.5%, 0.2)
     3041PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 37.5%, 1)
     3042PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 50%)
     3043PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 50%, 0)
     3044PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 50%, 0.2)
     3045PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 50%, 1)
     3046PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 62.5%)
     3047PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 62.5%, 0)
     3048PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 62.5%, 0.2)
     3049PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 62.5%, 1)
    30503050PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 75%)
    30513051PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 75%, 0)
    … …  
    30643064PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 0%, 0.2)
    30653065PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 0%, 1)
    3066 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)"
    3067 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)"
    3068 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)"
    3069 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)"
    3070 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)"
    3071 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)"
    3072 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)"
    3073 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)"
    3074 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)"
    3075 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)"
    3076 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)"
    3077 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)"
    3078 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)"
    3079 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)"
    3080 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)"
    3081 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)"
    3082 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)"
    3083 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)"
    3084 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)"
    3085 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)"
     3066PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 12.5%)
     3067PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 12.5%, 0)
     3068PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 12.5%, 0.2)
     3069PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 12.5%, 1)
     3070PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 25%)
     3071PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 25%, 0)
     3072PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 25%, 0.2)
     3073PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 25%, 1)
     3074PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 37.5%)
     3075PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 37.5%, 0)
     3076PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 37.5%, 0.2)
     3077PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 37.5%, 1)
     3078PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 50%)
     3079PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 50%, 0)
     3080PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 50%, 0.2)
     3081PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 50%, 1)
     3082PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 62.5%)
     3083PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 62.5%, 0)
     3084PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 62.5%, 0.2)
     3085PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 62.5%, 1)
    30863086PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 75%)
    30873087PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 75%, 0)
    … …  
    31003100PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 0%, 0.2)
    31013101PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 0%, 1)
    3102 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)"
    3103 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)"
    3104 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)"
    3105 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)"
    3106 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)"
    3107 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)"
    3108 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)"
    3109 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)"
    3110 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)"
    3111 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)"
    3112 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)"
    3113 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)"
    3114 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)"
    3115 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)"
    3116 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)"
    3117 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)"
    3118 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)"
    3119 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)"
    3120 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)"
    3121 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)"
     3102PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 12.5%)
     3103PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 12.5%, 0)
     3104PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 12.5%, 0.2)
     3105PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 12.5%, 1)
     3106PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 25%)
     3107PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 25%, 0)
     3108PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 25%, 0.2)
     3109PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 25%, 1)
     3110PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 37.5%)
     3111PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 37.5%, 0)
     3112PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 37.5%, 0.2)
     3113PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 37.5%, 1)
     3114PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 50%)
     3115PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 50%, 0)
     3116PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 50%, 0.2)
     3117PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 50%, 1)
     3118PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 62.5%)
     3119PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 62.5%, 0)
     3120PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 62.5%, 0.2)
     3121PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 62.5%, 1)
    31223122PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 75%)
    31233123PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 75%, 0)
    … …  
    31363136PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 0%, 0.2)
    31373137PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 0%, 1)
    3138 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)"
    3139 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)"
    3140 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)"
    3141 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)"
    3142 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)"
    3143 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)"
    3144 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)"
    3145 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)"
    3146 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)"
    3147 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)"
    3148 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)"
    3149 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)"
    3150 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)"
    3151 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)"
    3152 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)"
    3153 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)"
    3154 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)"
    3155 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)"
    3156 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)"
    3157 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)"
     3138PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 12.5%)
     3139PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 12.5%, 0)
     3140PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 12.5%, 0.2)
     3141PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 12.5%, 1)
     3142PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 25%)
     3143PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 25%, 0)
     3144PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 25%, 0.2)
     3145PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 25%, 1)
     3146PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 37.5%)
     3147PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 37.5%, 0)
     3148PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 37.5%, 0.2)
     3149PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 37.5%, 1)
     3150PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 50%)
     3151PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 50%, 0)
     3152PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 50%, 0.2)
     3153PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 50%, 1)
     3154PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 62.5%)
     3155PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 62.5%, 0)
     3156PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 62.5%, 0.2)
     3157PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 62.5%, 1)
    31583158PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 75%)
    31593159PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 75%, 0)
    … …  
    31723172PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 0%, 0.2)
    31733173PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 0%, 1)
    3174 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)"
    3175 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)"
    3176 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)"
    3177 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)"
    3178 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)"
    3179 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)"
    3180 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)"
    3181 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)"
    3182 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)"
    3183 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)"
    3184 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)"
    3185 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)"
    3186 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)"
    3187 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)"
    3188 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)"
    3189 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)"
    3190 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)"
    3191 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)"
    3192 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)"
    3193 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)"
     3174PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 12.5%)
     3175PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 12.5%, 0)
     3176PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 12.5%, 0.2)
     3177PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 12.5%, 1)
     3178PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 25%)
     3179PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 25%, 0)
     3180PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 25%, 0.2)
     3181PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 25%, 1)
     3182PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 37.5%)
     3183PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 37.5%, 0)
     3184PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 37.5%, 0.2)
     3185PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 37.5%, 1)
     3186PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 50%)
     3187PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 50%, 0)
     3188PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 50%, 0.2)
     3189PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 50%, 1)
     3190PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 62.5%)
     3191PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 62.5%, 0)
     3192PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 62.5%, 0.2)
     3193PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 62.5%, 1)
    31943194PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 75%)
    31953195PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 75%, 0)
    … …  
    32083208PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 0%, 0.2)
    32093209PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 0%, 1)
    3210 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)"
    3211 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)"
    3212 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)"
    3213 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)"
    3214 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)"
    3215 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)"
    3216 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)"
    3217 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)"
     3210PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 12.5%)
     3211PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 12.5%, 0)
     3212PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 12.5%, 0.2)
     3213PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 12.5%, 1)
     3214PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 25%)
     3215PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 25%, 0)
     3216PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 25%, 0.2)
     3217PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 25%, 1)
    32183218PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 37.5%)
    32193219PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 37.5%, 0)
    … …  
    32243224PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 50%, 0.2)
    32253225PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 50%, 1)
    3226 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)"
    3227 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)"
    3228 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)"
    3229 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)"
    3230 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)"
    3231 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)"
    3232 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)"
    3233 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)"
     3226PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 62.5%)
     3227PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 62.5%, 0)
     3228PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 62.5%, 0.2)
     3229PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 62.5%, 1)
     3230PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 75%)
     3231PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 75%, 0)
     3232PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 75%, 0.2)
     3233PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 75%, 1)
    32343234PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 87.5%)
    32353235PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 87.5%, 0)
    … …  
    32443244PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 0%, 0.2)
    32453245PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 0%, 1)
    3246 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)"
    3247 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)"
    3248 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)"
    3249 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)"
    3250 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)"
    3251 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)"
    3252 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)"
    3253 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)"
    3254 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)"
    3255 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)"
    3256 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)"
    3257 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)"
    3258 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)"
    3259 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)"
    3260 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)"
    3261 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)"
     3246PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 12.5%)
     3247PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 12.5%, 0)
     3248PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 12.5%, 0.2)
     3249PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 12.5%, 1)
     3250PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 25%)
     3251PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 25%, 0)
     3252PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 25%, 0.2)
     3253PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 25%, 1)
     3254PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 37.5%)
     3255PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 37.5%, 0)
     3256PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 37.5%, 0.2)
     3257PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 37.5%, 1)
     3258PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 50%)
     3259PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 50%, 0)
     3260PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 50%, 0.2)
     3261PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 50%, 1)
    32623262PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 62.5%)
    32633263PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 62.5%, 0)
    … …  
    32803280PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 0%, 0.2)
    32813281PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 0%, 1)
    3282 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)"
    3283 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)"
    3284 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)"
    3285 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)"
    3286 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)"
    3287 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)"
    3288 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)"
    3289 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)"
    3290 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)"
    3291 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)"
    3292 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)"
    3293 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)"
    3294 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)"
    3295 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)"
    3296 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)"
    3297 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)"
     3282PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 12.5%)
     3283PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 12.5%, 0)
     3284PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 12.5%, 0.2)
     3285PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 12.5%, 1)
     3286PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 25%)
     3287PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 25%, 0)
     3288PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 25%, 0.2)
     3289PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 25%, 1)
     3290PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 37.5%)
     3291PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 37.5%, 0)
     3292PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 37.5%, 0.2)
     3293PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 37.5%, 1)
     3294PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 50%)
     3295PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 50%, 0)
     3296PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 50%, 0.2)
     3297PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 50%, 1)
    32983298PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 62.5%)
    32993299PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 62.5%, 0)
    … …  
    33163316PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 0%, 0.2)
    33173317PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 0%, 1)
    3318 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)"
    3319 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)"
    3320 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)"
    3321 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)"
    3322 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)"
    3323 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)"
    3324 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)"
    3325 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)"
    3326 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)"
    3327 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)"
    3328 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)"
    3329 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)"
    3330 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)"
    3331 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)"
    3332 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)"
    3333 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)"
     3318PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 12.5%)
     3319PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 12.5%, 0)
     3320PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 12.5%, 0.2)
     3321PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 12.5%, 1)
     3322PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 25%)
     3323PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 25%, 0)
     3324PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 25%, 0.2)
     3325PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 25%, 1)
     3326PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 37.5%)
     3327PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 37.5%, 0)
     3328PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 37.5%, 0.2)
     3329PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 37.5%, 1)
     3330PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 50%)
     3331PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 50%, 0)
     3332PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 50%, 0.2)
     3333PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 50%, 1)
    33343334PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 62.5%)
    33353335PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 62.5%, 0)
    … …  
    33523352PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 0%, 0.2)
    33533353PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 0%, 1)
    3354 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)"
    3355 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)"
    3356 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)"
    3357 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)"
    3358 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)"
    3359 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)"
    3360 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)"
    3361 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)"
    3362 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)"
    3363 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)"
    3364 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)"
    3365 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)"
    3366 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)"
    3367 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)"
    3368 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)"
    3369 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)"
    3370 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)"
    3371 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)"
    3372 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)"
    3373 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)"
     3354PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 12.5%)
     3355PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 12.5%, 0)
     3356PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 12.5%, 0.2)
     3357PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 12.5%, 1)
     3358PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 25%)
     3359PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 25%, 0)
     3360PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 25%, 0.2)
     3361PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 25%, 1)
     3362PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 37.5%)
     3363PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 37.5%, 0)
     3364PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 37.5%, 0.2)
     3365PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 37.5%, 1)
     3366PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 50%)
     3367PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 50%, 0)
     3368PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 50%, 0.2)
     3369PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 50%, 1)
     3370PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 62.5%)
     3371PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 62.5%, 0)
     3372PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 62.5%, 0.2)
     3373PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 62.5%, 1)
    33743374PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 75%)
    33753375PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 75%, 0)
    … …  
    33883388PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 0%, 0.2)
    33893389PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 0%, 1)
    3390 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)"
    3391 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)"
    3392 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)"
    3393 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)"
    3394 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)"
    3395 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 25%, 0) assert_equals: expected "rgba(96, 32, 64, 0)" but got "rgba(95, 31, 63, 0)"
    3396 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 25%, 0.2) assert_equals: expected "rgba(96, 32, 64, 0.2)" but got "rgba(95, 31, 63, 0.2)"
    3397 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 25%, 1) assert_equals: expected "rgb(96, 32, 64)" but got "rgb(95, 31, 63)"
    3398 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 50%, 37.5%) assert_equals: expected "rgb(143, 48, 96)" but got "rgb(143, 47, 95)"
    3399 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 37.5%, 0) assert_equals: expected "rgba(143, 48, 96, 0)" but got "rgba(143, 47, 95, 0)"
    3400 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 37.5%, 0.2) assert_equals: expected "rgba(143, 48, 96, 0.2)" but got "rgba(143, 47, 95, 0.2)"
    3401 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 37.5%, 1) assert_equals: expected "rgb(143, 48, 96)" but got "rgb(143, 47, 95)"
    3402 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 50%, 50%) assert_equals: expected "rgb(191, 64, 128)" but got "rgb(191, 63, 127)"
    3403 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 50%, 0) assert_equals: expected "rgba(191, 64, 128, 0)" but got "rgba(191, 63, 127, 0)"
    3404 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 50%, 0.2) assert_equals: expected "rgba(191, 64, 128, 0.2)" but got "rgba(191, 63, 127, 0.2)"
    3405 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 50%, 1) assert_equals: expected "rgb(191, 64, 128)" but got "rgb(191, 63, 127)"
    3406 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 50%, 62.5%) assert_equals: expected "rgb(207, 112, 159)" but got "rgb(207, 111, 159)"
    3407 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 62.5%, 0) assert_equals: expected "rgba(207, 112, 159, 0)" but got "rgba(207, 111, 159, 0)"
    3408 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 62.5%, 0.2) assert_equals: expected "rgba(207, 112, 159, 0.2)" but got "rgba(207, 111, 159, 0.2)"
    3409 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 62.5%, 1) assert_equals: expected "rgb(207, 112, 159)" but got "rgb(207, 111, 159)"
     3390PASS HSL/HSLA value should parse and round correctly: hsl(330, 50%, 12.5%)
     3391PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 12.5%, 0)
     3392PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 12.5%, 0.2)
     3393PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 12.5%, 1)
     3394PASS HSL/HSLA value should parse and round correctly: hsl(330, 50%, 25%)
     3395PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 25%, 0)
     3396PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 25%, 0.2)
     3397PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 25%, 1)
     3398PASS HSL/HSLA value should parse and round correctly: hsl(330, 50%, 37.5%)
     3399PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 37.5%, 0)
     3400PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 37.5%, 0.2)
     3401PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 37.5%, 1)
     3402PASS HSL/HSLA value should parse and round correctly: hsl(330, 50%, 50%)
     3403PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 50%, 0)
     3404PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 50%, 0.2)
     3405PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 50%, 1)
     3406PASS HSL/HSLA value should parse and round correctly: hsl(330, 50%, 62.5%)
     3407PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 62.5%, 0)
     3408PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 62.5%, 0.2)
     3409PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 62.5%, 1)
    34103410PASS HSL/HSLA value should parse and round correctly: hsl(330, 50%, 75%)
    34113411PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 75%, 0)
    … …  
    34243424PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 0%, 0.2)
    34253425PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 0%, 1)
    3426 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 12.5%) assert_equals: expected "rgb(52, 12, 32)" but got "rgb(51, 11, 31)"
    3427 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 12.5%, 0) assert_equals: expected "rgba(52, 12, 32, 0)" but got "rgba(51, 11, 31, 0)"
    3428 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(52, 12, 32, 0.2)" but got "rgba(51, 11, 31, 0.2)"
    3429 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 12.5%, 1) assert_equals: expected "rgb(52, 12, 32)" but got "rgb(51, 11, 31)"
    3430 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 25%) assert_equals: expected "rgb(104, 24, 64)" but got "rgb(103, 23, 63)"
    3431 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 25%, 0) assert_equals: expected "rgba(104, 24, 64, 0)" but got "rgba(103, 23, 63, 0)"
    3432 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 25%, 0.2) assert_equals: expected "rgba(104, 24, 64, 0.2)" but got "rgba(103, 23, 63, 0.2)"
    3433 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 25%, 1) assert_equals: expected "rgb(104, 24, 64)" but got "rgb(103, 23, 63)"
    3434 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 37.5%) assert_equals: expected "rgb(155, 36, 96)" but got "rgb(155, 35, 95)"
    3435 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 37.5%, 0) assert_equals: expected "rgba(155, 36, 96, 0)" but got "rgba(155, 35, 95, 0)"
    3436 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(155, 36, 96, 0.2)" but got "rgba(155, 35, 95, 0.2)"
    3437 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 37.5%, 1) assert_equals: expected "rgb(155, 36, 96)" but got "rgb(155, 35, 95)"
    3438 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 50%) assert_equals: expected "rgb(207, 48, 128)" but got "rgb(207, 47, 127)"
    3439 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 50%, 0) assert_equals: expected "rgba(207, 48, 128, 0)" but got "rgba(207, 47, 127, 0)"
    3440 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 50%, 0.2) assert_equals: expected "rgba(207, 48, 128, 0.2)" but got "rgba(207, 47, 127, 0.2)"
    3441 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 50%, 1) assert_equals: expected "rgb(207, 48, 128)" but got "rgb(207, 47, 127)"
    3442 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 62.5%) assert_equals: expected "rgb(219, 100, 159)" but got "rgb(219, 99, 159)"
    3443 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 62.5%, 0) assert_equals: expected "rgba(219, 100, 159, 0)" but got "rgba(219, 99, 159, 0)"
    3444 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(219, 100, 159, 0.2)" but got "rgba(219, 99, 159, 0.2)"
    3445 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 62.5%, 1) assert_equals: expected "rgb(219, 100, 159)" but got "rgb(219, 99, 159)"
     3426PASS HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 12.5%)
     3427PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 12.5%, 0)
     3428PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 12.5%, 0.2)
     3429PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 12.5%, 1)
     3430PASS HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 25%)
     3431PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 25%, 0)
     3432PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 25%, 0.2)
     3433PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 25%, 1)
     3434PASS HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 37.5%)
     3435PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 37.5%, 0)
     3436PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 37.5%, 0.2)
     3437PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 37.5%, 1)
     3438PASS HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 50%)
     3439PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 50%, 0)
     3440PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 50%, 0.2)
     3441PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 50%, 1)
     3442PASS HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 62.5%)
     3443PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 62.5%, 0)
     3444PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 62.5%, 0.2)
     3445PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 62.5%, 1)
    34463446PASS HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 75%)
    34473447PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 75%, 0)
    … …  
    34603460PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 0%, 0.2)
    34613461PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 0%, 1)
    3462 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 75%, 12.5%) assert_equals: expected "rgb(56, 8, 32)" but got "rgb(55, 7, 31)"
    3463 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 12.5%, 0) assert_equals: expected "rgba(56, 8, 32, 0)" but got "rgba(55, 7, 31, 0)"
    3464 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 12.5%, 0.2) assert_equals: expected "rgba(56, 8, 32, 0.2)" but got "rgba(55, 7, 31, 0.2)"
    3465 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 12.5%, 1) assert_equals: expected "rgb(56, 8, 32)" but got "rgb(55, 7, 31)"
    3466 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 75%, 25%) assert_equals: expected "rgb(112, 16, 64)" but got "rgb(111, 15, 63)"
    3467 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 25%, 0) assert_equals: expected "rgba(112, 16, 64, 0)" but got "rgba(111, 15, 63, 0)"
    3468 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 25%, 0.2) assert_equals: expected "rgba(112, 16, 64, 0.2)" but got "rgba(111, 15, 63, 0.2)"
    3469 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 25%, 1) assert_equals: expected "rgb(112, 16, 64)" but got "rgb(111, 15, 63)"
    3470 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 75%, 37.5%) assert_equals: expected "rgb(167, 24, 96)" but got "rgb(167, 23, 95)"
    3471 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 37.5%, 0) assert_equals: expected "rgba(167, 24, 96, 0)" but got "rgba(167, 23, 95, 0)"
    3472 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 37.5%, 0.2) assert_equals: expected "rgba(167, 24, 96, 0.2)" but got "rgba(167, 23, 95, 0.2)"
    3473 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 37.5%, 1) assert_equals: expected "rgb(167, 24, 96)" but got "rgb(167, 23, 95)"
    3474 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 75%, 50%) assert_equals: expected "rgb(223, 32, 128)" but got "rgb(223, 31, 127)"
    3475 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 50%, 0) assert_equals: expected "rgba(223, 32, 128, 0)" but got "rgba(223, 31, 127, 0)"
    3476 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 50%, 0.2) assert_equals: expected "rgba(223, 32, 128, 0.2)" but got "rgba(223, 31, 127, 0.2)"
    3477 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 50%, 1) assert_equals: expected "rgb(223, 32, 128)" but got "rgb(223, 31, 127)"
    3478 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 75%, 62.5%) assert_equals: expected "rgb(231, 88, 159)" but got "rgb(231, 87, 159)"
    3479 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 62.5%, 0) assert_equals: expected "rgba(231, 88, 159, 0)" but got "rgba(231, 87, 159, 0)"
    3480 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 62.5%, 0.2) assert_equals: expected "rgba(231, 88, 159, 0.2)" but got "rgba(231, 87, 159, 0.2)"
    3481 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 62.5%, 1) assert_equals: expected "rgb(231, 88, 159)" but got "rgb(231, 87, 159)"
     3462PASS HSL/HSLA value should parse and round correctly: hsl(330, 75%, 12.5%)
     3463PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 12.5%, 0)
     3464PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 12.5%, 0.2)
     3465PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 12.5%, 1)
     3466PASS HSL/HSLA value should parse and round correctly: hsl(330, 75%, 25%)
     3467PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 25%, 0)
     3468PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 25%, 0.2)
     3469PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 25%, 1)
     3470PASS HSL/HSLA value should parse and round correctly: hsl(330, 75%, 37.5%)
     3471PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 37.5%, 0)
     3472PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 37.5%, 0.2)
     3473PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 37.5%, 1)
     3474PASS HSL/HSLA value should parse and round correctly: hsl(330, 75%, 50%)
     3475PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 50%, 0)
     3476PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 50%, 0.2)
     3477PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 50%, 1)
     3478PASS HSL/HSLA value should parse and round correctly: hsl(330, 75%, 62.5%)
     3479PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 62.5%, 0)
     3480PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 62.5%, 0.2)
     3481PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 62.5%, 1)
    34823482PASS HSL/HSLA value should parse and round correctly: hsl(330, 75%, 75%)
    34833483PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 75%, 0)
    … …  
    34963496PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 0%, 0.2)
    34973497PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 0%, 1)
    3498 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 12.5%) assert_equals: expected "rgb(60, 4, 32)" but got "rgb(59, 3, 31)"
    3499 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 12.5%, 0) assert_equals: expected "rgba(60, 4, 32, 0)" but got "rgba(59, 3, 31, 0)"
    3500 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(60, 4, 32, 0.2)" but got "rgba(59, 3, 31, 0.2)"
    3501 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 12.5%, 1) assert_equals: expected "rgb(60, 4, 32)" but got "rgb(59, 3, 31)"
    3502 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 25%) assert_equals: expected "rgb(120, 8, 64)" but got "rgb(119, 7, 63)"
    3503 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 25%, 0) assert_equals: expected "rgba(120, 8, 64, 0)" but got "rgba(119, 7, 63, 0)"
    3504 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 25%, 0.2) assert_equals: expected "rgba(120, 8, 64, 0.2)" but got "rgba(119, 7, 63, 0.2)"
    3505 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 25%, 1) assert_equals: expected "rgb(120, 8, 64)" but got "rgb(119, 7, 63)"
    3506 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 37.5%) assert_equals: expected "rgb(179, 12, 96)" but got "rgb(179, 11, 95)"
    3507 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 37.5%, 0) assert_equals: expected "rgba(179, 12, 96, 0)" but got "rgba(179, 11, 95, 0)"
    3508 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(179, 12, 96, 0.2)" but got "rgba(179, 11, 95, 0.2)"
    3509 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 37.5%, 1) assert_equals: expected "rgb(179, 12, 96)" but got "rgb(179, 11, 95)"
    3510 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 50%) assert_equals: expected "rgb(239, 16, 128)" but got "rgb(239, 15, 127)"
    3511 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 50%, 0) assert_equals: expected "rgba(239, 16, 128, 0)" but got "rgba(239, 15, 127, 0)"
    3512 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 50%, 0.2) assert_equals: expected "rgba(239, 16, 128, 0.2)" but got "rgba(239, 15, 127, 0.2)"
    3513 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 50%, 1) assert_equals: expected "rgb(239, 16, 128)" but got "rgb(239, 15, 127)"
    3514 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 62.5%) assert_equals: expected "rgb(243, 76, 159)" but got "rgb(243, 75, 159)"
    3515 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 62.5%, 0) assert_equals: expected "rgba(243, 76, 159, 0)" but got "rgba(243, 75, 159, 0)"
    3516 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(243, 76, 159, 0.2)" but got "rgba(243, 75, 159, 0.2)"
    3517 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 62.5%, 1) assert_equals: expected "rgb(243, 76, 159)" but got "rgb(243, 75, 159)"
     3498PASS HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 12.5%)
     3499PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 12.5%, 0)
     3500PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 12.5%, 0.2)
     3501PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 12.5%, 1)
     3502PASS HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 25%)
     3503PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 25%, 0)
     3504PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 25%, 0.2)
     3505PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 25%, 1)
     3506PASS HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 37.5%)
     3507PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 37.5%, 0)
     3508PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 37.5%, 0.2)
     3509PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 37.5%, 1)
     3510PASS HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 50%)
     3511PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 50%, 0)
     3512PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 50%, 0.2)
     3513PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 50%, 1)
     3514PASS HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 62.5%)
     3515PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 62.5%, 0)
     3516PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 62.5%, 0.2)
     3517PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 62.5%, 1)
    35183518PASS HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 75%)
    35193519PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 75%, 0)
    … …  
    35323532PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 0%, 0.2)
    35333533PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 0%, 1)
    3534 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 100%, 12.5%) assert_equals: expected "rgb(64, 0, 32)" but got "rgb(63, 0, 31)"
    3535 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 12.5%, 0) assert_equals: expected "rgba(64, 0, 32, 0)" but got "rgba(63, 0, 31, 0)"
    3536 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 12.5%, 0.2) assert_equals: expected "rgba(64, 0, 32, 0.2)" but got "rgba(63, 0, 31, 0.2)"
    3537 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 12.5%, 1) assert_equals: expected "rgb(64, 0, 32)" but got "rgb(63, 0, 31)"
    3538 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 100%, 25%) assert_equals: expected "rgb(128, 0, 64)" but got "rgb(127, 0, 63)"
    3539 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 25%, 0) assert_equals: expected "rgba(128, 0, 64, 0)" but got "rgba(127, 0, 63, 0)"
    3540 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 25%, 0.2) assert_equals: expected "rgba(128, 0, 64, 0.2)" but got "rgba(127, 0, 63, 0.2)"
    3541 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 25%, 1) assert_equals: expected "rgb(128, 0, 64)" but got "rgb(127, 0, 63)"
    3542 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 100%, 37.5%) assert_equals: expected "rgb(191, 0, 96)" but got "rgb(191, 0, 95)"
    3543 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 37.5%, 0) assert_equals: expected "rgba(191, 0, 96, 0)" but got "rgba(191, 0, 95, 0)"
    3544 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 37.5%, 0.2) assert_equals: expected "rgba(191, 0, 96, 0.2)" but got "rgba(191, 0, 95, 0.2)"
    3545 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 37.5%, 1) assert_equals: expected "rgb(191, 0, 96)" but got "rgb(191, 0, 95)"
    3546 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 100%, 50%) assert_equals: expected "rgb(255, 0, 128)" but got "rgb(255, 0, 127)"
    3547 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 50%, 0) assert_equals: expected "rgba(255, 0, 128, 0)" but got "rgba(255, 0, 127, 0)"
    3548 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 50%, 0.2) assert_equals: expected "rgba(255, 0, 128, 0.2)" but got "rgba(255, 0, 127, 0.2)"
    3549 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 50%, 1) assert_equals: expected "rgb(255, 0, 128)" but got "rgb(255, 0, 127)"
    3550 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 100%, 62.5%) assert_equals: expected "rgb(255, 64, 159)" but got "rgb(255, 63, 159)"
    3551 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 62.5%, 0) assert_equals: expected "rgba(255, 64, 159, 0)" but got "rgba(255, 63, 159, 0)"
    3552 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 62.5%, 0.2) assert_equals: expected "rgba(255, 64, 159, 0.2)" but got "rgba(255, 63, 159, 0.2)"
    3553 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 62.5%, 1) assert_equals: expected "rgb(255, 64, 159)" but got "rgb(255, 63, 159)"
    3554 FAIL HSL/HSLA value should parse and round correctly: hsl(330, 100%, 75%) assert_equals: expected "rgb(255, 128, 191)" but got "rgb(255, 127, 191)"
    3555 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 75%, 0) assert_equals: expected "rgba(255, 128, 191, 0)" but got "rgba(255, 127, 191, 0)"
    3556 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 75%, 0.2) assert_equals: expected "rgba(255, 128, 191, 0.2)" but got "rgba(255, 127, 191, 0.2)"
    3557 FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 75%, 1) assert_equals: expected "rgb(255, 128, 191)" but got "rgb(255, 127, 191)"
     3534PASS HSL/HSLA value should parse and round correctly: hsl(330, 100%, 12.5%)
     3535PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 12.5%, 0)
     3536PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 12.5%, 0.2)
     3537PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 12.5%, 1)
     3538PASS HSL/HSLA value should parse and round correctly: hsl(330, 100%, 25%)
     3539PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 25%, 0)
     3540PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 25%, 0.2)
     3541PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 25%, 1)
     3542PASS HSL/HSLA value should parse and round correctly: hsl(330, 100%, 37.5%)
     3543PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 37.5%, 0)
     3544PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 37.5%, 0.2)
     3545PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 37.5%, 1)
     3546PASS HSL/HSLA value should parse and round correctly: hsl(330, 100%, 50%)
     3547PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 50%, 0)
     3548PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 50%, 0.2)
     3549PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 50%, 1)
     3550PASS HSL/HSLA value should parse and round correctly: hsl(330, 100%, 62.5%)
     3551PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 62.5%, 0)
     3552PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 62.5%, 0.2)
     3553PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 62.5%, 1)
     3554PASS HSL/HSLA value should parse and round correctly: hsl(330, 100%, 75%)
     3555PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 75%, 0)
     3556PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 75%, 0.2)
     3557PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 75%, 1)
    35583558PASS HSL/HSLA value should parse and round correctly: hsl(330, 100%, 87.5%)
    35593559PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 87.5%, 0)
    … …  
    35683568PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 0%, 0.2)
    35693569PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 0%, 1)
    3570 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
    3571 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
    3572 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
    3573 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
    3574 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
    3575 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
    3576 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
    3577 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
    3578 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
    3579 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
    3580 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
    3581 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
    3582 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
    3583 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
    3584 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
    3585 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
     3570PASS HSL/HSLA value should parse and round correctly: hsl(360, 0%, 12.5%)
     3571PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 12.5%, 0)
     3572PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 12.5%, 0.2)
     3573PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 12.5%, 1)
     3574PASS HSL/HSLA value should parse and round correctly: hsl(360, 0%, 25%)
     3575PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 25%, 0)
     3576PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 25%, 0.2)
     3577PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 25%, 1)
     3578PASS HSL/HSLA value should parse and round correctly: hsl(360, 0%, 37.5%)
     3579PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 37.5%, 0)
     3580PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 37.5%, 0.2)
     3581PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 37.5%, 1)
     3582PASS HSL/HSLA value should parse and round correctly: hsl(360, 0%, 50%)
     3583PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 50%, 0)
     3584PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 50%, 0.2)
     3585PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 50%, 1)
    35863586PASS HSL/HSLA value should parse and round correctly: hsl(360, 0%, 62.5%)
    35873587PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 62.5%, 0)
    … …  
    36043604PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 0%, 0.2)
    36053605PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 0%, 1)
    3606 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 12.5%) assert_equals: expected "rgb(36, 28, 28)" but got "rgb(35, 27, 27)"
    3607 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 12.5%, 0) assert_equals: expected "rgba(36, 28, 28, 0)" but got "rgba(35, 27, 27, 0)"
    3608 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(36, 28, 28, 0.2)" but got "rgba(35, 27, 27, 0.2)"
    3609 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 12.5%, 1) assert_equals: expected "rgb(36, 28, 28)" but got "rgb(35, 27, 27)"
    3610 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 25%) assert_equals: expected "rgb(72, 56, 56)" but got "rgb(71, 55, 55)"
    3611 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 25%, 0) assert_equals: expected "rgba(72, 56, 56, 0)" but got "rgba(71, 55, 55, 0)"
    3612 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 25%, 0.2) assert_equals: expected "rgba(72, 56, 56, 0.2)" but got "rgba(71, 55, 55, 0.2)"
    3613 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 25%, 1) assert_equals: expected "rgb(72, 56, 56)" but got "rgb(71, 55, 55)"
    3614 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 37.5%) assert_equals: expected "rgb(108, 84, 84)" but got "rgb(107, 83, 83)"
    3615 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 37.5%, 0) assert_equals: expected "rgba(108, 84, 84, 0)" but got "rgba(107, 83, 83, 0)"
    3616 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(108, 84, 84, 0.2)" but got "rgba(107, 83, 83, 0.2)"
    3617 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 37.5%, 1) assert_equals: expected "rgb(108, 84, 84)" but got "rgb(107, 83, 83)"
    3618 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 50%) assert_equals: expected "rgb(143, 112, 112)" but got "rgb(143, 111, 111)"
    3619 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 50%, 0) assert_equals: expected "rgba(143, 112, 112, 0)" but got "rgba(143, 111, 111, 0)"
    3620 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 50%, 0.2) assert_equals: expected "rgba(143, 112, 112, 0.2)" but got "rgba(143, 111, 111, 0.2)"
    3621 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 50%, 1) assert_equals: expected "rgb(143, 112, 112)" but got "rgb(143, 111, 111)"
     3606PASS HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 12.5%)
     3607PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 12.5%, 0)
     3608PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 12.5%, 0.2)
     3609PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 12.5%, 1)
     3610PASS HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 25%)
     3611PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 25%, 0)
     3612PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 25%, 0.2)
     3613PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 25%, 1)
     3614PASS HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 37.5%)
     3615PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 37.5%, 0)
     3616PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 37.5%, 0.2)
     3617PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 37.5%, 1)
     3618PASS HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 50%)
     3619PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 50%, 0)
     3620PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 50%, 0.2)
     3621PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 50%, 1)
    36223622PASS HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 62.5%)
    36233623PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 62.5%, 0)
    … …  
    36403640PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 0%, 0.2)
    36413641PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 0%, 1)
    3642 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 25%, 12.5%) assert_equals: expected "rgb(40, 24, 24)" but got "rgb(39, 23, 23)"
    3643 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 12.5%, 0) assert_equals: expected "rgba(40, 24, 24, 0)" but got "rgba(39, 23, 23, 0)"
    3644 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 12.5%, 0.2) assert_equals: expected "rgba(40, 24, 24, 0.2)" but got "rgba(39, 23, 23, 0.2)"
    3645 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 12.5%, 1) assert_equals: expected "rgb(40, 24, 24)" but got "rgb(39, 23, 23)"
    3646 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 25%, 25%) assert_equals: expected "rgb(80, 48, 48)" but got "rgb(79, 47, 47)"
    3647 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 25%, 0) assert_equals: expected "rgba(80, 48, 48, 0)" but got "rgba(79, 47, 47, 0)"
    3648 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 25%, 0.2) assert_equals: expected "rgba(80, 48, 48, 0.2)" but got "rgba(79, 47, 47, 0.2)"
    3649 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 25%, 1) assert_equals: expected "rgb(80, 48, 48)" but got "rgb(79, 47, 47)"
    3650 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 25%, 37.5%) assert_equals: expected "rgb(120, 72, 72)" but got "rgb(119, 71, 71)"
    3651 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 37.5%, 0) assert_equals: expected "rgba(120, 72, 72, 0)" but got "rgba(119, 71, 71, 0)"
    3652 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 37.5%, 0.2) assert_equals: expected "rgba(120, 72, 72, 0.2)" but got "rgba(119, 71, 71, 0.2)"
    3653 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 37.5%, 1) assert_equals: expected "rgb(120, 72, 72)" but got "rgb(119, 71, 71)"
    3654 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 25%, 50%) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(159, 95, 95)"
    3655 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 50%, 0) assert_equals: expected "rgba(159, 96, 96, 0)" but got "rgba(159, 95, 95, 0)"
    3656 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 50%, 0.2) assert_equals: expected "rgba(159, 96, 96, 0.2)" but got "rgba(159, 95, 95, 0.2)"
    3657 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 50%, 1) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(159, 95, 95)"
     3642PASS HSL/HSLA value should parse and round correctly: hsl(360, 25%, 12.5%)
     3643PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 12.5%, 0)
     3644PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 12.5%, 0.2)
     3645PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 12.5%, 1)
     3646PASS HSL/HSLA value should parse and round correctly: hsl(360, 25%, 25%)
     3647PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 25%, 0)
     3648PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 25%, 0.2)
     3649PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 25%, 1)
     3650PASS HSL/HSLA value should parse and round correctly: hsl(360, 25%, 37.5%)
     3651PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 37.5%, 0)
     3652PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 37.5%, 0.2)
     3653PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 37.5%, 1)
     3654PASS HSL/HSLA value should parse and round correctly: hsl(360, 25%, 50%)
     3655PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 50%, 0)
     3656PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 50%, 0.2)
     3657PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 50%, 1)
    36583658PASS HSL/HSLA value should parse and round correctly: hsl(360, 25%, 62.5%)
    36593659PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 62.5%, 0)
    … …  
    36763676PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 0%, 0.2)
    36773677PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 0%, 1)
    3678 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 12.5%) assert_equals: expected "rgb(44, 20, 20)" but got "rgb(43, 19, 19)"
    3679 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 12.5%, 0) assert_equals: expected "rgba(44, 20, 20, 0)" but got "rgba(43, 19, 19, 0)"
    3680 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(44, 20, 20, 0.2)" but got "rgba(43, 19, 19, 0.2)"
    3681 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 12.5%, 1) assert_equals: expected "rgb(44, 20, 20)" but got "rgb(43, 19, 19)"
    3682 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 25%) assert_equals: expected "rgb(88, 40, 40)" but got "rgb(87, 39, 39)"
    3683 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 25%, 0) assert_equals: expected "rgba(88, 40, 40, 0)" but got "rgba(87, 39, 39, 0)"
    3684 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 25%, 0.2) assert_equals: expected "rgba(88, 40, 40, 0.2)" but got "rgba(87, 39, 39, 0.2)"
    3685 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 25%, 1) assert_equals: expected "rgb(88, 40, 40)" but got "rgb(87, 39, 39)"
    3686 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 37.5%) assert_equals: expected "rgb(131, 60, 60)" but got "rgb(131, 59, 59)"
    3687 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 37.5%, 0) assert_equals: expected "rgba(131, 60, 60, 0)" but got "rgba(131, 59, 59, 0)"
    3688 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(131, 60, 60, 0.2)" but got "rgba(131, 59, 59, 0.2)"
    3689 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 37.5%, 1) assert_equals: expected "rgb(131, 60, 60)" but got "rgb(131, 59, 59)"
    3690 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 50%) assert_equals: expected "rgb(175, 80, 80)" but got "rgb(175, 79, 79)"
    3691 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 50%, 0) assert_equals: expected "rgba(175, 80, 80, 0)" but got "rgba(175, 79, 79, 0)"
    3692 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 50%, 0.2) assert_equals: expected "rgba(175, 80, 80, 0.2)" but got "rgba(175, 79, 79, 0.2)"
    3693 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 50%, 1) assert_equals: expected "rgb(175, 80, 80)" but got "rgb(175, 79, 79)"
    3694 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 62.5%) assert_equals: expected "rgb(195, 124, 124)" but got "rgb(195, 123, 123)"
    3695 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 62.5%, 0) assert_equals: expected "rgba(195, 124, 124, 0)" but got "rgba(195, 123, 123, 0)"
    3696 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(195, 124, 124, 0.2)" but got "rgba(195, 123, 123, 0.2)"
    3697 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 62.5%, 1) assert_equals: expected "rgb(195, 124, 124)" but got "rgb(195, 123, 123)"
     3678PASS HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 12.5%)
     3679PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 12.5%, 0)
     3680PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 12.5%, 0.2)
     3681PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 12.5%, 1)
     3682PASS HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 25%)
     3683PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 25%, 0)
     3684PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 25%, 0.2)
     3685PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 25%, 1)
     3686PASS HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 37.5%)
     3687PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 37.5%, 0)
     3688PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 37.5%, 0.2)
     3689PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 37.5%, 1)
     3690PASS HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 50%)
     3691PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 50%, 0)
     3692PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 50%, 0.2)
     3693PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 50%, 1)
     3694PASS HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 62.5%)
     3695PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 62.5%, 0)
     3696PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 62.5%, 0.2)
     3697PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 62.5%, 1)
    36983698PASS HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 75%)
    36993699PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 75%, 0)
    … …  
    37123712PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 0%, 0.2)
    37133713PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 0%, 1)
    3714 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 50%, 12.5%) assert_equals: expected "rgb(48, 16, 16)" but got "rgb(47, 15, 15)"
    3715 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 12.5%, 0) assert_equals: expected "rgba(48, 16, 16, 0)" but got "rgba(47, 15, 15, 0)"
    3716 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 12.5%, 0.2) assert_equals: expected "rgba(48, 16, 16, 0.2)" but got "rgba(47, 15, 15, 0.2)"
    3717 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 12.5%, 1) assert_equals: expected "rgb(48, 16, 16)" but got "rgb(47, 15, 15)"
    3718 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 50%, 25%) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(95, 31, 31)"
    3719 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 25%, 0) assert_equals: expected "rgba(96, 32, 32, 0)" but got "rgba(95, 31, 31, 0)"
    3720 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 25%, 0.2) assert_equals: expected "rgba(96, 32, 32, 0.2)" but got "rgba(95, 31, 31, 0.2)"
    3721 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 25%, 1) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(95, 31, 31)"
    3722 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 50%, 37.5%) assert_equals: expected "rgb(143, 48, 48)" but got "rgb(143, 47, 47)"
    3723 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 37.5%, 0) assert_equals: expected "rgba(143, 48, 48, 0)" but got "rgba(143, 47, 47, 0)"
    3724 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 37.5%, 0.2) assert_equals: expected "rgba(143, 48, 48, 0.2)" but got "rgba(143, 47, 47, 0.2)"
    3725 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 37.5%, 1) assert_equals: expected "rgb(143, 48, 48)" but got "rgb(143, 47, 47)"
    3726 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 50%, 50%) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(191, 63, 63)"
    3727 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 50%, 0) assert_equals: expected "rgba(191, 64, 64, 0)" but got "rgba(191, 63, 63, 0)"
    3728 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 50%, 0.2) assert_equals: expected "rgba(191, 64, 64, 0.2)" but got "rgba(191, 63, 63, 0.2)"
    3729 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 50%, 1) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(191, 63, 63)"
    3730 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 50%, 62.5%) assert_equals: expected "rgb(207, 112, 112)" but got "rgb(207, 111, 111)"
    3731 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 62.5%, 0) assert_equals: expected "rgba(207, 112, 112, 0)" but got "rgba(207, 111, 111, 0)"
    3732 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 62.5%, 0.2) assert_equals: expected "rgba(207, 112, 112, 0.2)" but got "rgba(207, 111, 111, 0.2)"
    3733 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 62.5%, 1) assert_equals: expected "rgb(207, 112, 112)" but got "rgb(207, 111, 111)"
     3714PASS HSL/HSLA value should parse and round correctly: hsl(360, 50%, 12.5%)
     3715PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 12.5%, 0)
     3716PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 12.5%, 0.2)
     3717PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 12.5%, 1)
     3718PASS HSL/HSLA value should parse and round correctly: hsl(360, 50%, 25%)
     3719PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 25%, 0)
     3720PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 25%, 0.2)
     3721PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 25%, 1)
     3722PASS HSL/HSLA value should parse and round correctly: hsl(360, 50%, 37.5%)
     3723PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 37.5%, 0)
     3724PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 37.5%, 0.2)
     3725PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 37.5%, 1)
     3726PASS HSL/HSLA value should parse and round correctly: hsl(360, 50%, 50%)
     3727PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 50%, 0)
     3728PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 50%, 0.2)
     3729PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 50%, 1)
     3730PASS HSL/HSLA value should parse and round correctly: hsl(360, 50%, 62.5%)
     3731PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 62.5%, 0)
     3732PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 62.5%, 0.2)
     3733PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 62.5%, 1)
    37343734PASS HSL/HSLA value should parse and round correctly: hsl(360, 50%, 75%)
    37353735PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 75%, 0)
    … …  
    37483748PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 0%, 0.2)
    37493749PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 0%, 1)
    3750 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 12.5%) assert_equals: expected "rgb(52, 12, 12)" but got "rgb(51, 11, 11)"
    3751 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 12.5%, 0) assert_equals: expected "rgba(52, 12, 12, 0)" but got "rgba(51, 11, 11, 0)"
    3752 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(52, 12, 12, 0.2)" but got "rgba(51, 11, 11, 0.2)"
    3753 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 12.5%, 1) assert_equals: expected "rgb(52, 12, 12)" but got "rgb(51, 11, 11)"
    3754 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 25%) assert_equals: expected "rgb(104, 24, 24)" but got "rgb(103, 23, 23)"
    3755 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 25%, 0) assert_equals: expected "rgba(104, 24, 24, 0)" but got "rgba(103, 23, 23, 0)"
    3756 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 25%, 0.2) assert_equals: expected "rgba(104, 24, 24, 0.2)" but got "rgba(103, 23, 23, 0.2)"
    3757 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 25%, 1) assert_equals: expected "rgb(104, 24, 24)" but got "rgb(103, 23, 23)"
    3758 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 37.5%) assert_equals: expected "rgb(155, 36, 36)" but got "rgb(155, 35, 35)"
    3759 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 37.5%, 0) assert_equals: expected "rgba(155, 36, 36, 0)" but got "rgba(155, 35, 35, 0)"
    3760 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(155, 36, 36, 0.2)" but got "rgba(155, 35, 35, 0.2)"
    3761 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 37.5%, 1) assert_equals: expected "rgb(155, 36, 36)" but got "rgb(155, 35, 35)"
    3762 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 50%) assert_equals: expected "rgb(207, 48, 48)" but got "rgb(207, 47, 47)"
    3763 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 50%, 0) assert_equals: expected "rgba(207, 48, 48, 0)" but got "rgba(207, 47, 47, 0)"
    3764 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 50%, 0.2) assert_equals: expected "rgba(207, 48, 48, 0.2)" but got "rgba(207, 47, 47, 0.2)"
    3765 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 50%, 1) assert_equals: expected "rgb(207, 48, 48)" but got "rgb(207, 47, 47)"
    3766 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 62.5%) assert_equals: expected "rgb(219, 100, 100)" but got "rgb(219, 99, 99)"
    3767 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 62.5%, 0) assert_equals: expected "rgba(219, 100, 100, 0)" but got "rgba(219, 99, 99, 0)"
    3768 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(219, 100, 100, 0.2)" but got "rgba(219, 99, 99, 0.2)"
    3769 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 62.5%, 1) assert_equals: expected "rgb(219, 100, 100)" but got "rgb(219, 99, 99)"
     3750PASS HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 12.5%)
     3751PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 12.5%, 0)
     3752PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 12.5%, 0.2)
     3753PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 12.5%, 1)
     3754PASS HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 25%)
     3755PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 25%, 0)
     3756PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 25%, 0.2)
     3757PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 25%, 1)
     3758PASS HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 37.5%)
     3759PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 37.5%, 0)
     3760PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 37.5%, 0.2)
     3761PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 37.5%, 1)
     3762PASS HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 50%)
     3763PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 50%, 0)
     3764PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 50%, 0.2)
     3765PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 50%, 1)
     3766PASS HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 62.5%)
     3767PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 62.5%, 0)
     3768PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 62.5%, 0.2)
     3769PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 62.5%, 1)
    37703770PASS HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 75%)
    37713771PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 75%, 0)
    … …  
    37843784PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 0%, 0.2)
    37853785PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 0%, 1)
    3786 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 75%, 12.5%) assert_equals: expected "rgb(56, 8, 8)" but got "rgb(55, 7, 7)"
    3787 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 12.5%, 0) assert_equals: expected "rgba(56, 8, 8, 0)" but got "rgba(55, 7, 7, 0)"
    3788 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 12.5%, 0.2) assert_equals: expected "rgba(56, 8, 8, 0.2)" but got "rgba(55, 7, 7, 0.2)"
    3789 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 12.5%, 1) assert_equals: expected "rgb(56, 8, 8)" but got "rgb(55, 7, 7)"
    3790 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 75%, 25%) assert_equals: expected "rgb(112, 16, 16)" but got "rgb(111, 15, 15)"
    3791 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 25%, 0) assert_equals: expected "rgba(112, 16, 16, 0)" but got "rgba(111, 15, 15, 0)"
    3792 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 25%, 0.2) assert_equals: expected "rgba(112, 16, 16, 0.2)" but got "rgba(111, 15, 15, 0.2)"
    3793 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 25%, 1) assert_equals: expected "rgb(112, 16, 16)" but got "rgb(111, 15, 15)"
    3794 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 75%, 37.5%) assert_equals: expected "rgb(167, 24, 24)" but got "rgb(167, 23, 23)"
    3795 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 37.5%, 0) assert_equals: expected "rgba(167, 24, 24, 0)" but got "rgba(167, 23, 23, 0)"
    3796 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 37.5%, 0.2) assert_equals: expected "rgba(167, 24, 24, 0.2)" but got "rgba(167, 23, 23, 0.2)"
    3797 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 37.5%, 1) assert_equals: expected "rgb(167, 24, 24)" but got "rgb(167, 23, 23)"
    3798 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 75%, 50%) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(223, 31, 31)"
    3799 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 50%, 0) assert_equals: expected "rgba(223, 32, 32, 0)" but got "rgba(223, 31, 31, 0)"
    3800 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 50%, 0.2) assert_equals: expected "rgba(223, 32, 32, 0.2)" but got "rgba(223, 31, 31, 0.2)"
    3801 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 50%, 1) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(223, 31, 31)"
    3802 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 75%, 62.5%) assert_equals: expected "rgb(231, 88, 88)" but got "rgb(231, 87, 87)"
    3803 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 62.5%, 0) assert_equals: expected "rgba(231, 88, 88, 0)" but got "rgba(231, 87, 87, 0)"
    3804 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 62.5%, 0.2) assert_equals: expected "rgba(231, 88, 88, 0.2)" but got "rgba(231, 87, 87, 0.2)"
    3805 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 62.5%, 1) assert_equals: expected "rgb(231, 88, 88)" but got "rgb(231, 87, 87)"
     3786PASS HSL/HSLA value should parse and round correctly: hsl(360, 75%, 12.5%)
     3787PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 12.5%, 0)
     3788PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 12.5%, 0.2)
     3789PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 12.5%, 1)
     3790PASS HSL/HSLA value should parse and round correctly: hsl(360, 75%, 25%)
     3791PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 25%, 0)
     3792PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 25%, 0.2)
     3793PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 25%, 1)
     3794PASS HSL/HSLA value should parse and round correctly: hsl(360, 75%, 37.5%)
     3795PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 37.5%, 0)
     3796PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 37.5%, 0.2)
     3797PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 37.5%, 1)
     3798PASS HSL/HSLA value should parse and round correctly: hsl(360, 75%, 50%)
     3799PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 50%, 0)
     3800PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 50%, 0.2)
     3801PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 50%, 1)
     3802PASS HSL/HSLA value should parse and round correctly: hsl(360, 75%, 62.5%)
     3803PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 62.5%, 0)
     3804PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 62.5%, 0.2)
     3805PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 62.5%, 1)
    38063806PASS HSL/HSLA value should parse and round correctly: hsl(360, 75%, 75%)
    38073807PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 75%, 0)
    … …  
    38203820PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 0%, 0.2)
    38213821PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 0%, 1)
    3822 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 12.5%) assert_equals: expected "rgb(60, 4, 4)" but got "rgb(59, 3, 3)"
    3823 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 12.5%, 0) assert_equals: expected "rgba(60, 4, 4, 0)" but got "rgba(59, 3, 3, 0)"
    3824 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(60, 4, 4, 0.2)" but got "rgba(59, 3, 3, 0.2)"
    3825 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 12.5%, 1) assert_equals: expected "rgb(60, 4, 4)" but got "rgb(59, 3, 3)"
    3826 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 25%) assert_equals: expected "rgb(120, 8, 8)" but got "rgb(119, 7, 7)"
    3827 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 25%, 0) assert_equals: expected "rgba(120, 8, 8, 0)" but got "rgba(119, 7, 7, 0)"
    3828 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 25%, 0.2) assert_equals: expected "rgba(120, 8, 8, 0.2)" but got "rgba(119, 7, 7, 0.2)"
    3829 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 25%, 1) assert_equals: expected "rgb(120, 8, 8)" but got "rgb(119, 7, 7)"
    3830 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 37.5%) assert_equals: expected "rgb(179, 12, 12)" but got "rgb(179, 11, 11)"
    3831 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 37.5%, 0) assert_equals: expected "rgba(179, 12, 12, 0)" but got "rgba(179, 11, 11, 0)"
    3832 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(179, 12, 12, 0.2)" but got "rgba(179, 11, 11, 0.2)"
    3833 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 37.5%, 1) assert_equals: expected "rgb(179, 12, 12)" but got "rgb(179, 11, 11)"
    3834 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 50%) assert_equals: expected "rgb(239, 16, 16)" but got "rgb(239, 15, 15)"
    3835 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 50%, 0) assert_equals: expected "rgba(239, 16, 16, 0)" but got "rgba(239, 15, 15, 0)"
    3836 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 50%, 0.2) assert_equals: expected "rgba(239, 16, 16, 0.2)" but got "rgba(239, 15, 15, 0.2)"
    3837 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 50%, 1) assert_equals: expected "rgb(239, 16, 16)" but got "rgb(239, 15, 15)"
    3838 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 62.5%) assert_equals: expected "rgb(243, 76, 76)" but got "rgb(243, 75, 75)"
    3839 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 62.5%, 0) assert_equals: expected "rgba(243, 76, 76, 0)" but got "rgba(243, 75, 75, 0)"
    3840 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(243, 76, 76, 0.2)" but got "rgba(243, 75, 75, 0.2)"
    3841 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 62.5%, 1) assert_equals: expected "rgb(243, 76, 76)" but got "rgb(243, 75, 75)"
     3822PASS HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 12.5%)
     3823PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 12.5%, 0)
     3824PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 12.5%, 0.2)
     3825PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 12.5%, 1)
     3826PASS HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 25%)
     3827PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 25%, 0)
     3828PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 25%, 0.2)
     3829PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 25%, 1)
     3830PASS HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 37.5%)
     3831PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 37.5%, 0)
     3832PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 37.5%, 0.2)
     3833PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 37.5%, 1)
     3834PASS HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 50%)
     3835PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 50%, 0)
     3836PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 50%, 0.2)
     3837PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 50%, 1)
     3838PASS HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 62.5%)
     3839PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 62.5%, 0)
     3840PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 62.5%, 0.2)
     3841PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 62.5%, 1)
    38423842PASS HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 75%)
    38433843PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 75%, 0)
    … …  
    38563856PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 0%, 0.2)
    38573857PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 0%, 1)
    3858 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 100%, 12.5%) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(63, 0, 0)"
    3859 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 12.5%, 0) assert_equals: expected "rgba(64, 0, 0, 0)" but got "rgba(63, 0, 0, 0)"
    3860 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 12.5%, 0.2) assert_equals: expected "rgba(64, 0, 0, 0.2)" but got "rgba(63, 0, 0, 0.2)"
    3861 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 12.5%, 1) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(63, 0, 0)"
    3862 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 100%, 25%) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(127, 0, 0)"
    3863 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 25%, 0) assert_equals: expected "rgba(128, 0, 0, 0)" but got "rgba(127, 0, 0, 0)"
    3864 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 25%, 0.2) assert_equals: expected "rgba(128, 0, 0, 0.2)" but got "rgba(127, 0, 0, 0.2)"
    3865 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 25%, 1) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(127, 0, 0)"
     3858PASS HSL/HSLA value should parse and round correctly: hsl(360, 100%, 12.5%)
     3859PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 12.5%, 0)
     3860PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 12.5%, 0.2)
     3861PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 12.5%, 1)
     3862PASS HSL/HSLA value should parse and round correctly: hsl(360, 100%, 25%)
     3863PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 25%, 0)
     3864PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 25%, 0.2)
     3865PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 25%, 1)
    38663866PASS HSL/HSLA value should parse and round correctly: hsl(360, 100%, 37.5%)
    38673867PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 37.5%, 0)
    … …  
    38723872PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 50%, 0.2)
    38733873PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 50%, 1)
    3874 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 100%, 62.5%) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(255, 63, 63)"
    3875 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 62.5%, 0) assert_equals: expected "rgba(255, 64, 64, 0)" but got "rgba(255, 63, 63, 0)"
    3876 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 62.5%, 0.2) assert_equals: expected "rgba(255, 64, 64, 0.2)" but got "rgba(255, 63, 63, 0.2)"
    3877 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 62.5%, 1) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(255, 63, 63)"
    3878 FAIL HSL/HSLA value should parse and round correctly: hsl(360, 100%, 75%) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(255, 127, 127)"
    3879 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 75%, 0) assert_equals: expected "rgba(255, 128, 128, 0)" but got "rgba(255, 127, 127, 0)"
    3880 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 75%, 0.2) assert_equals: expected "rgba(255, 128, 128, 0.2)" but got "rgba(255, 127, 127, 0.2)"
    3881 FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 75%, 1) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(255, 127, 127)"
     3874PASS HSL/HSLA value should parse and round correctly: hsl(360, 100%, 62.5%)
     3875PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 62.5%, 0)
     3876PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 62.5%, 0.2)
     3877PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 62.5%, 1)
     3878PASS HSL/HSLA value should parse and round correctly: hsl(360, 100%, 75%)
     3879PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 75%, 0)
     3880PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 75%, 0.2)
     3881PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 75%, 1)
    38823882PASS HSL/HSLA value should parse and round correctly: hsl(360, 100%, 87.5%)
    38833883PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 87.5%, 0)

  • trunk/LayoutTests/imported/w3c/web-platform-tests/css/css-color/parsing/color-computed-expected.txt

    r251739 r251750  
    1111FAIL Property color value 'rgba(2, 3, 4, 50%)' computes to 'rgba(2, 3, 4, 0.5)' assert_equals: expected "rgba(2, 3, 4, 0.5)" but got "rgba(2, 3, 4, 0.498039)"
    1212PASS Property color value 'hsl(120, 100%, 50%)' computes to 'rgb(0, 255, 0)'
    13 FAIL Property color value 'hsla(120, 100%, 50%, 0.25)' computes to 'rgba(0, 255, 0, 0.25)' assert_equals: expected "rgba(0, 255, 0, 0.25)" but got "rgba(0, 255, 0, 0.247059)"
     13FAIL Property color value 'hsla(120, 100%, 50%, 0.25)' computes to 'rgba(0, 255, 0, 0.25)' assert_equals: expected "rgba(0, 255, 0, 0.25)" but got "rgba(0, 255, 0, 0.25098)"
    1414PASS Property color value 'rgb(-2, 3, 4)' computes to 'rgb(0, 3, 4)'
    1515PASS Property color value 'rgb(100, 200, 300)' computes to 'rgb(100, 200, 255)'

  • trunk/LayoutTests/imported/w3c/web-platform-tests/css/css-color/parsing/color-valid-expected.txt

    r251739 r251750  
    1111FAIL e.style['color'] = "rgba(2, 3, 4, 50%)" should set the property value assert_equals: serialization should be canonical expected "rgba(2, 3, 4, 0.5)" but got "rgba(2, 3, 4, 0.498039)"
    1212PASS e.style['color'] = "hsl(120, 100%, 50%)" should set the property value
    13 FAIL e.style['color'] = "hsla(120, 100%, 50%, 0.25)" should set the property value assert_in_array: serialization should be sound value "rgba(0, 255, 0, 0.247059)" not in array ["rgba(0, 255, 0, 0.25)", "hsla(120, 100%, 50%, 0.25)"]
     13FAIL e.style['color'] = "hsla(120, 100%, 50%, 0.25)" should set the property value assert_in_array: serialization should be sound value "rgba(0, 255, 0, 0.25098)" not in array ["rgba(0, 255, 0, 0.25)", "hsla(120, 100%, 50%, 0.25)"]
    1414PASS e.style['color'] = "rgb(-2, 3, 4)" should set the property value
    1515PASS e.style['color'] = "rgb(100, 200, 300)" should set the property value

  • trunk/LayoutTests/platform/mac/fast/css/hsl-color-expected.txt

    r177774 r251750  
    1616        RenderText {#text} at (0,0) size 570x37
    1717          text run at (0,0) width 570: "This should be blue: hsl(240, 100%, 50%)"
    18       RenderBlock {H1} at (0,233) size 769x38 [color=#7FFF7F]
     18      RenderBlock {H1} at (0,233) size 769x38 [color=#80FF80]
    1919        RenderText {#text} at (0,0) size 657x37
    2020          text run at (0,0) width 657: "This should be light green: hsl(120, 100%, 75%)"
    21       RenderBlock {H1} at (0,292) size 769x38 [color=#007F00]
     21      RenderBlock {H1} at (0,292) size 769x38 [color=#008000]
    2222        RenderText {#text} at (0,0) size 660x37
    2323          text run at (0,0) width 660: "This should be dark green: hsl(120, 100%, 25%)"
    24       RenderBlock {H1} at (0,350) size 769x38 [color=#3FBF3F]
     24      RenderBlock {H1} at (0,350) size 769x38 [color=#40BF40]
    2525        RenderText {#text} at (0,0) size 659x37
    2626          text run at (0,0) width 659: "This should be pastel green: hsl(120, 50%, 50%)"
    … …  
    4141        RenderText {#text} at (0,0) size 480x18
    4242          text run at (0,0) width 480: "Check percentages less than 0% (negative values), should be limited to 0%"
    43       RenderBlock {H1} at (0,622) size 769x38 [color=#7F7F7F]
     43      RenderBlock {H1} at (0,622) size 769x38 [color=#808080]
    4444        RenderText {#text} at (0,0) size 539x37
    4545          text run at (0,0) width 539: "This should be grey: hsl(120, 0%, 50%)"
    46       RenderBlock {H1} at (0,681) size 769x38 [color=#7F7F7F]
     46      RenderBlock {H1} at (0,681) size 769x38 [color=#808080]
    4747        RenderText {#text} at (0,0) size 638x37
    4848          text run at (0,0) width 638: "This should be grey, too: hsl(120, -100%, 50%)"
    … …  
    5151          text run at (0,0) width 764: "Check Hue values that are larger than 360, should be normalized back to a value between 0 and 360. As Hue values are"
    5252          text run at (0,18) width 461: "in degrees, there is no maximum like percentages, they are loop around."
    53       RenderBlock {H1} at (0,797) size 769x38 [color=#007F00]
     53      RenderBlock {H1} at (0,797) size 769x38 [color=#008000]
    5454        RenderText {#text} at (0,0) size 660x37
    5555          text run at (0,0) width 660: "This should be dark green: hsl(120, 100%, 25%)"
    56       RenderBlock {H1} at (0,855) size 769x38 [color=#007F00]
     56      RenderBlock {H1} at (0,855) size 769x38 [color=#008000]
    5757        RenderText {#text} at (0,0) size 719x37
    5858          text run at (0,0) width 719: "This should be dark green, too: hsl(480, 100%, 25%)"
    … …  
    6060        RenderText {#text} at (0,0) size 261x18
    6161          text run at (0,0) width 261: "Check Hue values with a negative angle."
    62       RenderBlock {H1} at (0,953) size 769x38 [color=#7FFF7F]
     62      RenderBlock {H1} at (0,953) size 769x38 [color=#80FF80]
    6363        RenderText {#text} at (0,0) size 657x37
    6464          text run at (0,0) width 657: "This should be light green: hsl(120, 100%, 75%)"
    65       RenderBlock {H1} at (0,1011) size 769x38 [color=#7FFF7F]
     65      RenderBlock {H1} at (0,1011) size 769x38 [color=#80FF80]
    6666        RenderText {#text} at (0,0) size 726x37
    6767          text run at (0,0) width 726: "This should be light green, too: hsl(-240, 100%, 75%)"
    68       RenderBlock {H1} at (0,1070) size 769x38 [color=#7FFF7F]
     68      RenderBlock {H1} at (0,1070) size 769x38 [color=#80FF80]
    6969        RenderText {#text} at (0,0) size 726x37
    7070          text run at (0,0) width 726: "This should be light green, too: hsl(-600, 100%, 75%)"

  • trunk/LayoutTests/platform/mac/fast/css/hsla-color-expected.txt

    r161884 r251750  
    44  RenderBlock {HTML} at (0,0) size 800x600
    55    RenderBody {BODY} at (8,8) size 784x571 [bgcolor=#FFFF00]
    6       RenderBlock {H1} at (0,0) size 784x37 [color=#FF00007F]
     6      RenderBlock {H1} at (0,0) size 784x37 [color=#FF000080]
    77        RenderText {#text} at (0,0) size 394x37
    88          text run at (0,0) width 394: "This should be red, alpha 0.5"
    9       RenderBlock {H1} at (0,58) size 784x38 [color=#FF00007F]
     9      RenderBlock {H1} at (0,58) size 784x38 [color=#FF000080]
    1010        RenderText {#text} at (0,0) size 455x37
    1111          text run at (0,0) width 455: "This should also be red, alpha 0.5"

  • trunk/LayoutTests/svg/custom/fill-opacity-hsl-expected.txt

    r149088 r251750  
    44  RenderSVGRoot {svg} at (20,20) size 60x160
    55    RenderSVGRect {rect} at (20,20) size 60x60 [fill={[type=SOLID] [color=#00FF00]}] [x=20.00] [y=20.00] [width=60.00] [height=60.00]
    6     RenderSVGRect {rect} at (20,120) size 60x60 [fill={[type=SOLID] [color=#00FF003F]}] [x=20.00] [y=120.00] [width=60.00] [height=60.00]
     6    RenderSVGRect {rect} at (20,120) size 60x60 [fill={[type=SOLID] [color=#00FF0040]}] [x=20.00] [y=120.00] [width=60.00] [height=60.00]

  • trunk/Source/WebCore/ChangeLog

    r251746 r251750  
    9696        (WebCore::WebAnimation::shouldPreventEnteringBackForwardCache_DEPRECATED const): Deleted.
    9797        * animation/WebAnimation.h:
     98
     992019-10-29  Simon Fraser  <simon.fraser@apple.com>
     100
     101        Align CSS hsl() -> rgb() color conversion with the spec
     102        https://bugs.webkit.org/show_bug.cgi?id=203592
     103
     104        Reviewed by Tim Horton.
     105
     106        Fix lots of tests in css/css-color/color-resolving-hsl.html by matching the specified rounding
     107        when converting between hsl() and rgb().
     108       
     109        Remove some duplicated code, and call HSLToSRGB().
     110       
     111        Tested by WPT.
     112
     113        * css/parser/CSSPropertyParserHelpers.cpp:
     114        (WebCore::CSSPropertyParserHelpers::parseHSLParameters):
     115        * platform/graphics/Color.cpp:
     116        (WebCore::makeRGBAFromHSLA):
     117        (WebCore::calcHue): Deleted.
     118        * platform/graphics/Color.h:
    98119
    991202019-10-07  Jer Noble  <jer.noble@apple.com>

  • trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp

    r251668 r251750  
    637637    } else
    638638        angleInDegrees = hslValue->computeDegrees();
     639
    639640    double colorArray[3];
    640     // The hue needs to be in the range [0.0, 6.0) for calcHue()
    641     colorArray[0] = fmod(fmod(angleInDegrees, 360.0) + 360.0, 360.0) / 60.0;
     641    colorArray[0] = fmod(fmod(angleInDegrees, 360.0) + 360.0, 360.0) / 360.0;
    642642    bool requiresCommas = false;
    643643    for (int i = 1; i < 3; i++) {
    … …  
    673673        return Color();
    674674
    675     return Color(makeRGBAFromHSLA(colorArray[0], colorArray[1], colorArray[2], alpha));
     675    return Color(makeRGBAFromHSLA(static_cast<float>(colorArray[0]), static_cast<float>(colorArray[1]), static_cast<float>(colorArray[2]), static_cast<float>(alpha)));
    676676}
    677677

  • trunk/Source/WebCore/platform/graphics/Color.cpp

    r246042 r251750  
    2828
    2929#include "AnimationUtilities.h"
     30#include "ColorUtilities.h"
    3031#include "HashTools.h"
    3132#include <wtf/Assertions.h>
    … …  
    9798}
    9899
    99 static double calcHue(double temp1, double temp2, double hueVal)
    100 {
    101     if (hueVal < 0.0)
    102         hueVal += 6.0;
    103     else if (hueVal >= 6.0)
    104         hueVal -= 6.0;
    105     if (hueVal < 1.0)
    106         return temp1 + (temp2 - temp1) * hueVal;
    107     if (hueVal < 3.0)
    108         return temp2;
    109     if (hueVal < 4.0)
    110         return temp1 + (temp2 - temp1) * (4.0 - hueVal);
    111     return temp1;
    112 }
    113 
    114 // Explanation of this algorithm can be found in the CSS Color 4 Module
    115 // specification at https://drafts.csswg.org/css-color-4/#hsl-to-rgb with
    116 // further explanation available at http://en.wikipedia.org/wiki/HSL_color_space
    117 
    118 // Hue is in the range of 0 to 6.0, the remainder are in the range 0 to 1.0
    119 // FIXME: Use HSLToSRGB().
    120 RGBA32 makeRGBAFromHSLA(double hue, double saturation, double lightness, double alpha)
    121 {
    122     const double scaleFactor = nextafter(256.0, 0.0);
    123 
    124     if (!saturation) {
    125         int greyValue = static_cast<int>(lightness * scaleFactor);
    126         return makeRGBA(greyValue, greyValue, greyValue, static_cast<int>(alpha * scaleFactor));
    127     }
    128 
    129     double temp2 = lightness <= 0.5 ? lightness * (1.0 + saturation) : lightness + saturation - lightness * saturation;
    130     double temp1 = 2.0 * lightness - temp2;
    131    
    132     return makeRGBA(static_cast<int>(calcHue(temp1, temp2, hue + 2.0) * scaleFactor),
    133                     static_cast<int>(calcHue(temp1, temp2, hue) * scaleFactor),
    134                     static_cast<int>(calcHue(temp1, temp2, hue - 2.0) * scaleFactor),
    135                     static_cast<int>(alpha * scaleFactor));
     100RGBA32 makeRGBAFromHSLA(float hue, float saturation, float lightness, float alpha)
     101{
     102    const float scaleFactor = 255.0;
     103    FloatComponents floatResult = HSLToSRGB({ hue, saturation, lightness, alpha });
     104    return makeRGBA(
     105        round(floatResult.components[0] * scaleFactor),
     106        round(floatResult.components[1] * scaleFactor),
     107        round(floatResult.components[2] * scaleFactor),
     108        round(floatResult.components[3] * scaleFactor));
    136109}
    137110

  • trunk/Source/WebCore/platform/graphics/Color.h

    r246632 r251750  
    7171
    7272WEBCORE_EXPORT RGBA32 makeRGBA32FromFloats(float r, float g, float b, float a);
    73 RGBA32 makeRGBAFromHSLA(double h, double s, double l, double a);
     73RGBA32 makeRGBAFromHSLA(float h, float s, float l, float a);
    7474RGBA32 makeRGBAFromCMYKA(float c, float m, float y, float k, float a);
    7575
Note: See TracChangeset for help on using the changeset viewer.